local defs = require('defs')
local class = require('mc.class')
local context = require('mc.context')
local hwproxy_objects = require('hwproxy_objects')
local shared_object = require('shared_object')
local hwproxy_error = require('hwproxy.errors')
local chip_types = require('hwproxy.json_types.keplerChip')
local object_defs = require('object_defs')
local hw_utils = require('hw_utils.utils')
local vos = require('utils.vos')
local utils_core = require('utils.core')
local utils = require('mc.utils')
local bus = require('hwproxy_objects.app_bus')
local log = require('mc.logging')
local queue = require('skynet.queue')
local skynet = require('skynet')
local ser = require('serialize')
local client = require('client')
local is_utf8 = utils_core.utf8_validate
local telemetry = require('telemetry')
local trace = require('telemetry.trace')
local SetLockStatusResultCode = chip_types.SetLockStatusResultCode
local skynet_sleep = skynet.sleep
local LOCK_TIME = defs.LOCK_TIME
local LOCK_STATUS = defs.LOCK_STATUS
local LOCK_OP_TYPE = defs.LOCK_OP_TYPE
local table_compare = utils.table_compare
local CHIP_INTERFACE = 'bmc.kepler.Chip'
local SCANNER_INTERFACE <const> = 'bmc.kepler.Scanner'
local ACCESSOR_INTERFACE <const> = 'bmc.kepler.Accessor'
local AGGREGATE_INTERFACE <const> = 'bmc.kepler.Scanner.Aggregate'
local MIN_DISABLE_DURATION <const> = 1
local MAX_DISABLE_DURATION <const> = 1800
local SCAN_DISABLED <const> = 0
local SCAN_NOT_ACCESSIBLE <const> = 3
local function get_topo_data(self, position)
local generate_topo = function(obj)
local topo_str = obj:GetTopology_PACKED(context.new()):unpack(true)
log:hw_stream_notice('position: %s, get topology successfully, topology: %s', position, topo_str)
self.topo_data[position] = topo_str and ser.decode(topo_str) or nil
end
local ret, obj
for _ = 1, 10 do
ret, obj = pcall(client.GetObjectGroupObjectGroupObject, client, { Id = position })
if ret then
generate_topo(obj)
return
end
skynet_sleep(100)
end
log:warn('position: %s get topology failed ret: %s', position, obj)
end
local function sync_telemetry(obj)
obj.stream:send('dlog_level_change', log:getLevel())
obj.stream:send('trace_status_change', telemetry.get_status())
obj.stream:send('trace_status_change', telemetry.get_status(telemetry.lOGS), telemetry.lOGS)
obj.stream:send('trace_status_change', telemetry.get_status(telemetry.METRICS), telemetry.METRICS)
obj.stream:send('trace_flags_change', 'load_sampling_rate', trace.get_trace_flag('load_sampling_rate'))
obj.stream:send('trace_flags_change', 'sampling_rate', trace.get_trace_flag('sampling_rate'))
obj.stream:send('trace_flags_change', 'sampling_level', trace.get_trace_flag('sampling_level'))
end
local app_objects = class(hwproxy_objects)
function app_objects:ctor(_, dbus)
self.cache_objects = {}
self.bus_objects = {}
self.cache_position = {}
self.wait_register_objects = {}
self.wait_register_dft = {}
skynet.fork(function()
self.monitor_service = skynet.uniqueservice('hwproxy/service/monitor')
skynet.send(self.monitor_service, 'lua', 'set_debug_log_level', log:getLevel())
end)
self.registed_accessor_cb = {}
self.dbus = dbus
self.thread_handler = {}
self.thread_queue = queue()
self.merge_work_bus = {}
self.bus_name_to_merge_key = {}
self.locked_buses = {}
end
function app_objects:new_bus(object)
local bus_obj = bus.new(object)
local addr = bus_obj.stream.work
local merge_key = bus_obj.stream.merge_key
if merge_key then
self.bus_name_to_merge_key[object.name] = merge_key
if not self.merge_work_bus[merge_key] then
self.merge_work_bus[merge_key] = {}
end
table.insert(self.merge_work_bus[merge_key], object.name)
skynet.send(self.monitor_service, 'lua', 'register', object.name, addr, merge_key)
sync_telemetry(bus_obj)
else
skynet.send(self.monitor_service, 'lua', 'register', object.name, addr)
sync_telemetry(bus_obj)
end
bus_obj.stream:send('create_hwproxy_object', object.name)
local tree = shared_object.create_tree()
bus_obj:set_raw_dbus(self.dbus.bus.conn:to_raw(true), tree:to_raw())
return bus_obj
end
function app_objects:cache_forward_object(position, object)
local objects = self.cache_objects[position]
if not objects then
objects = {}
self.cache_objects[position] = objects
end
local new_object = { name = object.name, class_name = object.class_name, path = object.path }
if object.class_name == 'Scanner' then
new_object.props = utils.merge_table(object[SCANNER_INTERFACE].props, object[AGGREGATE_INTERFACE].props)
new_object.is_work = true
elseif object_defs[object.class_name]['type'] == 'Chip' then
new_object.props = object[CHIP_INTERFACE] and object[CHIP_INTERFACE].props or {}
new_object.is_work = true
end
local props = object:get_all_prop_names()
if object.class_name == 'Accessor' then
new_object.prop_precisions = object[ACCESSOR_INTERFACE].prop_precisions
elseif object.class_name == 'Scanner' then
new_object.prop_precisions = object[SCANNER_INTERFACE].prop_precisions
end
for _, v in ipairs(props) do
if (object.class_name ~= 'Accessor' and object.class_name ~= 'Scanner') or v ~= 'Value' then
new_object[v] = object[v]
end
end
new_object.need_register = true
objects[object.name] = new_object
end
function app_objects:bus_object_handle(class_name, object, position)
object:register_mdb_objects()
self.super.bus_object_handle(self, class_name, object, position)
self:cache_forward_object(position, object)
end
function app_objects:chip_object_handle(class_name, object, position)
self.wait_register_objects[object.name] = object
self.super.chip_object_handle(self, class_name, object, position)
self:cache_forward_object(position, object)
local obj = object[CHIP_INTERFACE]
if obj then
shared_object.create_shared_values(obj)
obj.force_write = true
obj.property_before_change:on(function(name, value, sender)
if name == 'HealthStatus' and sender ~= nil then
local chip_name = self:get_chip_name(obj)
local host_bus = self.chips[chip_name].host_bus
host_bus.stream:call('set_health_status', { path = obj.path, chip = obj.chip }, value)
end
end)
end
object.property_changed:on(function(name, value)
if name == 'DrvWriteDelay' then
local host_bus = self.chips[object.name].host_bus
if not host_bus then
return
end
log:notice('chip: %s, sync DrvWriteDelay change to: %d', object.name, value)
host_bus.stream:call('update_drv_write_delay', object.name, value)
end
end)
end
function app_objects:register_property_read(obj, object)
obj.property_read:on(function(name)
local ctx_emit = context.get_context()
if name == 'Status' or (ctx_emit and ctx_emit.AccessMode == 'Cache') then
return true
end
local span = trace.start_span(
'hwproxy.app_objects.property_read',
trace.get_status() and { ['accessor.name'] = object.name } or nil
)
local offset = object.Offset
local ret = self:realtime_read(self.chips[object.Chip].host_bus, object.name, ctx_emit, offset)
if is_utf8(ret) and object.Type == 1 then
obj['PrintableValue'] = ret
end
obj['Value'] = ret
span:finish()
return true
end)
end
function app_objects:setup_accessor_interface(obj, object)
if object[ACCESSOR_INTERFACE] then
obj.property_before_change:on(function(name, value, sender)
local ctx = context.get_context()
if not sender or context.is_override() then
return true
end
local span = trace.start_span(
'hwproxy.app_objects.property_before_change',
trace.get_status() and { ['accessor.name'] = object.name } or nil
)
self:realtime_write(self.chips[object.Chip].host_bus, object.name, ctx, value)
span:finish()
return true
end)
self:register_property_read(obj, object)
end
end
function app_objects:resource_object_handle(class_name, object, position)
if not object.Chip or object.Chip == '' then
log:error('invalid chip object for resource %s', object.name)
return
end
self.wait_register_objects[object.name] = object
local obj = object[SCANNER_INTERFACE] or object[ACCESSOR_INTERFACE]
obj.force_write = true
if object[SCANNER_INTERFACE] then
self:handle_scanner_interface(object, position)
end
self:handle_aggregate_interface(object)
self:setup_accessor_interface(obj, object)
self:set_encoding_functions(obj)
app_objects.super.resource_object_handle(self, class_name, object, position)
self:cache_forward_object(position, object)
end
function app_objects:handle_scanner_interface(object, position)
object.property_changed:on(function(name, value)
if name ~= 'ScanEnabled' then
return
end
if not self.chips[object.Chip] or not self.chips[object.Chip].host_bus then
if name == 'ScanEnabled' then
self:cache_forward_object(position, object)
end
return
end
if value == SCAN_DISABLED then
object[SCANNER_INTERFACE]:clear_error('Value')
object.Value = utils.dbus_value_to_binary(object.NominalValue, 't')
object.Status = utils.dbus_value_to_binary(SCAN_NOT_ACCESSIBLE, 'y')
end
log:notice('scanner: %s change scan enabled to: %s', object.name, value)
end)
shared_object.create_shared_values(object[SCANNER_INTERFACE], object)
if object.ScanEnabled == SCAN_DISABLED then
object.Value = object.NominalValue
object.Status = SCAN_NOT_ACCESSIBLE
log:notice('scanner: %s scan enabled initial value: %d', object.name, object.ScanEnabled)
end
end
function app_objects:handle_aggregate_interface(object)
local aggregare_intf_obj = object[AGGREGATE_INTERFACE]
if aggregare_intf_obj then
shared_object.create_shared_values(aggregare_intf_obj)
end
end
function app_objects:set_encoding_functions(obj)
obj:set_decoder(function(_, value, type)
return utils.binary_to_dbus_type(value, type)
end)
obj:set_encoder(function(_, value, type)
return utils.dbus_value_to_binary(value, type)
end)
end
function app_objects:mux_object_handle(class_name, object, position)
object:register_mdb_objects()
app_objects.super.mux_object_handle(self, class_name, object, position)
self:cache_forward_object(position, object)
end
function app_objects:debounce_object_handle(class_name, object, position)
object:register_mdb_objects()
app_objects.super.debounce_object_handle(self, class_name, object, position)
self:cache_forward_object(position, object)
end
function app_objects:dft_object_handle(class_name, object, position)
self.wait_register_dft[object.RefChip] = self.wait_register_dft[object.RefChip] or {}
self.wait_register_dft[object.RefChip][object.name] = object
app_objects.super.dft_object_handle(self, class_name, object, position)
self:cache_forward_object(position, object)
end
function app_objects:smc_dfx_info_handle(class_name, object, position)
app_objects.super.smc_dfx_info_handle(self, class_name, object, position)
self:cache_forward_object(position, object)
end
function app_objects:on_add_object_complete(position)
get_topo_data(self, position)
app_objects.super.on_add_object_complete(self, position)
local bus_objects = self.bus_objects
local has_object_buses = {}
for _, object in pairs(self.cache_objects[position]) do
local name = object.name
if self.buses[name] then
bus_objects[name] = { self.buses[name] }
elseif self.chips[name] then
bus_objects[name] = { self.chips[name].host_bus }
elseif object.Chip then
if object.Chip ~= '' then
bus_objects[name] = { self.chips[object.Chip].host_bus }
end
elseif self.mux_data[name] then
if self.chips[self.mux_data[name].pre_device] then
bus_objects[name] = { self.chips[self.mux_data[name].pre_device].host_bus }
end
else
bus_objects[name] = self.buses
end
for _, v in pairs(bus_objects[name] or {}) do
has_object_buses[v.name] = v
v:add_object(object.class_name, object, position)
end
end
for _, v in pairs(has_object_buses) do
skynet.send(self.monitor_service, 'lua', 'add_work_monitor', _, position)
v:add_object_complete(position, self.topo_data[position], self.monitor_service)
end
self.cache_position[#self.cache_position + 1] = position
end
function app_objects:on_delete_object(class_name, object, position)
local name = object.name
local bus_objects = self.bus_objects
if object.LockStatus and object.LockStatus == 1 then
self:unlock(object, {}, true)
end
for _, v in pairs(bus_objects[name] or {}) do
v:delete_object(class_name, { name = name }, position)
end
bus_objects[name] = nil
if self.cache_objects[position] then
self.cache_objects[position][object.name] = nil
end
app_objects.super.on_delete_object(self, class_name, object, position)
end
function app_objects:on_delete_object_complete(position)
for _, v in pairs(self.buses) do
v:delete_object_complete(position)
end
app_objects.super.on_delete_object_complete(self, position)
for index, pos in ipairs(self.cache_position) do
if pos == position then
table.remove(self.cache_position, index)
break
end
end
end
function app_objects:trace_status_change(status, kind)
for _, bus_obj in pairs(self.buses) do
bus_obj.stream:send('trace_status_change', status, kind)
end
end
function app_objects:trace_flags_change(flag, value)
for _, bus_obj in pairs(self.buses) do
bus_obj.stream:send('trace_flags_change', flag, value)
end
end
function app_objects:dlog_level_change(dlog_level)
for _, bus_obj in pairs(self.buses) do
bus_obj.stream:send('dlog_level_change', dlog_level)
end
skynet.send(self.monitor_service, 'lua', 'set_debug_log_level', dlog_level)
end
function app_objects:dlog_type_change(dlog_type)
for _, bus_obj in pairs(self.buses) do
bus_obj.stream:send('dlog_type_change', dlog_type)
end
end
function app_objects:read_write_func(func_name, obj, ctx, ...)
if getmetatable(ctx) == context or type(ctx) == 'table' then
if ctx.RPCTimeCost == 'used' then
ctx.RPCTimeCost = vos.vos_tick_get()
else
ctx.RPCTimeCost = nil
end
end
local span = trace.start_span(
'hwproxy.app_objects.read_write_func',
trace.get_status() and { ['func.name'] = func_name, ['chip.name'] = obj.path } or nil
)
local chip_name = self:get_chip_name(obj)
local host_bus = self.chips[chip_name].host_bus
local results =
{ host_bus.stream:call('read_write_func', func_name, { path = obj.path, chip = obj.chip }, ctx, ...) }
span:finish()
return table.unpack(results)
end
function app_objects:bus_read_write_func(func_name, obj, ctx, ...)
local chip_name = self:get_vchip_name(obj)
local host_bus = self.chips[chip_name].host_bus
return host_bus.stream:call('read_write_func', func_name, { chip = chip_name }, ctx and ctx or context.new(), ...)
end
function app_objects:cpld_upg_request(op, obj, ctx, ...)
local chip_name = self:get_chip_name(obj)
local host_bus = self.chips[chip_name].host_bus
return host_bus.stream:call('cpld_upg_request', op, { path = obj.path }, ctx and ctx or context.new(), ...)
end
function app_objects:accessor_operate(op, accessor_name, value)
local ref_chip = self.accessor_ref_chip[accessor_name]
if not ref_chip then
error(hwproxy_error.chip_not_exist_error())
end
local ctx = context.get_context()
if op == 'Read' then
return self:realtime_read(ref_chip.host_bus, accessor_name, ctx)
elseif op == 'Write' then
value = utils.dbus_value_to_binary(value, 'x')
return self:realtime_write(ref_chip.host_bus, accessor_name, ctx, value)
end
end
function app_objects:realtime_read(host_bus, accessor_name, ctx, offset)
return host_bus.stream:call('realtime_read', {}, accessor_name, ctx and ctx or context.new(), offset)
end
function app_objects:realtime_write(host_bus, accessor_name, ctx, value)
return host_bus.stream:call('realtime_write', {}, accessor_name, ctx and ctx or context.new(), value)
end
function app_objects:chip_test(obj)
local ref_chip_name = self:get_ref_chip_name(obj)
local host_bus = self.chips[ref_chip_name].host_bus
local obj_name = self:get_object_name_from_path(obj)
local dtf_obj = self.dft_list[obj_name]
return host_bus.stream:call('chip_test', { path = obj.path, offset = dtf_obj.Offset, len = dtf_obj.Size })
end
function app_objects:update_resource(chip_name, resource_names, ok, ret)
local t_chip = self.chips[chip_name]
if t_chip == nil then
return
end
local resources = {}
for _, work_res in ipairs(resource_names) do
local work_res_name = work_res.name
local res = t_chip.accessors[work_res_name] or t_chip.scanners[work_res_name]
if not res then
goto continue
end
local work_res_scan_status = work_res.scan_status
for _, app_res in ipairs(res.resources) do
if app_res.name == work_res_name then
app_res.scan_status = work_res_scan_status
resources[#resources + 1] = app_res
end
end
::continue::
end
t_chip:update_resource(resources, ok, ret)
end
function app_objects:handle_chip_scanners(obj, _, Status, DisableDuration)
local chip_name = self:get_chip_name(obj)
local host_bus = self.chips[chip_name].host_bus
if DisableDuration < MIN_DISABLE_DURATION or DisableDuration > MAX_DISABLE_DURATION then
log:raise(
'Invalid Parameter! DisableDuration Range is:[%d, %d], current DisableDuration is %d',
MIN_DISABLE_DURATION,
MAX_DISABLE_DURATION,
DisableDuration
)
end
if Status == false then
return host_bus.stream:call('stop_chip_scanners', { path = obj.path }, DisableDuration)
else
return host_bus.stream:call('restart_chip_scanners', { path = obj.path })
end
end
function app_objects:lock(obj, ctx, lock_time)
if lock_time < LOCK_TIME.MIN or lock_time > LOCK_TIME.MAX then
return SetLockStatusResultCode.InvalidParameter
end
local chip_name = self:get_chip_name(obj)
local chip = self.chips[chip_name]
local bus_name = chip.host_bus.name
local channel_chain = chip.channel_chain
local requestor = ctx.Requestor or 'unknown'
local lock_info = self.locked_buses[bus_name]
if lock_info ~= nil then
if requestor ~= lock_info.requestor then
return SetLockStatusResultCode.RequestorMismatchedError
end
if chip_name ~= lock_info.chip_name then
return (channel_chain == lock_info.channel_chain) and SetLockStatusResultCode.ChipMismatchedError
or SetLockStatusResultCode.ChannelMismatchedError
end
skynet.killthread(lock_info.co)
self.locked_buses[bus_name] = nil
end
local co = skynet.timeout(lock_time * 100, function()
self.locked_buses[bus_name] = nil
obj.LockStatus = LOCK_STATUS.UNLOCKED
log:notice(
'channel automatic unlocked upon timeout, bus: %s, channel_chain: %s, chip: %s',
bus_name,
channel_chain,
chip_name
)
end)
self.locked_buses[bus_name] =
{ co = co, requestor = requestor, chip_name = chip_name, channel_chain = channel_chain }
obj.LockStatus = LOCK_STATUS.LOCKED
if lock_info ~= nil then
log:notice(
'[%s] renew lock status for %s seconds successfully, bus: %s, channel_chain: %s, chip: %s',
requestor,
lock_time,
bus_name,
channel_chain,
chip_name
)
else
log:notice(
'[%s] lock channel for %s seconds successfully, bus: %s, channel_chain: %s, chip: %s',
requestor,
lock_time,
bus_name,
channel_chain,
chip_name
)
end
return SetLockStatusResultCode.OK
end
function app_objects:unlock(obj, ctx, is_force_unlock)
local chip_name = self:get_chip_name(obj)
local chip = self.chips[chip_name]
local bus_name = chip.host_bus.name
local lock_info = self.locked_buses[bus_name]
local requestor = ctx.Requestor or 'unknown'
local channel_chain = chip.channel_chain
if not is_force_unlock then
if lock_info == nil then
return SetLockStatusResultCode.UnlockedError
end
if requestor ~= lock_info.requestor then
return SetLockStatusResultCode.RequestorMismatchedError
end
if chip_name ~= lock_info.chip_name then
return (channel_chain == lock_info.channel_chain) and SetLockStatusResultCode.ChipMismatchedError
or SetLockStatusResultCode.ChannelMismatchedError
end
end
skynet.killthread(lock_info.co)
self.locked_buses[bus_name] = nil
obj.LockStatus = LOCK_STATUS.UNLOCKED
log:notice(
'[%s] unlock channel successfully, bus: %s, channel_chain: %s, chip: %s',
requestor,
bus_name,
channel_chain,
chip_name
)
return SetLockStatusResultCode.OK
end
function app_objects:set_lock_status(obj, ctx, op_type, lock_time)
if op_type == LOCK_OP_TYPE.LOCK then
return self:lock(obj, ctx, lock_time)
elseif op_type == LOCK_OP_TYPE.UNLOCK then
return self:unlock(obj, ctx)
end
return SetLockStatusResultCode.InvalidParameter
end
function app_objects:porcess_accessibility(obj, host_bus, bus_name, status, disable_duration)
if self.thread_handler[bus_name] then
skynet.killthread(self.thread_handler[bus_name])
self.thread_handler[bus_name] = nil
end
if not status then
host_bus.stream:call('stop_bus_access', disable_duration)
obj.AccessEnabled = false
obj.Timeout = disable_duration
self.thread_handler[bus_name] = skynet.fork_once(function()
while disable_duration >= 0 do
local psuse_time = disable_duration >= 10 and 1000 or (disable_duration * 100)
skynet_sleep(psuse_time)
disable_duration = disable_duration - 10
obj.Timeout = disable_duration > 0 and disable_duration or 0
end
host_bus.stream:call('restart_bus_access')
obj.AccessEnabled = true
self.thread_handler[bus_name] = nil
end)
else
host_bus.stream:call('restart_bus_access')
obj.AccessEnabled = true
obj.Timeout = 0
end
end
function app_objects:handle_bus_accessibility(obj, _, status, disable_duration)
if obj.AccessEnabled and status then
log:info('The current link access status is already enabled.')
return
end
if disable_duration < MIN_DISABLE_DURATION or disable_duration > MAX_DISABLE_DURATION then
log:raise(
'Invalid Parameter! DisableDuration Range is:[%d, %d], current DisableDuration is %d',
MIN_DISABLE_DURATION,
MAX_DISABLE_DURATION,
disable_duration
)
end
local bus_name = self:get_bus_name(obj)
local host_bus = self.buses[bus_name]
self.thread_queue(function()
self:porcess_accessibility(obj, host_bus, bus_name, status, disable_duration)
end)
end
local scanner_map = { 'Status', 'Value' }
function app_objects:check_scanner_shm_value(object, object_name, chip_name)
for _, value_name in ipairs(scanner_map) do
local shm_prop_value = hw_utils.get_shm_prop(object.path, SCANNER_INTERFACE, value_name)
if shm_prop_value and not table_compare(object[value_name], shm_prop_value) then
local host_bus = self.chips[chip_name].host_bus
host_bus.stream:send('update_scanner_shm_value', object_name, value_name)
end
end
end
function app_objects:object_register(object_name, chip_name)
if not self.wait_register_objects[object_name] then
log:mcf_error('object_register failed, %s not exist', object_name)
return
end
local object = self.wait_register_objects[object_name]
if object.register_mdb_objects then
object:register_mdb_objects()
end
if object[SCANNER_INTERFACE] then
local ok, err = pcall(self.check_scanner_shm_value, self, object, object_name, chip_name)
if not ok then
log:warn(
'check scanner shm value failed, scanner name: %s, chip name: %s, err: %s',
object_name,
chip_name,
err
)
end
end
self.wait_register_objects[object_name] = nil
if self.wait_register_dft[object_name] then
for _, obj in pairs(self.wait_register_dft[object_name]) do
if obj.register_mdb_objects then
obj:register_mdb_objects()
end
end
self.wait_register_dft[object_name] = nil
end
log:mcf_debug('object: %s register to resource tree', object_name)
end
function app_objects:get_bus_object(bus_name)
for _, objs in pairs(self.cache_objects) do
for _, obj in pairs(objs) do
if obj.name == bus_name then
return obj
end
end
end
end
function app_objects:plugin_request(obj, ctx, ...)
local chip_name = self:get_chip_name(obj)
local host_bus = self.chips[chip_name].host_bus
return host_bus.stream:call('plugin_request', { path = obj.path }, ctx, ...)
end
function app_objects:mock_scanner_failure(obj, ctx, scanner_name, disable_duration)
local chip = self.scanner_ref_chip[scanner_name]
if not chip then
log:raise('scanner %s not exist', scanner_name)
end
return chip.host_bus.stream:call('mock_scanner_failure', scanner_name, disable_duration)
end
function app_objects:mock_bus_ctrl(obj, ctx, bus_name, action)
if not self.buses[bus_name] then
log:raise('bus %s not exist', bus_name)
end
return skynet.call(self.buses[bus_name].stream.work, 'lua', 'mock_bus_ctrl', action)
end
function app_objects:monitor_obj(obj, ctx, action)
local chip_name = self:get_chip_name(obj)
local chip_obj = self.chips[chip_name]
if not chip_obj then
log:raise(string.format('obj %s does not exist', chip_name))
end
return chip_obj.host_bus.stream:call('monitor_obj', { path = obj.path, chip = obj.chip }, ctx, action)
end
function app_objects:trace_scanner_debounce(object, ctx, action)
local scanner_name = self:get_object_name_from_path(object)
local chip_obj = self.scanner_ref_chip[scanner_name]
chip_obj.host_bus.stream:call('trace_scanner_debounce', { name = scanner_name }, ctx, action)
end
function app_objects:on_reboot_action()
local ok, err, bus_obj_stream
for _, bus_obj in pairs(self.buses) do
bus_obj_stream = bus_obj.stream
ok, err = pcall(bus_obj_stream.call, bus_obj_stream, 'on_reboot_action')
if not ok then
log:warn('on_reboot_action failed bus_name: %s, err: %s', bus_obj.name, err)
end
end
end
local add_object_to_bus = function(bus_obj, object, position, bus_object_name)
if bus_obj.name ~= bus_object_name then
return
end
bus_obj:add_object(object.class_name, object, position)
end
local function restart_bus_service(self, bus_obj, bus_object_name)
local tree = shared_object.create_tree()
bus_obj:set_raw_dbus(self.dbus.bus.conn:to_raw(true), tree:to_raw())
for _, position in ipairs(self.cache_position) do
for _, object in pairs(self.cache_objects[position]) do
local name = object.name
for _, v in pairs(self.bus_objects[name] or {}) do
add_object_to_bus(v, object, position, bus_object_name)
end
end
skynet.send(self.monitor_service, 'lua', 'add_work_monitor', bus_object_name, position)
bus_obj:add_object_complete(position, self.topo_data[position], self.monitor_service)
end
end
function app_objects:restart_work_service(bus_name)
local merge_key = self.bus_name_to_merge_key[bus_name]
local group_key = merge_key or bus_name
local addr = skynet.newservice('hwproxy/service/work', bus_name)
local ok, err = pcall(function(...)
if self.merge_work_bus[group_key] then
bus.update_work_addr(group_key, addr)
local bus_obj
for _, v in pairs(self.merge_work_bus[group_key]) do
bus_obj = self.buses[v]
bus_obj.stream.work = addr
bus_obj.stream:send('create_hwproxy_object', v)
restart_bus_service(self, bus_obj, v)
end
if bus_obj then
sync_telemetry(bus_obj)
end
else
local bus_obj = self.buses[bus_name]
bus_obj.stream.work = addr
bus_obj.stream:send('create_hwproxy_object', bus_name)
sync_telemetry(bus_obj)
restart_bus_service(self, bus_obj, bus_name)
end
end)
if not ok then
log:error('restart work service failed, error: %s', err)
end
return addr
end
return app_objects