Starts a SSH session with the destination server.

 @param [Array] arguments
   Additional arguments to pass to SSH.
542608
def ssh(*arguments)
      options = []

      # Add the -p option if an alternate destination port is given
      if @uri.port
        options += ['-p', @uri.port.to_s]
      end

      # append the SSH URI
      options << ssh_uri

      # append the additional arguments
      arguments.each { |arg| options << arg.to_s }

      return system('ssh',*options)
    end
1037336
def start_simple_server():
	""
	args = _get_args()
	addr = ('', args.port)
	DebuggingServer(addr, None)
	asyncore.loop()
1249290
def start(debug=False, host='127.0.0.1'):
    
    if debug:
        debug = True
    nago.protocols.httpserver.app.run(debug=debug, host=host)
289622
function startSSHForwarding($ssh)
    {
        if ($this->forward_status == self::FORWARD_NONE) {
            $this->forward_status = self::FORWARD_REQUEST;
        }
    }
256271
async def start_serving(self, address=None, sockets=None,
                            backlog=100, sslcontext=None):
        
        if self._server:
            raise RuntimeError('Already serving')
        create_server = self._loop.create_server
        server = None
        if sockets:
            for sock in sockets:
                srv = await create_server(self.create_protocol,
                                          sock=sock,
                                          backlog=backlog,
                                          ssl=sslcontext)
                if server:
                    server.sockets.extend(srv.sockets)
                else:
                    server = srv
        elif isinstance(address, tuple):
            server = await create_server(self.create_protocol,
                                         host=address[0],
                                         port=address[1],
                                         backlog=backlog,
                                         ssl=sslcontext)
        else:
            raise RuntimeError('sockets or address must be supplied')
        self._set_server(server)
491262
function start (settings) {

  settings = settings || {};

  // Populate security values with the corresponding files.
  if (settings.secure) {
    settings.passphrase = settings.passphrase || '1234';
    settings.key = settings.key || 'https.key';
    settings.cert = settings.cert || 'https.crt';
    settings.ca = settings.ca || [];
  }

  settings.port = settings.port || (settings.secure ? 443 : 80);

  return startServer(settings);
}
1233622
def client_start(request, socket, context):
    
    CLIENTS[socket.session.session_id] = (request, socket, context)
341222
def load_server!
      if @server_name
        unless SERVERS.has_key?(@server_name)
          raise(UnknownServer,"Unknown server name #{@server_name}",caller)
        end

        extend SERVERS[@server_name]

        initialize_server if respond_to?(:initialize_server)
      end
    end
146059
public void startSeleniumServer(final String args) {
		if (seleniumProxy != null) {
			throw new IllegalStateException("There is already a Selenium remote server running");
		}
		
		try {
	        final RemoteControlConfiguration configuration;

	        LOG.info("Starting server with arguments: '" + args + "'");
	        
	        //String[] argv = StringUtils.isNotBlank(args) ? StringUtils.split(args) : new String[] {};
	        String[] argv = StringUtils.split(args);
	        
	        configuration = SeleniumServer.parseLauncherOptions(argv);
	        //checkArgsSanity(configuration);

	        System.setProperty("org.openqa.jetty.http.HttpRequest.maxFormContentSize", "0"); // default max is 200k; zero is infinite
	        seleniumProxy = new SeleniumServer(isSlowConnection(), configuration);
	        seleniumProxy.start();
		} catch (Exception e) {
			//server.stop();
			LOG.info("Server stopped");
		}
	}
954398
def execute
      cli_arguments = Telegram::CLIArguments.new(@config)
      command = "'#{@config.daemon}' #{cli_arguments.to_s}"
      @stdout = IO.popen(command, 'a+')
      initialize_stdout_reading
    end
499204
def init(opts):
    '''
    
    '''
    try:
        DETAILS['server'] = SSHConnection(host=__opts__['proxy']['host'],
                                          username=__opts__['proxy']['username'],
                                          password=__opts__['proxy']['password'])
        out, err = DETAILS['server'].sendline('help')
        DETAILS['initialized'] = True

    except TerminalException as e:
        log.error(e)
        return False
478316
def run
      raise("Already running a pry-remote session!") if
        PryByebug.current_remote_server

      PryByebug.current_remote_server = self

      setup
      Pry.start @object, input: client.input_proxy, output: client.output
    end
595219
def start
      setup
      if connect
        @sasl_remaining_methods = @bot.config.sasl.mechanisms.reverse
        send_cap_ls
        send_login

        reading_thread = start_reading_thread
        sending_thread = start_sending_thread
        ping_thread    = start_ping_thread

        reading_thread.join
        sending_thread.kill
        ping_thread.kill
      end
    end
895271
def start
      ARGV.each do |arg|
        unless arg.index('-') === 0
          @commands << arg
        end
      end
      # get the first command as the method, and the rest of the commands as args
      method = @commands.empty? ? :timeline : @commands[0].to_sym
      return method_missing(method) unless AllowedMethods.include?(method)
      self.send(method, @commands[1..@commands.size])
    end
877857
def run
      if PryDebugger.current_remote_server
        raise 'Already running a pry-remote session!'
      else
        PryDebugger.current_remote_server = self
      end

      setup
      Pry.start @object, {
        :input  => client.input_proxy,
        :output => client.output
      }
    end
871215
def _setup_ssh(self):
        """"""
        global paramiko
        if paramiko is none:
            import paramiko

        self.ssh = paramiko.SSHClient()
        self.ssh.set_missing_host_key_policy(paramiko.AutoAddPolicy())
        self.ssh.connect(self.server, username=self.user, pkey=self.pkey)
883202
def build_ssh_cmd_str(cmd_str, host, args, host_args)
      Dk::Remote.ssh_cmd_str(cmd_str, host, args, host_args)
    end