Starts remote console support for this VM.
543082
def _start_console(self):
        
        self._remote_pipe = yield from asyncio_open_serial(self._get_pipe_name())
        server = AsyncioTelnetServer(reader=self._remote_pipe,
                                     writer=self._remote_pipe,
                                     binary=True,
                                     echo=True)
        self._telnet_server = yield from asyncio.start_server(server.run, self._manager.port_manager.console_host, self.console)
666826
def start(self):
        
        engine = self.current_engine()
        if not engine.running:
            if self._settings["vmname"] is None:
                return
            log.info("")
            engine.vmname = self._settings["vmname"]
            engine.ram = self._settings["ram"]
            engine.vcpus = self._settings["vcpus"]
            engine.headless = self._settings["headless"]
            compute = yield from self._controller.add_compute(compute_id="vm",
                                                              name="GNS3 VM is starting ({})".format(engine.vmname),
                                                              host=None,
                                                              force=True,
                                                              connect=False)

            try:
                yield from engine.start()
            except Exception as e:
                yield from self._controller.delete_compute("vm")
                log.error("Can't start the GNS3 VM: {}".format(str(e)))
                yield from compute.update(name="GNS3 VM ({})".format(engine.vmname))
                raise e
            yield from compute.connect()  # we can connect now that the VM has started
            yield from compute.update(name="GNS3 VM ({})".format(engine.vmname),
                                      protocol=self.protocol,
                                      host=self.ip_address,
                                      port=self.port,
                                      user=self.user,
                                      password=self.password)

            # check if the VM is in the same subnet as the local server, start 10 seconds later to give
            # some time for the compute in the VM to be ready for requests
            asyncio.get_event_loop().call_later(10, lambda: asyncio.async(self._check_network(compute)))
119515
public void start() {
        if (hasVibratePermission(mContext)) {
            mVibrator = (Vibrator) mContext.getSystemService(Service.VIBRATOR_SERVICE);
        }

        // Setup a listener for changes in haptic feedback settings
        mIsGloballyEnabled = checkGlobalSetting(mContext);
        Uri uri = Settings.System.getUriFor(Settings.System.HAPTIC_FEEDBACK_ENABLED);
        mContext.getContentResolver().registerContentObserver(uri, false, mContentObserver);
    }
495443
def start
      if ENV['rvm_path']
        sh "rvmsudo vhost run #{run_options}"
      else
        vhost = File.expand_path('../../bin/vhost', __dir__)
        sh "bundle exec sudo env PATH=#{ENV['PATH']} #{vhost} run #{run_options}"
      end
      sleep 1
      self.device = @device if @device
    end
1295965
def start(self):
        '''  '''
        self._app.run(host=self._host, port=self._port)
1156878
@Override
	public void run()
    {
        log.info("Starting remote administration thread ...");

        try
        {
            LocalQueue inputQueue = engine.getLocalQueue(FFMQConstants.ADM_REQUEST_QUEUE);
            LocalQueue outputQueue = engine.getLocalQueue(FFMQConstants.ADM_REPLY_QUEUE);
            
            conn = new LocalQueueConnection(engine, null, null);
            session = conn.createQueueSession(true, Session.SESSION_TRANSACTED);
            receiver = session.createReceiver(inputQueue);
            sender = session.createSender(outputQueue);

            conn.start();

            // Flush input queue on startup
            inputQueue.purge(null);
            outputQueue.purge(null);
            
            // Enter listening loop
            notifyStartup();
            while (!stopRequired)
            {
                Message message = receiver.receive();
                if (message == null)
                    break; // Interrupted
                log.debug("Received message " + message);

                try
                {
                    // Process the command
                    String errorMsg = process(message);
    
                    // Build response message
                    Message response = session.createMessage();
                    response.setJMSCorrelationID(message.getJMSMessageID());
                    if (errorMsg != null)
                        response.setStringProperty(FFMQAdminConstants.ADM_HEADER_ERRMSG, errorMsg);
                    
                    sender.send(response,DeliveryMode.NON_PERSISTENT,Message.DEFAULT_PRIORITY,Message.DEFAULT_TIME_TO_LIVE);
                }
                catch (JMSException e)
                {
                    log.error("Cannot process admin command",e);
                }
                finally
                {
                    session.commit();
                }
            }
            
            log.debug("Remote administration thread has stopped");
        }
        catch (Throwable e)
        {
            log.fatal("Administration thread failed", e);
            notifyStartup();
        }
        finally
        {
            try
            {
                if (sender != null)
                    sender.close();
            }
            catch (JMSException e)
            {
            	ErrorTools.log(e, log);
            }

            try
            {
                if (receiver != null)
                    receiver.close();
            }
            catch (JMSException e)
            {
            	ErrorTools.log(e, log);
            }

            try
            {
                if (session != null)
                    session.close();
            }
            catch (JMSException e)
            {
            	ErrorTools.log(e, log);
            }

            try
            {
                if (conn != null)
                    conn.close();
            }
            catch (JMSException e)
            {
            	ErrorTools.log(e, log);
            }
        }
    }
814363
def start(self):
        
        #: Schedule a load view if given and remote debugging is not active
        #: the remote debugging init call this after dev connection is ready
        if self.load_view and self.dev != "remote":
            self.deferred_call(self.load_view, self)

        self.loop.start()
953475
async def start(self, remoteCaps, remotePort):
        
        if not self.__started:
            self.__started = True
            self.__state = 'connecting'
            self._remote_port = remotePort

            # configure logging
            if logger.isEnabledFor(logging.DEBUG):
                prefix = self.is_server and 'server ' or 'client '
                self.__log_debug = lambda msg, *args: logger.debug(prefix + msg, *args)

            # initialise local channel ID counter
            # one side should be using even IDs, the other odd IDs
            if self.is_server:
                self._data_channel_id = 0
            else:
                self._data_channel_id = 1

            self.__transport._register_data_receiver(self)
            if not self.is_server:
                await self._init()
402416
def console
      client_setup({}, true, true)
      puts "Console Connected to #{@client.url}"
      puts "HINT: The @client object is available to you\n\n"
    rescue
      puts "WARNING: Couldn't connect to #{@options['url'] || ENV['ONEVIEWSDK_URL']}\n\n"
    ensure
      require 'pry'
      Pry.config.prompt = proc { '> ' }
      Pry.plugins['stack_explorer'] && Pry.plugins['stack_explorer'].disable!
      Pry.plugins['byebug'] && Pry.plugins['byebug'].disable!
      Pry.start(OneviewSDK::Console.new(@client))
    end
1131914
def console_main():
    """"""
    cmd = main(check=False)
    if cmd is not None:
        sys.exit(cmd.returncode)
186170
def start
      throw([:task_has_failed], "Guard::RemoteSync options invalid") unless options_valid?
      Guard::Compat::UI.info "Guard::RemoteSync started in source directory '#{File.expand_path @source.directory}'"
      Guard::Compat::UI.notify("Guard::RemoteSync is running in directory #{File.expand_path @source.directory}", notifier_options)
      if @command.test
        @command.sync if options[:sync_on_start]
      else
        throw([:task_has_failed], "Guard::RemoteSync rsync failed, please check your configurations, directories, permissions, and maybe even your ssh details ( set up a public key possibly )")
      end

    end
1111341
public void start() {
        application = new CitrusRemoteApplication(configuration);
        port(configuration.getPort());
        application.init();

        if (!configuration.isSkipTests()) {
            new RunController(configuration).run();
        }

        if (configuration.getTimeToLive() == 0) {
            stop();
        }
    }
1264956
def run_console(*, locals=None, banner=None, serve=None, prompt_control=None):
    """"""
    loop = InteractiveEventLoop(
        locals=locals,
        banner=banner,
        serve=serve,
        prompt_control=prompt_control)
    asyncio.set_event_loop(loop)
    try:
        loop.run_forever()
    except KeyboardInterrupt:
        pass
283564
def start(**kwargs):
  '''  '''

  output, err = cli_syncthing_adapter.start(**kwargs)
  click.echo("%s" % output, err=err)
200157
def start(self):
        """"""
        # TODO(BMo) having this check is probably a good idea but I've \
        # disabled it for now while the PBC is in flux.
        # assert sip_pbc.release.__version__ == '1.2.3'

        scheduler_threads = [
            Thread(target=self._monitor_events, daemon=True),
            Thread(target=self._processing_controller_status, daemon=True),
            Thread(target=self._schedule_processing_blocks, daemon=True),
            Thread(target=self._monitor_pbc_status, daemon=True)
        ]

        for thread in scheduler_threads:
            thread.start()

        try:
            for thread in scheduler_threads:
                thread.join()
        except KeyboardInterrupt:
            LOG.info('Keyboard interrupt!')
            sys.exit(0)
        finally:
            LOG.info('Finally!')
1064318
def open_remote(serial_number=-1, server_id=nil, password=nil)
	   Phidgets::FFI::Common.openRemote(@handle, serial_number, server_id, password)
	   true
    end
1210171
public function start()
    {
        if ($this->started) {
            return;
        }

        $auth = $this->getAuthFlag();

        $command = 'transmission-remote -C ' . $auth
            . ' -' . ($this->encryption ? 'er' : 'ep')
            . ' -p ' . $this->port
            . ' -' . ($this->upnp ? 'm' : 'M')
            . ($this->downloadPath ? ' -w ' . $this->downloadPath : '');
        $this->execute($command);

        $this->execute('transmission-remote ' . $auth . ' -l');
        if ($this->getStatus() == 1) {
            $this->execute('transmission-daemon');
        }

        $this->started = true;
    }