Sets remote server to striped passive server mode (SPAS).
509725
public HostPortList setStripedPassive()
        throws IOException,
               ServerException {
        Command cmd = new Command("SPAS",
                                  (controlChannel.isIPv6()) ? "2" : null);
        Reply reply = null;

        try {
            reply = controlChannel.execute(cmd);
        } catch (UnexpectedReplyCodeException urce) {
            throw ServerException.embedUnexpectedReplyCodeException(urce);
        } catch(FTPReplyParseException rpe) {
            throw ServerException.embedFTPReplyParseException(rpe);
        }

        this.gSession.serverMode = GridFTPSession.SERVER_EPAS;
        if (controlChannel.isIPv6()) {
            gSession.serverAddressList =
                HostPortList.parseIPv6Format(reply.getMessage());
            int size = gSession.serverAddressList.size();
            for (int i=0;i<size;i++) {
                HostPort6 hp = (HostPort6)gSession.serverAddressList.get(i);
                if (hp.getHost() == null) {
                    hp.setVersion(HostPort6.IPv6);
                    hp.setHost(controlChannel.getHost());
                }
            }
        } else {
            gSession.serverAddressList =
                HostPortList.parseIPv4Format(reply.getMessage());
        }
        return gSession.serverAddressList;
    }
665956
private static void setCleanHost(Matcher matcher, List<String> hosts) {
		// get the host but might be [ipv6]
		String maybeIPv6Host = matcher.group( 1 );
		Matcher ipv6Matcher = NAKED_IPV6_PATTERN.matcher( maybeIPv6Host );
		String cleanHost = maybeIPv6Host;
		if ( ipv6Matcher.matches() ) {
			cleanHost = ipv6Matcher.group( 1 );
			if ( cleanHost == null ) {
				cleanHost = maybeIPv6Host;
			}
		}
		hosts.add( cleanHost );
	}
1211955
function setCurrentServer(server) {
    if (server) {
        server.makeCurrent();
        assert.strictEqual(getCurrentServer(), server);
    }
    else {
        init.initOptions.serverUrl = null;
    }
}
324389
public void setShellServerOptions(String enabled, String portStr) {

        int port;
        try {
            port = Integer.parseInt(portStr);
        } catch (NumberFormatException e) {
            port = CmsRemoteShellConstants.DEFAULT_PORT;
        }
        m_shellServerOptions = new CmsRemoteShellConfiguration(Boolean.parseBoolean(enabled), port);

    }
1223669
public void installServerCertificate(String cert) throws HostConfigFault, RuntimeFault, RemoteException {
        getVimService().installServerCertificate(getMOR(), cert);
    }
232128
def set_silent(self):
        """"""
        self.set_icntl(1, -1) # output stream for error msgs
        self.set_icntl(2, -1) # otuput stream for diagnostic msgs
        self.set_icntl(3, -1) # output stream for global info
        self.set_icntl(4, 0)
722457
def set_config(self, data=None, **kwargs):
        """"""
        config = self.bot.config['server_config']
        for opt in data.split(' '):
            if '=' in opt:
                opt, value = opt.split('=', 1)
            else:
                value = True
            if opt.isupper():
                config[opt] = value
967805
def stop_accepting_passive_svc_checks(self):
        
        if self.my_conf.accept_passive_service_checks:
            self.my_conf.modified_attributes |= DICT_MODATTR["MODATTR_PASSIVE_CHECKS_ENABLED"].value
            self.my_conf.accept_passive_service_checks = False
            self.my_conf.explode_global_conf()
            self.daemon.update_program_status()
273054
def set_ntp_servers(ntp_servers)
      new_action = { 'StaticNTPServers' => ntp_servers }
      response = rest_patch('/redfish/v1/Managers/1/DateTime/', body: new_action)
      response_handler(response)
      true
    end
264747
def shutdown_server(self):
        """"""
        self.log.debug('shutdown_server: in')
        if self.ensime and self.toggle_teardown:
            self.ensime.stop()
726949
def _set_server_known(cls, host, port):
        
        with PostgreSql._known_servers_lock:
            PostgreSql._known_servers.add((host, port))
1064620
private function prepareHostedMode()
    {
        $param_server = nbCLICheckOption('s', 'server', ':', false);
        if (strlen($param_server) === 0) {
            $param_server = self::DEFAULT_HOSTED_KEY;
            $this->mode = CNabuEngine::ENGINE_MODE_HOSTED;
            $this->server_key = $param_server;
        } else {
            echo "Invalid server key provided for Hosted Engine Mode.\n";
            echo "Please revise your options and try again.\n";
        }
    }
1318747
public function setServer(ServerInterface $server): void
    {
        $this->server = $server;
        $this->server->configure($this);
    }
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)
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
247030
def serveInBackground(port, serverName, prefix='/status/'):
  """"""
  import flask, threading
  from wsgiref.simple_server import make_server
  app = flask.Flask(__name__)
  registerStatsHandler(app, serverName, prefix)
  server = threading.Thread(target=make_server('', port, app).serve_forever)
  server.daemon = True
  server.start()
  return server
611677
private void makeSureServerIsRunning(PortFile portFile)
            throws IOException, InterruptedException {

        if (portFile.exists()) {
            portFile.lock();
            portFile.getValues();
            portFile.unlock();

            if (portFile.containsPortInfo()) {
                // Server seems to already be running
                return;
            }
        }

        // Fork a new server and wait for it to start
        SjavacClient.fork(sjavacForkCmd,
                          portFile,
                          poolsize,
                          keepalive);
    }