Settings for Remote Management.
359642
public function remote_management_page_init() {
		register_setting(
			'github_updater_remote_management',
			'github_updater_remote_settings',
			[ $this, 'sanitize' ]
		);

		add_settings_section(
			'remote_management',
			esc_html__( 'Remote Management', 'github-updater' ),
			[ $this, 'print_section_remote_management' ],
			'github_updater_remote_settings'
		);

		foreach ( self::$remote_management as $id => $name ) {
			add_settings_field(
				$id,
				null,
				[ $this, 'token_callback_checkbox_remote' ],
				'github_updater_remote_settings',
				'remote_management',
				[
					'id'    => $id,
					'title' => esc_html( $name ),
				]
			);
		}
	}
1290102
def make_remote_view(data, settings, more_excluded_names=None):
    
    data = get_remote_data(data, settings, mode='editable',
                           more_excluded_names=more_excluded_names)
    remote = {}
    for key, value in list(data.items()):
        view = value_to_display(value, minmax=settings['minmax'])
        remote[key] = {'type':  get_human_readable_type(value),
                       'size':  get_size(value),
                       'color': get_color_name(value),
                       'view':  view}
    return remote
316260
def upload_settings():
    ""
    local_path = os.path.join(curdir, 'settings/{0}.py'.format(env.host))
    if os.path.exists(local_path):
        remote_path = os.path.join(env.path, 'varify/conf/local_settings.py')
        put(local_path, remote_path)
    elif not confirm(yellow('No local settings found for host "{0}". Continue anyway?'.format(env.host))):
        abort('No local settings found for host "{0}". Aborting.'.format(env.host))
901563
function(modem, name, remote) {
  this.modem = modem;
  this.name = name;
  this.remote = remote || name;
}
1288004
def lock(self, back=None, remote=None):
        '''
        
        '''
        back = self.backends(back)
        locked = []
        errors = []
        for fsb in back:
            fstr = '{0}.lock'.format(fsb)
            if fstr in self.servers:
                msg = 'Setting update lock for {0} remotes'.format(fsb)
                if remote:
                    if not isinstance(remote, six.string_types):
                        errors.append(
                            'Badly formatted remote pattern \'{0}\''
                            .format(remote)
                        )
                        continue
                    else:
                        msg += ' matching {0}'.format(remote)
                log.debug(msg)
                good, bad = self.servers[fstr](remote=remote)
                locked.extend(good)
                errors.extend(bad)
        return locked, errors
1288601
def _set_slave_enabled(self, dpid, port, enabled):
        """"""
        slave = self._get_slave(dpid, port)
        if slave:
            slave['enabled'] = enabled
248334
def command(command):
    
    with cd(env.remote_path):
        sudo(env.python + ' manage.py %s' % command, user=env.remote_user)
31341
def setup(app):
    
    app.info('adding remote-include directive...', nonl=True)
    app.add_directive('remote-include', RemoteInclude)
    app.info(' done')
    return {
        'version': __version__,
        'parallel_read_safe': True,
        'parallel_write_safe': True,
        }
222190
def _connect_remote(self, host, host_port, lan_ports, race, name, map_inst,
                      save_map, interface):
    """"""
    # Connect!
    logging.info("Connecting...")
    self._controllers = [remote_controller.RemoteController(host, host_port)]
    logging.info("Connected")

    if map_inst and save_map:
      run_config = run_configs.get()
      self._controllers[0].save_map(map_inst.path, map_inst.data(run_config))

    # Create the join request.
    join = sc_pb.RequestJoinGame(options=interface)
    join.race = race
    join.player_name = name
    join.shared_port = 0  # unused
    join.server_ports.game_port = lan_ports.pop(0)
    join.server_ports.base_port = lan_ports.pop(0)
    join.client_ports.add(
        game_port=lan_ports.pop(0), base_port=lan_ports.pop(0))

    logging.info("Joining game.")
    self._controllers[0].join_game(join)
    self._in_game = True
    logging.info("Game joined.")
837891
def _configure_manager(self):
        
        self._manager = CloudNetworkManager(self, resource_class=CloudNetwork,
                response_key="network", uri_base="os-networksv2")
5289
def set_settings(self, releases=None, default_release=None):
        """"""
        if (self._storage is None or
                getattr(self, 'releases', {}) != releases or
                getattr(self, 'default_release', '') != default_release):
            self._storage = {}
            self.releases = releases or {}
            self.default_release = default_release
195807
def cli(env):
    """"""
    manager = SoftLayer.IPSECManager(env.client)
    contexts = manager.get_tunnel_contexts()

    table = formatting.Table(['id',
                              'name',
                              'friendly name',
                              'internal peer IP address',
                              'remote peer IP address',
                              'created'])
    for context in contexts:
        table.add_row([context.get('id', ''),
                       context.get('name', ''),
                       context.get('friendlyName', ''),
                       context.get('internalPeerIpAddress', ''),
                       context.get('customerPeerIpAddress', ''),
                       context.get('createDate', '')])
    env.fout(table)
453181
def setInstallMode(self, remote, on=True, t=60, mode=1, address=None):
        """"""
        if self._server is not None:
            return self._server.setInstallMode(remote, on, t, mode, address)
85303
def _configure_manager(self):
        
        self._manager = CloudLoadBalancerManager(self,
                resource_class=CloudLoadBalancer,
                response_key="loadBalancer", uri_base="loadbalancers")
823903
def _configure(self, manager, connect_api_instance, observer_params):
        
        self._manager = manager
        self._api = connect_api_instance
        self._observer_params = self._observer_params or {}
        self._observer_params.update(observer_params)
1030243
function RemoteLS (opts) {
  var _this = this

  _.extend(this, {
    logger: console,
    development: true, // include dev dependencies.
    optional: true, // include optional dependencies.
    peer: false, // include peer dependencies.
    verbose: false,
    registry: require('registry-url')(), // URL of registry to ls.
    queue: async.queue(function (task, done) {
      _this._loadPackageJson(task, done)
    }, 8),
    tree: {},
    flat: {}
  }, require('./config')(), opts)

  this.queue.pause()
}
1041425
def create_remote(self, name, url, **kwargs):
        """"""
        return Remote.create(self, name, url, **kwargs)