Register a Dde task.
163986
def register_dde_task(self, *args, **kwargs):
        """"""
        kwargs["task_class"] = DdeTask
        return self.register_task(*args, **kwargs)
709287
def register(self):
        """"""
        self._do_selection_update = True
        # relieve old model
        if self.__my_selected_sm_id is not None:  # no old models available
            self.relieve_model(self._selected_sm_model)
        # set own selected state machine id
        self.__my_selected_sm_id = self.model.selected_state_machine_id
        if self.__my_selected_sm_id is not None:
            # observe new model
            self._selected_sm_model = self.model.state_machines[self.__my_selected_sm_id]
            self.observe_model(self._selected_sm_model)  # for selection
            self.update()
        else:
            self._selected_sm_model = None
            self.state_row_iter_dict_by_state_path.clear()
            self.tree_store.clear()
        self._do_selection_update = False
725276
def register_elastic_task(self, *args, **kwargs):
        """"""
        kwargs["task_class"] = ElasticTask
        return self.register_task(*args, **kwargs)
64730
def RegisterResources(self, client_resources):
    """"""
    self.user_cpu_stats.RegisterValue(client_resources.cpu_usage.user_cpu_time)
    self.system_cpu_stats.RegisterValue(
        client_resources.cpu_usage.system_cpu_time)
    self.network_bytes_sent_stats.RegisterValue(
        client_resources.network_bytes_sent)

    self.worst_performers.Append(client_resources)
    new_worst_performers = sorted(
        self.worst_performers,
        key=lambda s: s.cpu_usage.user_cpu_time + s.cpu_usage.system_cpu_time,
        reverse=True)[:self.NUM_WORST_PERFORMERS]
    self.worst_performers = new_worst_performers
1152332
def register_dte_task(self, *args, **kwargs):
        """"""
        kwargs["task_class"] = DteTask
        return self.register_task(*args, **kwargs)
494337
def register_bse_task(self, *args, **kwargs):
        """"""
        kwargs["task_class"] = BseTask
        return self.register_task(*args, **kwargs)
1177517
public void registerTaskConfig(String taskName, TedProcessorFactory tedProcessorFactory, TedRetryScheduler retryScheduler) {
		tedDriverImpl.registerTaskConfig(taskName, tedProcessorFactory, null, retryScheduler, null);
	}
536904
def _register_info(self):
        """"""
        # Stores information on Workbench commands and signatures
        for name, meth in inspect.getmembers(self, predicate=inspect.isroutine):
            if not name.startswith('_') and name != 'run':
                info = {'command': name, 'sig': str(funcsigs.signature(meth)), 'docstring': meth.__doc__}
                self.workbench.store_info(info, name, 'command')

        # Register help information
        self.workbench.store_info({'help': self.help.help_cli()}, 'cli', 'help')
        self.workbench.store_info({'help': self.help.help_cli_basic()}, 'cli_basic', 'help')
        self.workbench.store_info({'help': self.help.help_cli_search()}, 'search', 'help')
        self.workbench.store_info({'help': self.help.help_dataframe()}, 'dataframe', 'help')
        self.workbench.store_info({'help': self.help.help_dataframe_memory()}, 'dataframe_memory', 'help')
        self.workbench.store_info({'help': self.help.help_dataframe_pe()}, 'dataframe_pe', 'help')
1353885
def register_repl(group, name="repl"):
    """"""
    group.command(name=name)(click.pass_context(repl))
1115511
def register(cache):
	'''  '''

	global caches
	name = cache().name
	if not caches.has_key(name):
		caches[name] = cache
498558
def register
      data = JSON.parse(IO.read(@template_definition_path))
      data = rubyize_format(data)

      message = "#{data[:family]} task definition registered."
      if @options[:noop]
        message = "NOOP: #{message}"
      else
        register_task_definition(data)
      end

      unless @options[:mute]
        puts "Equivalent aws cli command:"
        file_path = "file://#{@template_definition_path.sub(/^\.\//,'')}"
        puts "  aws ecs register-task-definition --cli-input-json #{file_path}".color(:green)
        puts message
      end
    end
548481
private <T> ServiceRegistration<T> registerMBean(ObjectName on, Class<T> type, T o) {
        Dictionary<String, Object> props = new Hashtable<String, Object>();
        props.put("jmx.objectname", on.toString());
        return context.registerService(type, o, props);
    }
1168879
def register_periodic_tasks(self, tasks: Iterable[Task]):
        """"""
        tasks = [task.serialize() for task in tasks]
        self._number_periodic_tasks = len(tasks)
        self._run_script(
            self._register_periodic_tasks,
            math.ceil(datetime.now(timezone.utc).timestamp()),
            self._to_namespaced(PERIODIC_TASKS_HASH_KEY),
            self._to_namespaced(PERIODIC_TASKS_QUEUE_KEY),
            *tasks
        )
795565
public void registerTaskConfig(String taskName, TedProcessorFactory tedProcessorFactory) {
		registerTaskConfig(taskName, tedProcessorFactory, null, null, null);
	}
365135
def add_task(self, pid):
        
        _register_process_with_cgrulesengd(pid)
        for cgroup in self.paths:
            with open(os.path.join(cgroup, 'tasks'), 'w') as tasksFile:
                tasksFile.write(str(pid))
1015451
def register(cls):
    
    definition_name = make_definition_name(cls.__name__)
    REGISTRY[definition_name] = cls
    return cls
1321496
protected void doRegister(String appName, String serviceName, ProviderInfo providerInfo) {

        registerAppInfoOnce(appName);

        if (LOGGER.isInfoEnabled(appName)) {
            LOGGER.infoWithApp(appName, LogCodes.getLog(LogCodes.INFO_ROUTE_REGISTRY_PUB, serviceName));
        }

        PublishServiceRequest publishServiceRequest = new PublishServiceRequest();
        publishServiceRequest.setServiceName(serviceName);
        ProviderMetaInfo providerMetaInfo = new ProviderMetaInfo();
        providerMetaInfo.setProtocol(providerInfo.getProtocolType());
        providerMetaInfo.setSerializeType(providerInfo.getSerializationType());
        providerMetaInfo.setAppName(appName);
        providerMetaInfo.setVersion(VERSION);
        publishServiceRequest.setProviderMetaInfo(providerMetaInfo);

        client.publishService(publishServiceRequest);
    }