Pushes the artifact to git.remotes.
@param $identifier
@param $options
@return bool
@throws BltException
2950
protected function push($identifier, $options) {
    if ($options['dry-run']) {
      $this->logger->warning("Skipping push of deployment artifact. deploy.dryRun is set to true.");
      return FALSE;
    }
    else {
      $this->say("Pushing artifact to git.remotes...");
    }

    $task = $this->taskExecStack()
      ->dir($this->deployDir);
    foreach ($this->getConfigValue('git.remotes') as $remote) {
      $remote_name = md5($remote);
      $task->exec("git push $remote_name $identifier");
    }
    $result = $task->run();

    if (!$result->wasSuccessful()) {
      throw new BltException("Failed to push deployment artifact!");
    }
  }
666264
protected function execute(InputInterface $input, OutputInterface $output)
    {
        $remote = $input->getOption('remote');

        $persistence = $this->getPersistence();

        if (null === $remote) {
            $dialog = $this->getHelper('dialog');

            $remote = $dialog->ask($output, 'Please enter a Git remote to clone and pull from and to push to: ');

            if (!$dialog->askConfirmation($output, '<question>'.$remote.' will be cloned into '.$persistence->getDirectoryName().'. Continue? [y] </question>', false)) {
                $output->writeln('Not cloning, cancelled.');

                return;
            }
        }

        $output->writeln('Cloning...');
        $persistence->cloneRepository($remote);

        $output->writeln(sprintf('Init of git repository for remote "%s" in %s successful', $remote, $persistence->getDirectoryName()));
    }
435430
public function withIdentifier(bool $identifier): self
    {
        $metadata = clone $this;
        $metadata->identifier = $identifier;

        return $metadata;
    }
952176
public function addIdentifier(string $identifier)
    {
        $count = $this->queueRepository->countOpenByIdentifier($identifier);
        if ($count > 0) {
            return;
        }

        $this->logger->debug('SFC Queue add', [$identifier]);

        $data = [
            'cache_url' => $identifier,
            'page_uid' => 0,
            'invalid_date' => \time(),
            'call_result' => '',
        ];

        $this->queueRepository->insert($data);
    }
946236
private function loadContentType(string $identifier): ContentType
    {
        return $this->repository->sudo(
            static function (Repository $repository) use ($identifier): ContentType {
                return $repository->getContentTypeService()->loadContentTypeByIdentifier($identifier);
            }
        );
    }
813293
public function add($alias, $item = null, array $options = null)
    {
        $this->addItem($alias, $item, $options);
    }
592602
public function column($identifier, $options = []):self
    {
        if (is_callable($options)) {
            $column = new TextColumn($identifier, $options);
        } else {
            $column = new TextColumn($identifier, $options);
        }

        $this->columns->put($identifier, $column);

        return $this;
    }
369467
public function getPlaceholder(string $identifier): APIPlaceholder
    {
        if ($this->hasPlaceholder($identifier)) {
            return $this->placeholders[$identifier];
        }

        throw BlockException::noPlaceholder($identifier);
    }
1193935
public static function getAddonByIdentifier(string $identifier)
    {
        foreach (self::getAddons() as $addon) {
            if ($addon->getIdentifier() == $identifier) {
                return $addon;
            }
        }
        
        return null;
    }
16003
public function addGrantType(GrantTypeInterface $grantType, $identifier = null)
    {
        if (is_null($identifier) || is_numeric($identifier)) {
            $identifier = $grantType->getQueryStringIdentifier();
        }

        $this->grantTypes[$identifier] = $grantType;
    }
1251066
public function bindScopeIdentifiers(string $identifier, iterable $scopeIdentifiers): void
    {
        try {
            $schema = $this->getDatabaseSchema();
            $this->createBelongsToManyRelationship(
                $identifier,
                $scopeIdentifiers,
                $schema->getClientsScopesTable(),
                $schema->getClientsScopesClientIdentityColumn(),
                $schema->getClientsScopesScopeIdentityColumn()
            );
        } catch (RepositoryException $exception) {
            $message = 'Binding client scopes failed.';
            throw new RepositoryException($message, 0, $exception);
        }
    }
236390
public function read(int $identifier): ?TokenInterface
    {
        try {
            return $this->readResource($identifier);
        } catch (RepositoryException $exception) {
            $message = 'Token reading failed.';
            throw new RepositoryException($message, 0, $exception);
        }
    }
279038
private function executeAction($id, array $options)
    {
        $action = $this->adapter->post(sprintf('%s/floating_ips/%s/actions', $this->endpoint, $id), $options);

        $action = json_decode($action);

        return new ActionEntity($action->action);
    }
692884
public function setByIdentifier($identifier, NodeInterface $node = null)
    {
        $this->nodesByIdentifier[$identifier] = $node;
        if ($node !== null) {
            $this->nodesByPath[$node->getPath()] = $node;
        }
    }
545430
public function push($remote = 'origin', $branch = 'master', string $args = null)
    {
        if ($remote instanceof Remote) {
            $remote = $remote->getName();
        }
        if ($branch instanceof Branch) {
            $branch = $branch->getName();
        }
        $this->clearAll();
        $this->addCommandName(self::GIT_PUSH_COMMAND);
        $this->addCommandSubject($remote);
        $this->addCommandSubject2($branch);

        if(!is_null($args)) {
            $this->addCommandArgument($args);
        }

        return $this->getCommand();
    }
836056
public static function getRepository($identifier, $config = array())
    {
        if (strpos($identifier, 'repos:') === 0) {
            $repository = AnService::get($identifier);
        } else {
            $strIdentifier = (string) $identifier;

            if (!AnService::has($identifier)) {
                $identifier = self::getEntityIdentifier($identifier);
            }

            if (!AnService::has($identifier)) {
                AnService::set($strIdentifier, AnService::get($identifier, $config));
            }

            $repository = AnService::get($identifier)->getRepository();
        }

        return $repository;
    }
1095706
public function ensureContentTypeGroupDoesntExist($identifier)
    {

        /** @var \eZ\Publish\API\Repository\ContentTypeService */
        $contentTypeService = $this->contentTypeService;

        // attempt to delete the content type group with the identifier
        try {
            $contentTypeService->deleteContentTypeGroup(
                $contentTypeService->loadContentTypeGroupByIdentifier($identifier)
            );
        } catch (ApiExceptions\NotFoundException $e) {
            // nothing to do
        }
    }