Activate this register to turn on a minion status tracking register, this
    register keeps the current status beacon data and the time that each beacon
    was last checked in.
334585
def reg(name):
    '''
    
    '''
    ret = {'name': name,
           'changes': {},
           'comment': '',
           'result': True}
    now = time.time()
    if 'status' not in __reg__:
        __reg__['status'] = {}
        __reg__['status']['val'] = {}
    for event in __events__:
        if fnmatch.fnmatch(event['tag'], 'salt/beacon/*/status/*'):
            # Got one!
            idata = {'recv_time': now}
            for key in event['data']['data']:
                if key in ('id', 'recv_time'):
                    continue
                idata[key] = event['data']['data'][key]
            __reg__['status']['val'][event['data']['id']] = idata
            ret['changes'][event['data']['id']] = True
    return ret
672775
def activated(self, item):
        """"""
        data = self.data.get(id(item))
        if data is not None:
            fname, lineno = data
            self.sig_edit_goto.emit(fname, lineno, '')
441073
def _process_status(self, status):
        
        self._screen_id = status.get(ATTR_SCREEN_ID)
        self.status_update_event.set()
879766
void registerAppReInit() {
        // on re-init make sure GAID is available
        if (!trackingController.isTrackingDisabled()) { // Do not get GAID when tracking is disabled
            isGAParamsFetchInProgress_ = deviceInfo_.getSystemObserver().prefetchGAdsParams(context_, this);
        }
        if (networkCount_ != 0) {
            networkCount_ = 0;
            requestQueue_.clear();
        }
        ServerRequest initRequest = getInstallOrOpenRequest(null);
        if(isGAParamsFetchInProgress_) {
            initRequest.addProcessWaitLock(ServerRequest.PROCESS_WAIT_LOCK.GAID_FETCH_WAIT_LOCK);
        }
        registerInstallOrOpen(initRequest, null);
    }
590975
def register(self):
        
        # logger.debug("StateMachineEditionChangeHistory register state_machine old/new sm_id %s/%s" %
        #              (self.__my_selected_sm_id, self.model.selected_state_machine_id))

        # relieve old models
        if self.__my_selected_sm_id is not None:  # no old models available
            self.relieve_model(self._selected_sm_model.history)

        if self.model.selected_state_machine_id is not None and global_gui_config.get_config_value('HISTORY_ENABLED'):

            # set own selected state machine id
            self.__my_selected_sm_id = self.model.selected_state_machine_id

            # observe new models
            self._selected_sm_model = self.model.state_machines[self.__my_selected_sm_id]
            if self._selected_sm_model.history:
                self.observe_model(self._selected_sm_model.history)
                self.update(None, None, None)
            else:
                logger.warning("The history is enabled but not generated {0}. {1}"
                               "".format(self._selected_sm_model.state_machine.state_machine_id,
                                         self._selected_sm_model.state_machine.file_system_path))
        else:
            if self.__my_selected_sm_id is not None:
                self.doing_update = True
                self.history_tree_store.clear()
                self.doing_update = False
            self.__my_selected_sm_id = None
            self._selected_sm_model = None
562222
def SetStatus(self, status, message="", backtrace=None):
    """"""
    self.status.status = status
    self.status.error_message = utils.SmartUnicode(message)
    if backtrace:
      self.status.backtrace = utils.SmartUnicode(backtrace)
43453
protected void setPageStatus(IStatus status) {
		this.status = status == null ? SARLEclipsePlugin.getDefault().createOkStatus() : status;
	}
889349
def active(display_progress=False):
    '''
    
    '''
    ret = {}
    client = salt.client.get_local_client(__opts__['conf_file'])
    try:
        active_ = client.cmd('*', 'saltutil.running', timeout=__opts__['timeout'])
    except SaltClientError as client_error:
        print(client_error)
        return ret

    if display_progress:
        __jid_event__.fire_event({
            'message': 'Attempting to contact minions: {0}'.format(list(active_.keys()))
            }, 'progress')
    for minion, data in six.iteritems(active_):
        if display_progress:
            __jid_event__.fire_event({'message': 'Received reply from minion {0}'.format(minion)}, 'progress')
        if not isinstance(data, list):
            continue
        for job in data:
            if not job['jid'] in ret:
                ret[job['jid']] = _format_jid_instance(job['jid'], job)
                ret[job['jid']].update({'Running': [{minion: job.get('pid', None)}], 'Returned': []})
            else:
                ret[job['jid']]['Running'].append({minion: job['pid']})

    mminion = salt.minion.MasterMinion(__opts__)
    for jid in ret:
        returner = _get_returner((__opts__['ext_job_cache'], __opts__['master_job_cache']))
        data = mminion.returners['{0}.get_jid'.format(returner)](jid)
        if data:
            for minion in data:
                if minion not in ret[jid]['Returned']:
                    ret[jid]['Returned'].append(minion)

    return ret
1007164
def notify(self, data):
        """"""
        string_channels = {
            ChannelIdentifiers.de_registrations,
            ChannelIdentifiers.registrations_expired
        }

        if data['channel'] in string_channels:
            message = {'device_id': data["value"], 'channel': data["channel"]}
        else:
            message = DeviceStateChanges._map_endpoint_data(data)

        return super(DeviceStateChanges, self).notify(message)
974949
def list_available_beacons(self):
        '''
        
        '''
        _beacons = ['{0}'.format(_beacon.replace('.beacon', ''))
                    for _beacon in self.beacons if '.beacon' in _beacon]

        # Fire the complete event back along with the list of beacons
        evt = salt.utils.event.get_event('minion', opts=self.opts)
        evt.fire_event({'complete': True, 'beacons': _beacons},
                       tag='/salt/minion/minion_beacons_list_available_complete')

        return True
274738
def register_watchers(self, type_callback_dict, register_timeout=None):
        
        for event_type, callback in type_callback_dict.items():
            self._push_watchers[event_type].add(callback)
        self.wait_for_response(
            RegisterMessage(event_list=type_callback_dict.keys()),
            timeout=register_timeout)
868713
function() {
        registerDeviceTimeoutId && clearTimeout(registerDeviceTimeoutId);
        registerServerTimeoutId && clearTimeout(registerServerTimeoutId);
        checkIfSocketHasOpennedTimeoutId && clearTimeout(checkIfSocketHasOpennedTimeoutId);
        socketReconnectCheck && clearTimeout(socketReconnectCheck);
      }
484390
function status (cb) {
    var i, m1, filearray = []
    if (my.args.length > 0) {
      console.log('ignoring extra arguments')
    }
    for (i in my.state.trackedfiles) {
      filearray.push( path.basename(i) )
    }
    m1 = [
      , 'Using bin ' + path.basename(getActiveBin(my.state.bins))
      , 'Currently tracked files: '
      , ''
    ]
    return cb( erf('', m1.concat(filearray) ))
  }
337151
def set_state(self, newState, timer=0):
        """"""
        if _debug: ServerSSM._debug("set_state %r (%s) timer=%r", newState, SSM.transactionLabels[newState], timer)

        # do the regular state change
        SSM.set_state(self, newState, timer)

        # when completed or aborted, remove tracking
        if (newState == COMPLETED) or (newState == ABORTED):
            if _debug: ServerSSM._debug("    - remove from active transactions")
            self.ssmSAP.serverTransactions.remove(self)

            # release the device info
            if self.device_info:
                if _debug: ClientSSM._debug("    - release device information")
                self.ssmSAP.deviceInfoCache.release(self.device_info)
1037510
def on_status_update(self, channel, callback):
        
        if channel not in self._callbacks:
            self._callbacks[channel] = []
        self._callbacks[channel].append(callback)
164033
def _on_item_activated(self, item):
        
        msg = item.data(QtCore.Qt.UserRole)
        self.msg_activated.emit(msg)
1231223
function(isRetry) {
        if (asyncLogging) {
          if (workerId > 0) {
            Utility.asyncStepLogger(workerId + "\t Registering Device");
          } else {
            Utility.asyncStepLogger("Registering Device");
          }
        }

        var content = {
          appId: appId,
          deviceId: deviceId
        };

        if (peerId !== undefined) {
          content.refresh = true;
        } else {
          content.renew = true;
        }

        pushSendData({
          type: asyncMessageType.DEVICE_REGISTER,
          content: content
        });
      }