Returns the deployment service instance.

@return \AppserverIo\Appserver\Core\Api\DeploymentService The deployment service instance
963427
public function getDeploymentService()
    {
        if ($this->deploymentService == null) {
            $this->deploymentService = $this->newService('AppserverIo\Appserver\Core\Api\DeploymentService');
        }
        return $this->deploymentService;
    }
875931
public static function getInstance()
    {
        if (!self::$instance instanceof ClientInterface) {

            $serviceContainer = ServiceContainer::getInstance();

            self::$instance = new static(
                $serviceContainer->get('engine'),
                $serviceContainer->get('procedure_loader'),
                $serviceContainer->get('procedure_compiler'),
                $serviceContainer->get('message_factory')
            );
        }

        return self::$instance;
    }
1051925
public function getInstance()
    {
        if (isset($this->classInstance)) {
            return $this->classInstance;
        }
        $this->classInstance = $this->jobFactory->create($this->payload['class'], $this->getArguments(), $this->queue);
        $this->classInstance->job = $this;
        return $this->classInstance;
    }
1070956
public static function getInstance()
    {
        $configuration = Configuration::getConfig(self::CONFIG_FILE_NAME);
        $idpListServiceType = $configuration->getString(self::PROPNAME_IDP_LIST_SERVICE_TYPE, self::CSV);
        if ($idpListServiceType === self::CSV) {
            return new IdpListsServiceCsv();
        } elseif ($idpListServiceType === self::DB) {
            return new IdpListsServiceDB();
        } else {
            throw new Exception(
                'Unknown idpListService type. Hint: try ' . self::CSV . ' or ' . self::DB
            );
        }
    }
1161797
protected function getClassService()
    {
        if (is_null($this->service)) {
            $this->service = taoItems_models_classes_ItemsService::singleton();
        }
        return $this->service;
    }
853782
public function getService()
    {
        $serviceNodes = $this->element->getElementsByTagName('service');
        if ($serviceNodes->length > 0) {
            return new ServiceNode($this->document, $serviceNodes->item(0));
        }
        return null;
    }
907702
protected function getCompileService()
    {
        if ($this->compileService === null) {
            $this->compileService = GeneralUtility::makeInstance(CompileService::class);
        }
        return $this->compileService;
    }
1001621
protected function buildServiceManager()
    {
        // ServiceManager creation
        $serviceManager = new ServiceManagerBuilder($this->getConfigManager()->getMergedConfig());
        $serviceManager->build($this->getAppParameters());
        $serviceManager->set('app', $this);

        return $serviceManager;
    }
99465
private function getProvider()
    {
        $app = $this->app;

        $version = intval($app::VERSION);

        switch ($version) {
            case 4:
              return new ServiceProviderLaravel4($app);

            case 5:
              return new ServiceProviderLaravel5($app);

            default:
              throw new RuntimeException('Your version of Laravel is not supported');
        }
    }
739507
protected function getService()
    {
        if (!isset($this->service)) {
            $this->service = $this->getServiceLocator()
                    ->get($this->getModuleNamespace() . '\Service\\' . $this->getEntityName());
        }

        return $this->service;
    }
327378
public function getWebservice()
    {
        if ($this->_webservice === null) {
            $this->_webservice = $this->getConnection()->getWebservice($this->getName());
        }

        return $this->_webservice;
    }
97452
public function deploy()
    {
        $isFtp = $this->connections->getCurrentConnectionKey()->isFtp();

        $from = $this->on('dummy', function () {
            $this->setupIfNecessary();
            $this->executeTask('CreateRelease');
            $this->executeTask('PrepareRelease');

            return $this->releasesManager->getCurrentReleasePath();
        });

        $to = $isFtp
            ? $this->paths->getFolder()
            : $this->releasesManager->getCurrentReleasePath();

        return $this->onReleaseReady($from, $to);
    }
1088115
public function create()
    {
        $serviceId = $this->container->getParameter('graviton.security.authentication.provider.model');
        $service = $this->container->get('graviton.security.authentication.provider.model.noop');

        if (!empty($serviceId) && $this->container->has($serviceId)) {
            $service = $this->container->get($serviceId);
        }

        return $service;
    }
1328718
public function getCurrentDeployment()
    {
        $deployment = EnvironmentDeployment::get('current', $this->getUri() . '/deployments', $this->client);
        if (!$deployment) {
            throw new EnvironmentStateException('Current deployment not found', $this);
        }

        return $deployment;
    }
103501
public function getSectionService()
    {
        if ($this->sectionService !== null) {
            return $this->sectionService;
        }

        $this->sectionService = new SectionService(
            $this,
            $this->persistenceHandler->sectionHandler(),
            $this->persistenceHandler->locationHandler(),
            $this->getPermissionCriterionResolver(),
            $this->serviceSettings['section']
        );

        return $this->sectionService;
    }
39939
private function getInstanceAdminClient()
    {
        //@codeCoverageIgnoreStart
        if ($this->instanceAdminClient) {
            return $this->instanceAdminClient;
        }
        //@codeCoverageIgnoreEnd

        $this->instanceAdminClient = new InstanceAdminClient($this->grpcConfig);

        return $this->instanceAdminClient;
    }
58954
public static function instance()
    {
        if (null === self::$_instance) {
            $logger = new Monolog(Config::read('app.id'));
            $file_handler = new StreamHandler(self::getFilepath());
            $logger->pushHandler($file_handler);

            self::$_instance = $logger;
        }
        return self::$_instance;
    }