Installer Class Reference

Inheritance diagram for Installer:

Public Member Functions
	__construct (IOInterface $io, Composer $composer, $type='magento-module')
	setDeployManager (DeployManager $deployManager)
	setConfig (ProjectConfig $config)
	getDeployManager ()
	setDeployStrategy ($strategy)
	getDeployStrategy (PackageInterface $package, $strategy=null)
	supports ($packageType)
	getTargetDir ()
	install (InstalledRepositoryInterface $repo, PackageInterface $package)
	getGitIgnoreFileLocation ()
	appendGitIgnore (PackageInterface $package, $ignoreFile)
	prepareMagentoCore ()
	update (InstalledRepositoryInterface $repo, PackageInterface $initial, PackageInterface $target)
	toggleMagentoMaintenanceMode ($active=false)
	clearMagentoCache ()
	uninstall (InstalledRepositoryInterface $repo, PackageInterface $package)
	getParser (PackageInterface $package)
	getInstallPath (PackageInterface $package)
	transformArrayKeysToLowerCase ($array)
	annoy (IOInterface $io)

Data Fields
const	MAGENTO_REMOVE_DEV_FLAG = 'magento-remove-dev'
const	MAGENTO_MAINTANANCE_FLAG = 'maintenance.flag'
const	MAGENTO_CACHE_PATH = 'var/cache'
const	MAGENTO_ROOT_DIR_TMP_SUFFIX = '_tmp'
const	MAGENTO_ROOT_DIR_BACKUP_SUFFIX = '_bkup'

Protected Member Functions
	initializeMagentoRootDir ()
	getSourceDir (PackageInterface $package)
	preInstallMagentoCore ()
	clearRootDir ()
	setMagentoPermissions ()
	setPermissions ($path, $dirmode, $filemode)
	redeployProject ()
	preUpdateMagentoCore ()
	postUpdateMagentoCore ()
	cleanupPostUpdateMagentoCore ()

Protected Attributes
	$magentoRootDir = null
	$defaultMagentoRootDir = './'
	$modmanRootDir = null
	$isForced = false
	$_source_dir
	$_deployStrategy = "copy"
	$noMaintenanceMode = false
	$originalMagentoRootDir = null
	$backupMagentoRootDir = null
	$removeMagentoDev = false
	$keepMagentoCache = false
	$_magentoLocalXmlPath = 'app/etc/local.xml'
	$_defaultEnvFilePaths
	$_magentoDevDir = 'dev'
	$_magentoWritableDirs
	$deployManager
	$config
	$appendGitIgnore = false
	$_pathMappingTranslations = array()

Detailed Description

Composer Magento Installer

Definition at line 22 of file Installer.php.

Constructor & Destructor Documentation

__construct()

__construct	(	IOInterface	$io,
		Composer	$composer,
			$type = 'magento-module'
	)

Initializes Magento Module installer

Parameters

\Composer\IO\IOInterface	$io
\Composer\Composer	$composer
string	$type

Exceptions

Definition at line 117 of file Installer.php.

    {
        parent::__construct($io, $composer, $type);
        $this->initializeVendorDir();

        $this->annoy( $io );

        $extra = $composer->getPackage()->getExtra();

        if (isset($extra['magento-root-dir']) || $rootDirInput = $this->defaultMagentoRootDir) {

            if (isset($rootDirInput)) {
                $extra['magento-root-dir'] = $rootDirInput;
            }

            $dir = rtrim(trim($extra['magento-root-dir']), '/\\');
            $this->magentoRootDir = new \SplFileInfo($dir);
            if (!is_dir($dir) && $io->askConfirmation('magento root dir "' . $dir . '" missing! create now? [Y,n] ')) {
                $this->initializeMagentoRootDir($dir);
                $io->write('magento root dir "' . $dir . '" created');
            }

            if (!is_dir($dir)) {
                $dir = $this->vendorDir . "/$dir";
                $this->magentoRootDir = new \SplFileInfo($dir);
            }
        }

        if (isset($extra['modman-root-dir'])) {

            $dir = rtrim(trim($extra['modman-root-dir']), '/\\');
            if (!is_dir($dir)) {
                $dir = $this->vendorDir . "/$dir";
            }
            if (!is_dir($dir)) {
                throw new \ErrorException("modman root dir \"{$dir}\" is not valid");
            }
            $this->modmanRootDir = new \SplFileInfo($dir);
        }

        if (isset($extra['magento-deploystrategy'])) {
            $this->_deployStrategy = (string)$extra['magento-deploystrategy'];
            if($this->_deployStrategy !== "copy"){
                $io->write("<warning>Warning: Magento 2 is not tested with \"{$this->_deployStrategy}\" deployment strategy. It may not function properly.</warning>");
            }
        }

        if ((is_null($this->magentoRootDir) || false === $this->magentoRootDir->isDir())
            && $this->_deployStrategy != 'none'
        ) {
            $dir = $this->magentoRootDir instanceof \SplFileInfo ? $this->magentoRootDir->getPathname() : '';
            $io->write("<error>magento root dir \"{$dir}\" is not valid</error>", true);
            $io->write('<comment>You need to set an existing path for "magento-root-dir" in your composer.json</comment>', true);
            $io->write('<comment>For more information please read about the "Usage" in the README of the installer Package</comment>', true);
            throw new \ErrorException("magento root dir \"{$dir}\" is not valid");
        }

        if (isset($extra['magento-force'])) {
            $this->isForced = (bool)$extra['magento-force'];
        }

        if (false !== getenv('MAGENTO_CLOUD_PROJECT')) {
            $this->setDeployStrategy('none');
        }

        if (isset($extra['magento-deploystrategy'])) {
            $this->setDeployStrategy((string)$extra['magento-deploystrategy']);
        }

        if (!empty($extra['auto-append-gitignore'])) {
            $this->appendGitIgnore = true;
        }

        if (!empty($extra['path-mapping-translations'])) {
            $this->_pathMappingTranslations = (array)$extra['path-mapping-translations'];
        }
    }

Member Function Documentation

annoy()

annoy

(

IOInterface

$io

)

this function is for annoying people with messages.

First usage: get people to vote about the future release of composer so later I can say "you wanted it this way"

Parameters

IOInterface

$io

No <error> in future, as some people look for error lines inside of CI Applications, which annoys them

Definition at line 812 of file Installer.php.

    {

        /*
        $io->write('<comment> time for voting about the future of the #magento #composer installer. </comment>', true);
        $io->write('<comment> https://github.com/magento-hackathon/magento-composer-installer/blob/discussion-master/Milestone/2/index.md </comment>', true);
        $io->write('<error> For the case you don\'t vote, I will ignore your problems till iam finished with the resulting release. </error>', true);
         * 
         **/
    }

appendGitIgnore()

appendGitIgnore	(	PackageInterface	$package,
			$ignoreFile
	)

Add all the files which are to be deployed to the .gitignore file, if it doesn't exist then create a new one

Parameters

PackageInterface	$package
string	$ignoreFile

Definition at line 448 of file Installer.php.

    {
        $contents = array();
        if(file_exists($ignoreFile)) {
            $contents = file($ignoreFile, FILE_IGNORE_NEW_LINES);
        }

        $additions = array();
        foreach($this->getParser($package)->getMappings() as $map) {
            $dest   = $map[1];
            $ignore = sprintf("/%s", $dest);
            $ignore = str_replace('/./','/', $ignore);
            $ignore = str_replace('//','/', $ignore);
            $ignore = rtrim($ignore,'/');
            if(!in_array($ignore, $contents)) {
                $ignoredMappings = $this->getDeployStrategy($package)->getIgnoredMappings();
                if( in_array($ignore, $ignoredMappings) ){
                    continue;
                }
                
                $additions[] = $ignore;
            }
        }

        if(!empty($additions)) {
            array_unshift($additions, '#' . $package->getName());
            $contents = array_merge($contents, $additions);
            file_put_contents($ignoreFile, implode("\n", $contents));
        }
        
        if ($package->getType() === 'magento-core') {
            $this->prepareMagentoCore();
        }
    }

cleanupPostUpdateMagentoCore()

cleanupPostUpdateMagentoCore ( )

protected

Definition at line 669 of file Installer.php.

                                                      {
        $rootDir = $this->magentoRootDir->getPathname();
        $backupDir = $this->backupMagentoRootDir->getPathname();
        $persistentFolders = array('media', 'var');
        copy($backupDir . DIRECTORY_SEPARATOR . $this->_magentoLocalXmlPath, $rootDir . DIRECTORY_SEPARATOR . $this->_magentoLocalXmlPath);
        foreach ($persistentFolders as $folder) {
            $this->filesystem->removeDirectory($rootDir . DIRECTORY_SEPARATOR . $folder);
            $this->filesystem->rename($backupDir . DIRECTORY_SEPARATOR . $folder, $rootDir . DIRECTORY_SEPARATOR . $folder);
        }
        if ($this->io->ask('Remove root backup? [Y,n] ', true)) {
            $this->filesystem->removeDirectory($backupDir);
            $this->io->write('Removed root backup!', true);
        } else {
            $this->io->write('Skipping backup removal...', true);
        }
        $this->clearMagentoCache();
    }

clearMagentoCache()

clearMagentoCache

(

)

Definition at line 700 of file Installer.php.

                                        {
        if (($targetDir = $this->getTargetDir()) && !$this->keepMagentoCache) {
            $magentoCachePath = $targetDir . DIRECTORY_SEPARATOR . self::MAGENTO_CACHE_PATH;
            if ($this->filesystem->removeDirectory($magentoCachePath)) {
                $this->io->write('Magento cache cleared');
            }
        }
    }

clearRootDir()

clearRootDir ( )

protected

Definition at line 498 of file Installer.php.

                                      {
        $this->filesystem->removeDirectory($this->magentoRootDir->getPathname());
        $this->filesystem->ensureDirectoryExists($this->magentoRootDir->getPathname());
    }

getDeployManager()

getDeployManager

(

)

Returns

DeployManager

Definition at line 213 of file Installer.php.

    {
        return $this->deployManager;
    }

getDeployStrategy()

getDeployStrategy	(	PackageInterface	$package,
			$strategy = null
	)

Returns the strategy class used for deployment

Parameters

\Composer\Package\PackageInterface	$package
string	$strategy

Returns

\MagentoHackathon\Composer\Magento\Deploystrategy\DeploystrategyAbstract

Definition at line 312 of file Installer.php.

    {
        if (null === $strategy) {
            $strategy = $this->_deployStrategy;
        }
        $extra  = $this->composer->getPackage()->getExtra();
        if( isset($extra['magento-deploystrategy-overwrite']) ){
            $moduleSpecificDeployStrategys = $this->transformArrayKeysToLowerCase($extra['magento-deploystrategy-overwrite']);
            if( isset($moduleSpecificDeployStrategys[$package->getName()]) ){
                $strategy = $moduleSpecificDeployStrategys[$package->getName()];
            }
        }
        $moduleSpecificDeployIgnores = array();
        if( isset($extra['magento-deploy-ignore']) ){
            $extra['magento-deploy-ignore'] = $this->transformArrayKeysToLowerCase($extra['magento-deploy-ignore']);
            if( isset($extra['magento-deploy-ignore']["*"]) ){
                $moduleSpecificDeployIgnores = $extra['magento-deploy-ignore']["*"];
            }
            if( isset($extra['magento-deploy-ignore'][$package->getName()]) ){
                $moduleSpecificDeployIgnores = array_merge(
                    $moduleSpecificDeployIgnores, 
                    $extra['magento-deploy-ignore'][$package->getName()]
                );
            }
        }
        if($package->getType() === 'magento-core'){
            $strategy = 'copy';
        }
        $targetDir = $this->getTargetDir();
        $sourceDir = $this->getSourceDir($package);
        switch ($strategy) {
            case 'symlink':
                $impl = new \MagentoHackathon\Composer\Magento\Deploystrategy\Symlink($sourceDir, $targetDir);
                break;
            case 'link':
                $impl = new \MagentoHackathon\Composer\Magento\Deploystrategy\Link($sourceDir, $targetDir);
                break;
            case 'none':
                $impl = new \MagentoHackathon\Composer\Magento\Deploystrategy\None($sourceDir, $targetDir);
                break;
            case 'copy':
            default:
                $impl = new \MagentoHackathon\Composer\Magento\Deploystrategy\Copy($sourceDir, $targetDir);
        }
        // Inject isForced setting from extra config
        $impl->setIsForced($this->isForced);
        $impl->setIgnoredMappings($moduleSpecificDeployIgnores);
        return $impl;
    }

getGitIgnoreFileLocation()

getGitIgnoreFileLocation

(

)

Get .gitignore file location

Returns

string

Definition at line 433 of file Installer.php.

    {
        $ignoreFile = $this->magentoRootDir->getPathname() . '/.gitignore';

        return $ignoreFile;
    }

getInstallPath()

getInstallPath

(

PackageInterface

$package

)

Definition at line 775 of file Installer.php.

    {

        if (!is_null($this->modmanRootDir) && true === $this->modmanRootDir->isDir()) {
            $targetDir = $package->getTargetDir();
            if (!$targetDir) {
                list($vendor, $targetDir) = explode('/', $package->getPrettyName());
            }
            $installPath = $this->modmanRootDir . '/' . $targetDir;
        } else {
            $installPath = parent::getInstallPath($package);
        }

        // Make install path absolute. This is needed in the symlink deploy strategies.
        if (DIRECTORY_SEPARATOR !== $installPath[0] && $installPath[1] !== ':') {
            $installPath = getcwd() . "/$installPath";
        }

        return $installPath;
    }

getParser()

getParser

(

PackageInterface

$package

)

Returns the modman parser for the vendor dir

Parameters

PackageInterface

$package

Returns

Parser

Exceptions

Definition at line 743 of file Installer.php.

    {
        $extra = $package->getExtra();
        $moduleSpecificMap = $this->composer->getPackage()->getExtra();
        if( isset($moduleSpecificMap['magento-map-overwrite']) ){
            $moduleSpecificMap = $this->transformArrayKeysToLowerCase($moduleSpecificMap['magento-map-overwrite']);
            if( isset($moduleSpecificMap[$package->getName()]) ){
                $map = $moduleSpecificMap[$package->getName()];
            }
        }
        $suffix = PackageTypes::$packageTypes[$package->getType()];
        if (isset($map)) {
            $parser = new MapParser($map, $this->_pathMappingTranslations,$suffix);
            return $parser;
        } elseif (isset($extra['map'])) {
            $parser = new MapParser($extra['map'], $this->_pathMappingTranslations, $suffix);
            return $parser;
        } elseif (isset($extra['package-xml'])) {
            $parser = new PackageXmlParser($this->getSourceDir($package), $extra['package-xml'], $this->_pathMappingTranslations, $suffix);
            return $parser;
        } elseif (file_exists($this->getSourceDir($package) . '/modman')) {
            $parser = new ModmanParser($this->getSourceDir($package), $this->_pathMappingTranslations, $suffix);
            return $parser;
        } else {
            throw new \ErrorException('Unable to find deploy strategy for module: no known mapping');
        }

    }

getSourceDir()

getSourceDir ( PackageInterface  $package )

protected

Return Source dir of package

Parameters

\Composer\Package\PackageInterface

$package

Returns

string

Definition at line 379 of file Installer.php.

    {
        $this->filesystem->ensureDirectoryExists($this->vendorDir);
        return $this->getInstallPath($package);
    }

getTargetDir()

getTargetDir

(

)

Return the absolute target directory path for package installation

Returns

string

Definition at line 390 of file Installer.php.

    {
        $targetDir = realpath($this->magentoRootDir->getPathname());
        return $targetDir;
    }

initializeMagentoRootDir()

initializeMagentoRootDir ( )

protected

Create base requrements for project installation

Definition at line 221 of file Installer.php.

                                                  {
        if (!$this->magentoRootDir->isDir()) {
            $magentoRootPath = $this->magentoRootDir->getPathname();
            $pathParts = explode(DIRECTORY_SEPARATOR, $magentoRootPath);
            $baseDir = explode(DIRECTORY_SEPARATOR, $this->vendorDir);
            array_pop($baseDir);
            $pathParts = array_merge($baseDir, $pathParts);
            $directoryPath = '';
            foreach ($pathParts as $pathPart) {
                $directoryPath .=  $pathPart . DIRECTORY_SEPARATOR;
                $this->filesystem->ensureDirectoryExists($directoryPath);
            }
        }

        // $this->getSourceDir($package);
    }

install()

install	(	InstalledRepositoryInterface	$repo,
		PackageInterface	$package
	)

Installs specific package

Parameters

InstalledRepositoryInterface	$repo	repository in which to check
PackageInterface	$package	package instance

Definition at line 402 of file Installer.php.

    {

        if ($package->getType() === 'magento-core' && !$this->preInstallMagentoCore()) {
            return;
        }

        parent::install($repo, $package);

        // skip marshal and apply default behavior if extra->map does not exist
        if (!$this->hasExtraMap($package)) {
            return;
        }

        $strategy = $this->getDeployStrategy($package);
        $strategy->setMappings($this->getParser($package)->getMappings());
        $deployManagerEntry = new Entry();
        $deployManagerEntry->setPackageName($package->getName());
        $deployManagerEntry->setDeployStrategy($strategy);
        $this->deployManager->addPackage($deployManagerEntry);

        if ($this->appendGitIgnore) {
            $this->appendGitIgnore($package, $this->getGitIgnoreFileLocation());
        }
    }

postUpdateMagentoCore()

postUpdateMagentoCore ( )

protected

Definition at line 655 of file Installer.php.

                                               {
        $tmpDir = $this->magentoRootDir->getPathname();
        $backupDir = $this->originalMagentoRootDir->getPathname() . self::MAGENTO_ROOT_DIR_BACKUP_SUFFIX;
        $this->backupMagentoRootDir = new \SplFileInfo($backupDir);

        $origRootDir = $this->originalMagentoRootDir->getPathName();
        $this->filesystem->rename($origRootDir, $backupDir);
        $this->filesystem->rename($tmpDir, $origRootDir);
        $this->magentoRootDir = clone $this->originalMagentoRootDir;

        $this->prepareMagentoCore();
        $this->cleanupPostUpdateMagentoCore();
    }

preInstallMagentoCore()

preInstallMagentoCore ( )

protected

Install Magento core

Parameters

InstalledRepositoryInterface	$repo	repository in which to check
PackageInterface	$package	package instance

Definition at line 489 of file Installer.php.

                                               {
        if (!$this->io->askConfirmation('<info>Are you sure you want to install the Magento core?</info><error>Attention: Your Magento root dir will be cleared in the process!</error> [<comment>Y,n</comment>] ', true)) {
            $this->io->write('Skipping core installation...');
            return false;
        }
        $this->clearRootDir();
        return true;
    }

prepareMagentoCore()

prepareMagentoCore

(

)

Definition at line 503 of file Installer.php.

                                         {
        $this->setMagentoPermissions();
        $this->redeployProject();
    }

preUpdateMagentoCore()

preUpdateMagentoCore ( )

protected

Definition at line 643 of file Installer.php.

                                              {
        if (!$this->io->askConfirmation('<info>Are you sure you want to manipulate the Magento core installation</info> [<comment>Y,n</comment>]? ', true)) {
            $this->io->write('Skipping core update...');
            return false;
        }
        $tmpDir = $this->magentoRootDir->getPathname() . self::MAGENTO_ROOT_DIR_TMP_SUFFIX;
        $this->filesystem->ensureDirectoryExists($tmpDir);
        $this->originalMagentoRootDir = clone $this->magentoRootDir;
        $this->magentoRootDir = new \SplFileInfo($tmpDir);
        return true;
    }

redeployProject()

redeployProject ( )

protected

Definition at line 551 of file Installer.php.

                                         {
        $ioInterface = $this->io;
        // init repos
        $composer = $this->composer;
        $installedRepo = $composer->getRepositoryManager()->getLocalRepository();

        $dm = $composer->getDownloadManager();
        $im = $composer->getInstallationManager();

        /*
         * @var $moduleInstaller MagentoHackathon\Composer\Magento\Installer
         */
        $moduleInstaller = $im->getInstaller("magento-module");

        foreach ($installedRepo->getPackages() as $package) {

            if ($ioInterface->isVerbose()) {
                $ioInterface->write($package->getName());
            $ioInterface->write($package->getType());
            }

            if ($package->getType() != "magento-module") {
                continue;
            }
            if ($ioInterface->isVerbose()) {
                $ioInterface->write("package {$package->getName()} recognized");
            }

            $strategy = $moduleInstaller->getDeployStrategy($package);
            if ($ioInterface->getOption('verbose')) {
            $ioInterface->write("used " . get_class($strategy) . " as deploy strategy");
            }
            $strategy->setMappings($moduleInstaller->getParser($package)->getMappings());

            $strategy->deploy();
        }


        return;
    }

setConfig()

setConfig

(

ProjectConfig

$config

)

Definition at line 205 of file Installer.php.

    {
        $this->config = $config;
    }

setDeployManager()

setDeployManager

(

DeployManager

$deployManager

)

Parameters

DeployManager

$deployManager

Definition at line 199 of file Installer.php.

    {
        $this->deployManager = $deployManager;
    }

setDeployStrategy()

setDeployStrategy

(

$strategy

)

Parameters

string

$strategy

Definition at line 300 of file Installer.php.

    {
        $this->_deployStrategy = $strategy;
    }

setMagentoPermissions()

setMagentoPermissions ( )

protected

some directories have to be writable for the server

Definition at line 511 of file Installer.php.

                                               {
        foreach ($this->_magentoWritableDirs as $dir) {
            if (!file_exists($this->getTargetDir() . DIRECTORY_SEPARATOR . $dir)) {
                mkdir($this->getTargetDir() . DIRECTORY_SEPARATOR . $dir, 0777, true);
            }
            $this->setPermissions($this->getTargetDir() . DIRECTORY_SEPARATOR . $dir, 0777, 0666);
        }
    }

setPermissions()

setPermissions (   $path,   $dirmode,   $filemode  )

protected

set permissions recursively

Parameters

string	$path	Path to set permissions for
int	$dirmode	Permissions to be set for directories
int	$filemode	Permissions to be set for files

Definition at line 527 of file Installer.php.

                                                                  {
        if (is_dir($path)) {
            if (!@chmod($path, $dirmode)) {
                $this->io->write(
                        'Failed to set permissions "%s" for directory "%s"', decoct($dirmode), $path
                );
            }
            $dh = opendir($path);
            while (($file = readdir($dh)) !== false) {
                if ($file != '.' && $file != '..') { // skip self and parent pointing directories
                    $fullpath = $path . '/' . $file;
                    $this->setPermissions($fullpath, $dirmode, $filemode);
                }
            }
            closedir($dh);
        } elseif (is_file($path)) {
            if (false == !@chmod($path, $filemode)) {
                $this->io->write(
                        'Failed to set permissions "%s" for file "%s"', decoct($filemode), $path
                );
            }
        }
    }

supports()

supports

(

$packageType

)

Decides if the installer supports the given type

Parameters

string

$packageType

Returns

bool

Definition at line 368 of file Installer.php.

    {
        return array_key_exists($packageType, PackageTypes::$packageTypes);
    }

toggleMagentoMaintenanceMode()

toggleMagentoMaintenanceMode

(

$active = false

)

Definition at line 687 of file Installer.php.

                                                                  {
        if (($targetDir = $this->getTargetDir()) && !$this->noMaintenanceMode) {
            $flagPath = $targetDir . DIRECTORY_SEPARATOR . self::MAGENTO_MAINTANANCE_FLAG;
            if ($active) {
                $this->io->write("Adding magento maintenance flag...");
                file_put_contents($flagPath, '*');
            } elseif (file_exists($flagPath)) {
                $this->io->write("Removing magento maintenance flag...");
                unlink($flagPath);
            }
        }
    }

transformArrayKeysToLowerCase()

transformArrayKeysToLowerCase

(

$array

)

Definition at line 796 of file Installer.php.

    {
        $arrayNew = array();
        foreach($array as $key=>$value){
            $arrayNew[strtolower($key)] = $value;
        }
        return $arrayNew;
    }

uninstall()

uninstall	(	InstalledRepositoryInterface	$repo,
		PackageInterface	$package
	)

Uninstalls specific package.

Parameters

InstalledRepositoryInterface	$repo	repository in which to check
PackageInterface	$package	package instance

Definition at line 715 of file Installer.php.

    {
        // skip marshal and apply default behavior if extra->map does not exist
        if (!$this->hasExtraMap($package)) {
            parent::uninstall($repo, $package);
            return;
        }

        $strategy = $this->getDeployStrategy($package);
        $strategy->setMappings($this->getParser($package)->getMappings());
        try {
            $strategy->clean();
        } catch (\ErrorException $e) {
            if ($this->io->isDebug()) {
                $this->io->write($e->getMessage());
            }
        }

        parent::uninstall($repo, $package);
    }

update()

update	(	InstalledRepositoryInterface	$repo,
		PackageInterface	$initial,
		PackageInterface	$target
	)

Updates specific package

Parameters

InstalledRepositoryInterface	$repo	repository in which to check
PackageInterface	$initial	already installed package version
PackageInterface	$target	updated version

Exceptions

InvalidArgumentException

if $from package is not installed

Definition at line 601 of file Installer.php.

    {

        if ($target->getType() === 'magento-core' && !$this->preUpdateMagentoCore()) {
            return;
        }

        // cleanup marshaled files if extra->map exist
        if ($this->hasExtraMap($initial)) {
            $initialStrategy = $this->getDeployStrategy($initial);
            $initialStrategy->setMappings($this->getParser($initial)->getMappings());
            try {
                $initialStrategy->clean();
            } catch (\ErrorException $e) {
                if ($this->io->isDebug()) {
                    $this->io->write($e->getMessage());
                }
            }
        }

        parent::update($repo, $initial, $target);

        // marshal files for new package version if extra->map exist
        if ($this->hasExtraMap($target)) {
            $targetStrategy = $this->getDeployStrategy($target);
            $targetStrategy->setMappings($this->getParser($target)->getMappings());
            $deployManagerEntry = new Entry();
            $deployManagerEntry->setPackageName($target->getName());
            $deployManagerEntry->setDeployStrategy($targetStrategy);
            $this->deployManager->addPackage($deployManagerEntry);
        }

        if($this->appendGitIgnore) {
            $this->appendGitIgnore($target, $this->getGitIgnoreFileLocation());
        }

        if ($target->getType() === 'magento-core') {
            $this->postUpdateMagentoCore();
        }
    }

Field Documentation

$_defaultEnvFilePaths

$_defaultEnvFilePaths

protected

Initial value:

= array(
        'app/etc/local.xml'
    )

Definition at line 76 of file Installer.php.

$_deployStrategy

$_deployStrategy = "copy"

protected

Definition at line 62 of file Installer.php.

$_magentoDevDir

$_magentoDevDir = 'dev'

protected

Definition at line 79 of file Installer.php.

$_magentoLocalXmlPath

$_magentoLocalXmlPath = 'app/etc/local.xml'

protected

Definition at line 75 of file Installer.php.

$_magentoWritableDirs

$_magentoWritableDirs

protected

Initial value:

= array(
        'app/etc',
        'media',
        'var'
    )

Definition at line 80 of file Installer.php.

$_pathMappingTranslations

$_pathMappingTranslations = array()

protected

Definition at line 107 of file Installer.php.

$_source_dir

$_source_dir

protected

Definition at line 57 of file Installer.php.

$appendGitIgnore

$appendGitIgnore = false

protected

Definition at line 101 of file Installer.php.

$backupMagentoRootDir

$backupMagentoRootDir = null

protected

Definition at line 72 of file Installer.php.

$config

$config

protected

Definition at line 94 of file Installer.php.

$defaultMagentoRootDir

$defaultMagentoRootDir = './'

protected

Definition at line 36 of file Installer.php.

$deployManager

$deployManager

protected

Definition at line 89 of file Installer.php.

$isForced

$isForced = false

protected

Definition at line 50 of file Installer.php.

$keepMagentoCache

$keepMagentoCache = false

protected

Definition at line 74 of file Installer.php.

$magentoRootDir

$magentoRootDir = null

protected

Definition at line 29 of file Installer.php.

$modmanRootDir

$modmanRootDir = null

protected

Definition at line 43 of file Installer.php.

$noMaintenanceMode

$noMaintenanceMode = false

protected

Definition at line 70 of file Installer.php.

$originalMagentoRootDir

$originalMagentoRootDir = null

protected

Definition at line 71 of file Installer.php.

$removeMagentoDev

$removeMagentoDev = false

protected

Definition at line 73 of file Installer.php.

MAGENTO_CACHE_PATH

const MAGENTO_CACHE_PATH = 'var/cache'

Definition at line 66 of file Installer.php.

MAGENTO_MAINTANANCE_FLAG

const MAGENTO_MAINTANANCE_FLAG = 'maintenance.flag'

Definition at line 65 of file Installer.php.

MAGENTO_REMOVE_DEV_FLAG

const MAGENTO_REMOVE_DEV_FLAG = 'magento-remove-dev'

Definition at line 64 of file Installer.php.

MAGENTO_ROOT_DIR_BACKUP_SUFFIX

const MAGENTO_ROOT_DIR_BACKUP_SUFFIX = '_bkup'

Definition at line 68 of file Installer.php.

MAGENTO_ROOT_DIR_TMP_SUFFIX

const MAGENTO_ROOT_DIR_TMP_SUFFIX = '_tmp'

Definition at line 67 of file Installer.php.

---

The documentation for this class was generated from the following file:

• vendor/magento/magento-composer-installer/src/MagentoHackathon/Composer/Magento/Installer.php