SSH into the environment engine.

@param array $opts An array of command options.
@option string $service The service name on which to ssh into.

@return $this
507850
public function envSsh($opts = ['service' => null])
    {
        $this->executeCommandHook(__FUNCTION__, 'before');
        $this->engineInstance()->ssh($opts['service']);
        $this->executeCommandHook(__FUNCTION__, 'after');

        return $this;
    }
608917
public function clearHost($opt = self::SCHEME | self::HOST | self::PORT | self::CREDENTIALS)
	{
		$scheme = ($opt & self::SCHEME) === self::SCHEME;
		$host = ($opt & self::HOST) === self::HOST;
		$port = ($opt & self::PORT) === self::PORT;
		$creds = ($opt & self::CREDENTIALS) === self::CREDENTIALS;
		if ($scheme) {
			$this->scheme->clear();
		}
		if ($host) {
			$this->host->clear();
		}
		if ($port) {
			$this->port->clear();
		}
		if ($creds) {
			$this->credentials->clear();
		}
		return $this;
	}
778475
private function init($service)
    {
        //====================================================================//
        // Debug
        Splash::log()->deb('MsgWsCall');
        //====================================================================//
        // Safety Check
        if (!$this->verify()) {
            return Splash::log()->err('ErrWsInValid');
        }
        //====================================================================//
        // Clean Data Input Buffer
        $this->cleanIn();
        //====================================================================//
        // Prepare Data Output Buffer
        //====================================================================//
        // Fill buffer with Server Core infos
        $this->outputs->server = $this->getServerInfos();
        // Remote Service to call
        $this->outputs->service = $service;
        // Share Debug Flag with Server
        $this->outputs->debug = (int) SPLASH_DEBUG;

        return true;
    }
1337499
public function propagate($service)
    {
        if(is_object($service) &&  ($service instanceof ServiceLocatorAwareInterface)){
            $service->setServiceLocator($this);
        }
        return $service;
    }
555675
protected function alterService(DockerService $service)
    {
        if ($this->internal) {
            $service
                ->setNetworks([
                    'internal'
                ])
                ->setlabels([
                    'traefik.enable=false'
                ]);

            if ($this->bindPorts) {
                $service->setPorts(
                    $this->getPorts('0000')
                );
            }
        } else {
            $service->setPorts($this->getPorts());
        }

        return $service;
    }
331453
public function connect(array $options = [])
    {
        $config = $this->_parseConfig($options);
        try {
            $this->client = new SoapClient($this->getConfig('wsdl'), $config);
        } catch (SoapFault $fault) {
            $this->handleError($fault->faultstring);
        }

        if ($this->client) {
            $this->connected = true;
        }

        return $this->connected;
    }
403937
public function merge($opts)
    {
        $primary_opts = self::parse($opts);
        if ($primary_opts->apiKey === null) {
            $primary_opts->apiKey = $this->apiKey;
        }
        $primary_opts->headers = array_merge($this->headers, $primary_opts->headers);
        return $primary_opts;
    }
1315933
public function setService($services)
    {
        if (!is_array($services)) {
            throw new \Exception(__METHOD__.' accept parameter as array.');
        }

        foreach ($services as $key => $alias) {
            $this[$key] = $alias;
        }

        return $this;
    }
954302
public function read(array $opts) {
        $this->statuscodes = (object)[
            'attended' => 100,
            'partial' => 90
        ];
        $this->partialAttendanceDurationCredit = 0.5;

        $this->sessionDuration = 0;
        foreach ($opts['session']->dates as $index => $date) {
            $this->sessionDuration -= $date->timestart;
            $this->sessionDuration += $date->timefinish;
        }

        $translatorevents = [];
        foreach ($opts['signups'] as $signupIndex => $signup) {
            $signupEvent = $this->getSignupEvent($signup, $opts);
            if (!is_null($signupEvent)) {
                $translatorevent = array_merge(parent::read($opts)[0], $signupEvent);
                array_push($translatorevents,$translatorevent);
            }
        }
        return $translatorevents;
    }
16302
public function drupalLetmein($opts = [
        'user' => null,
        'path' => null
    ])
    {
        $this->executeCommandHook(__FUNCTION__, 'before');
        /** @var DrupalProjectType $instance */
        $instance = $this->getProjectInstance();
        $instance->createDrupalLoginLink($opts['user'], $opts['path']);
        $this->executeCommandHook(__FUNCTION__, 'after');
    }
1254865
public function storeAuthorizationState($service, $state)
    {
        $service = $this->normalizeServiceName($service);

        $states = $this->sessionScope->get(self::SESSION_STATE);
        $states[$service] = $state;
        $this->sessionScope->set(self::SESSION_STATE, $states);

        return $this;
    }
588969
protected function get($service, array &$options)
    {
        if (isset($options[$service]) && is_object($options[$service])) {
            return $options[$service];
        }

        $service = explode('_', $service);
        $service = array_map('ucfirst', $service);
        $service = 'get' . implode('', $service);

        return $options[$service] = $this->$service($options);
    }
644355
private function getService(string $service)
    {
        if ($this->container instanceof ContainerInterface && $this->container->has($service)) {
            return $this->container->get($service);
        }

        return new $service();
    }
183961
public function build($service = null)
    {
        if (!$this->sender) {
            $this->sender = $this->buildGuzzleSender();
        }

        if (!$this->factory) {
            throw new RuntimeException("You need to provide a configuration or a factory for requests");
        }

        if (!$this->logger) {
            $this->logger = new NullLogger();
        }

        return $this->buildClient($this->factory, $this->sender, $this->logger, $service);
    }
414296
public function add(string $serviceName, array $options = []): self
    {
        $this->services[$serviceName] = $options;

        return $this;
    }
960678
public function clearAuthorizationState($service)
    {
        $service = $this->normalizeServiceName($service);

        $states = $this->sessionScope->get(self::SESSION_STATE);
        if (array_key_exists($service, $states)) {
            unset($states, $service);
        }
        $this->sessionScope->set(self::SESSION_STATE, $states);

        return $this;
    }
820580
protected function executeEngineCommand($command, $service = null, $options = [], $quiet = false, $localhost = false)
    {
        if ($command instanceof CommandBuilder) {
            $command = $command->build();
        }
        $engine = $this->getEngineInstance();

        if ($engine instanceof DockerEngineType && !$localhost) {
            $results = $engine->execRaw($command, $service, $options, $quiet);
        } else {
            $results = $this->_exec($command);
        }

        $this->validateTaskResult($results);

        return $results;
    }