/** * @param string $targetPath * @param string $installPath * @param array $map * @param bool $isSymlink * @param bool $isRelative * * @throws IOException * @throws \InvalidArgumentException * * @api * * @quality:method [B] */ public function publish($targetPath, $installPath, array $map, $isSymlink, $isRelative) { $targetPath = rtrim($targetPath, '/'); $installPath = rtrim($installPath, '/'); $this->filesystem->mkdir($targetPath, 0777); foreach ($map as $from => $to) { $targetDir = realpath($targetPath) . '/' . $to; $sourceDir = realpath($installPath) . '/' . $from; $this->filesystem->remove($targetDir); if ($isSymlink) { $this->io->write(sprintf('Trying to install AdminLTE %s assets as symbolic links.', $from)); $originDir = $sourceDir; if ($isRelative) { $originDir = $this->filesystem->makePathRelative($sourceDir, realpath($targetPath)); } try { $this->filesystem->symlink($originDir, $targetDir); $this->io->write(sprintf('The AdminLTE %s assets were installed using symbolic links.', $from)); } catch (IOException $e) { $this->hardCopy($sourceDir, $targetDir); $this->io->write(sprintf('It looks like your system doesn\'t support symbolic links, so the AdminLTE %s assets were installed by copying them.', $from)); } } else { $this->io->write(sprintf('Installing AdminLTE %s assets as <comment>hard copies</comment>.', $from)); $this->hardCopy($sourceDir, $targetDir); } } }
private function symlinkPackageToVendor($packagePath, $vendorPath) { $relative = $this->fileSystem->makePathRelative(realpath($packagePath), realpath($vendorPath . '/../')); $this->fileSystem->rename($vendorPath, $vendorPath . '_linked', true); $this->fileSystem->symlink($relative, $vendorPath); $this->fileSystem->remove($vendorPath . '_linked'); }
/** * Deploy build. * * @throws runtime_exception If deployment failed * @return $this */ public function deploy_build() { if (!$this->fs->exists($this->build_dir)) { return $this; } $this->build_parents(); $current_build = false; if ($this->fs->exists($this->production_link)) { if (is_link($this->production_link)) { $current_build = readlink($this->production_link); } } try { $new_build = $this->repo_dir . 'prod_' . time(); $this->fs->rename($this->build_dir, $new_build); $this->fs->remove($this->production_link); $this->fs->symlink($new_build, $this->production_link); } catch (\Exception $e) { $this->fs->remove($this->production_link); if ($current_build) { $this->fs->symlink($current_build, $this->production_link); } throw new runtime_exception('PACKAGES_BUILD_DEPLOYMENT_FAILED'); } if ($current_build) { $this->fs->remove($current_build); } return $this; }
/** * Copy all assets from a given path to the publish path. * * @param string $name * @param string $source * @throws \RuntimeException * @return bool */ public function publish($name, $source) { $destination = $this->publishPath . "/packages/{$name}"; try { $this->files->symlink($source, $destination); } catch (\Exception $e) { throw new \RuntimeException("Unable to publish assets."); } return true; }
/** * {@inheritdoc} */ public function symlink(string $origin, string $target, bool $copyOnWindows = false) { try { $this->filesystem->symlink($origin, $target, $copyOnWindows); } catch (IOException $exception) { throw new FilesystemException($exception->getMessage(), $exception->getPath(), $exception); } catch (Exception $exception) { throw new FilesystemException($exception->getMessage(), null, $exception); } }
/** * Generates a symlink. * * The method will try to generate relative symlinks and fall back to generating * absolute symlinks if relative symlinks are not supported (see #208). * * @param string $source The symlink name * @param string $target The symlink target * @param string $rootDir The root directory */ public static function symlink($source, $target, $rootDir) { static::validateSymlink($source, $target, $rootDir); $fs = new Filesystem(); if ('\\' === DIRECTORY_SEPARATOR) { $fs->symlink($rootDir . '/' . $source, $rootDir . '/' . $target); } else { $fs->symlink(rtrim($fs->makePathRelative($source, dirname($target)), '/'), $rootDir . '/' . $target); } }
/** * @param $source * @param $target */ protected function link($source, $target) { $targetDir = dirname($target); if (!$this->filesystem->exists($targetDir)) { $this->filesystem->mkdir($targetDir); } if ($this->filesystem->exists($target)) { $this->filesystem->remove($target); } $this->filesystem->symlink($source, $target); }
/** * Forces image caching and returns path to cached image. * * @param string $basePath Deprecated parameter * @param string $path * @param string $filter * @param boolean $force * @param string $saveAs * * @return string|null * * @throws RuntimeException */ public function cacheImage($basePath, $path, $filter, $force = false, $saveAs = null) { $path = '/' . ltrim($path, '/'); $saveAs = $saveAs ? '/' . ltrim($saveAs, '/') : $path; // if cache path cannot be determined, return 404 if (!($cachedPath = $this->cachePathResolver->getCachedPath($saveAs, $filter))) { return null; } // if the file has already been cached, just return path if (!$force && is_file($cachedPath)) { return $cachedPath; } if (!($sourcePath = $this->cachePathResolver->getRealPath($path, $filter))) { return null; } $this->ensureDirectoryExists($cachedPath); try { $image = $this->imagine->open($sourcePath); } catch (RuntimeException $e) { try { // Make sure source path is an image new ImageFile($sourcePath, false); // Do not pollute the space (don't copy anything; symlink is just fine) $this->filesystem->symlink($sourcePath, $cachedPath); } catch (RuntimeException $e) { return null; } catch (IOException $e) { // In case we were not able to create symlink we should return source path. // This means we'll be back here, but at least we'll not be polluting space with useless copies. return $sourcePath; } return $cachedPath; } $options = ['quality' => $this->filterManager->getOption($filter, 'quality', $this->defaultQuality), 'format' => $this->filterManager->getOption($filter, 'format', null)]; // Important! optipng filter returns an instance of ImageAssetWrapper. /** @var ImageInterface|ImageAssetWrapper $image */ $image = $this->filterManager->getFilter($filter)->apply($image); /** @var resource $context */ if ($context = $this->findStreamContext($cachedPath, $filter)) { $tmpPath = tempnam(sys_get_temp_dir(), 'avalanche-cache-manager-proxy-'); $image->save($tmpPath, $options); copy($tmpPath, $cachedPath, $context); unlink($tmpPath); } else { $image->save($cachedPath, $options); } $this->ensureFilePermissions($cachedPath); return $cachedPath; }
/** * {@inheritdoc} */ public function download(PackageInterface $package, $path) { $url = $package->getDistUrl(); $realUrl = realpath($url); if (false === $realUrl || !file_exists($realUrl) || !is_dir($realUrl)) { throw new \RuntimeException(sprintf('Source path "%s" is not found for package %s', $url, $package->getName())); } if (strpos(realpath($path) . DIRECTORY_SEPARATOR, $realUrl . DIRECTORY_SEPARATOR) === 0) { throw new \RuntimeException(sprintf('Package %s cannot install to "%s" inside its source at "%s"', $package->getName(), realpath($path), $realUrl)); } $fileSystem = new Filesystem(); $this->filesystem->removeDirectory($path); $this->io->writeError(sprintf(' - Installing <info>%s</info> (<comment>%s</comment>)', $package->getName(), $package->getFullPrettyVersion())); try { if (Platform::isWindows()) { // Implement symlinks as NTFS junctions on Windows $this->filesystem->junction($realUrl, $path); $this->io->writeError(sprintf(' Junctioned from %s', $url)); } else { $shortestPath = $this->filesystem->findShortestPath($path, $realUrl); $fileSystem->symlink($shortestPath, $path); $this->io->writeError(sprintf(' Symlinked from %s', $url)); } } catch (IOException $e) { $fileSystem->mirror($realUrl, $path); $this->io->writeError(sprintf(' Mirrored from %s', $url)); } $this->io->writeError(''); }
/** * Dumps all translation files. * * @param string $targetDir Target directory. * @param boolean $symlink True if generate symlink * * @return null */ public function dump($targetDir = 'web', $symlink = false, $directory = null) { $route = $this->router->getRouteCollection()->get('bazinga_exposetranslation_js'); $directory = null === $directory ? $this->kernel->getRootDir() . '/../' : $directory; $requirements = $route->getRequirements(); $formats = explode('|', $requirements['_format']); $routeDefaults = $route->getDefaults(); $defaultFormat = $routeDefaults['_format']; $parts = array_filter(explode('/', $route->getPattern())); $this->filesystem->remove($directory . $targetDir . "/" . current($parts)); foreach ($this->getTranslationMessages() as $locale => $domains) { foreach ($domains as $domain => $messageList) { foreach ($formats as $format) { $content = $this->engine->render('BazingaExposeTranslationBundle::exposeTranslation.' . $format . '.twig', array('messages' => array($domain => $messageList), 'locale' => $locale, 'defaultDomains' => $domain)); $path[$format] = $directory . $targetDir . strtr($route->getPattern(), array('{domain_name}' => $domain, '{_locale}' => $locale, '{_format}' => $format)); $this->filesystem->mkdir(dirname($path[$format]), 0777); if (file_exists($path[$format])) { $this->filesystem->remove($path[$format]); } file_put_contents($path[$format], $content); } $targetFile = $directory . $targetDir; $targetFile .= strtr($route->getPattern(), array('{domain_name}' => $domain, '{_locale}' => $locale, '.{_format}' => '')); if (true === $symlink) { $this->filesystem->symlink($path[$defaultFormat], $targetFile); } else { $this->filesystem->copy($path[$defaultFormat], $targetFile); } } } }
/** * Installs the assets under the web root directory. * * @param CommandEvent $event A CommandEvent instance */ public static function installAssets(CommandEvent $event) { $webDir = static::$options['pulsar-web-dir']; $fs = new Filesystem(); // $fs->mirror(sprintf('%s/../Resources/public', __DIR__), sprintf('%s/pulsar', $webDir)); $fs->symlink(sprintf('%s/../Resources/public', __DIR__), sprintf('%s/pulsar', $webDir), true); }
/** * Links Drupal core, modules, themes and assets into Drupal root. * * @param Event $event */ public static function prepareDrupalRoot(Event $event) { $options = self::getOptions($event); $composer = $event->getComposer(); $filesystem = new Filesystem(); $originDir = realpath($composer->getConfig()->get('vendor-dir') . '/drupal/drupal'); $targetDir = realpath($options['drupal-root']); if (is_dir($originDir)) { if ($options['drupal-install']['relative']) { $originDir = rtrim($filesystem->makePathRelative($originDir, $targetDir), '/'); } $directories = array('includes', 'misc', 'modules', 'themes'); foreach ($directories as $directory) { $filesystem->remove($targetDir . '/' . $directory); if ($options['drupal-install']['symlink']) { $event->getIO()->write(sprintf('Creating symlink for Drupal\'s \'%s\' directory', $directory)); $filesystem->symlink($originDir . '/' . $directory, $targetDir . '/' . $directory); } else { $event->getIO()->write(sprintf('Copying Drupal\'s \'%s\' directory to web root', $directory)); $filesystem->mkdir($targetDir . '/' . $directory, 0777); // We use a custom iterator to ignore VCS files $filesystem->mirror($originDir . '/' . $directory, $targetDir . '/' . $directory, Finder::create()->ignoreDotFiles(false)->in($originDir)); } } } }
/** * Installs Drupal under the web root directory. * * @param $event CommandEvent A instance */ public static function installDrupal(CommandEvent $event) { $options = self::getOptions($event); $webDir = $options['symfony-web-dir']; $composer = $event->getComposer(); $filesystem = new Filesystem(); $packages = $composer->getPackage()->getRequires(); $drupal_root = $composer->getConfig()->get('vendor-dir') . DIRECTORY_SEPARATOR . $packages['drupal/drupal']->getTarget(); $directories = array('includes', 'misc', 'modules', 'themes'); foreach ($directories as $directory) { $originDir = '../' . $drupal_root . '/' . $directory; $targetDir = $webDir . '/' . $directory; echo sprintf('Creating symlink for Drupal\'s \'%s\' directory', $directory) . PHP_EOL; $filesystem->symlink($originDir, $targetDir); } $directory = 'sites'; $targetDir = $webDir . '/' . $directory . '/'; // Check for sites/default because sites/all may exist if composer installs // modules or themes. if (!$filesystem->exists($targetDir . '/default')) { $originDir = $drupal_root . '/' . $directory; echo sprintf('Creating new sites directory', $directory) . PHP_EOL; $filesystem->mirror($originDir, $targetDir, null, array('override' => true)); } }
/** * @inheritdoc */ public function postActivation(ConnectionInterface $con = null) { $fileSystem = new Filesystem(); //Check for environment if ($env = $this->getContainer()->getParameter('kernel.environment')) { //Check for backward compatibility if ($env !== "prod" && $env !== "dev") { //Remove separtion between dev and prod in particular environment $env = str_replace('_dev', '', $env); $this->webMediaEnvPath = $this->webMediaPath . DS . $env; } } // Create symbolic links or hard copy in the web directory // (according to \Thelia\Action\Document::CONFIG_DELIVERY_MODE), // to make the TinyMCE code available. if (false === $fileSystem->exists($this->webJsPath)) { if (ConfigQuery::read(Document::CONFIG_DELIVERY_MODE) === 'symlink') { $fileSystem->symlink($this->jsPath, $this->webJsPath); } else { $fileSystem->mirror($this->jsPath, $this->webJsPath); } } // Create the media directory in the web root , if required if (null !== $this->webMediaEnvPath) { if (false === $fileSystem->exists($this->webMediaEnvPath)) { $fileSystem->mkdir($this->webMediaEnvPath . DS . 'upload'); $fileSystem->mkdir($this->webMediaEnvPath . DS . 'thumbs'); } } else { if (false === $fileSystem->exists($this->webMediaPath)) { $fileSystem->mkdir($this->webMediaPath . DS . 'upload'); $fileSystem->mkdir($this->webMediaPath . DS . 'thumbs'); } } }
/** * @param $origin * @param $target */ private function doSymlinkAsset($origin, $target) { $this->filesystem->symlink($origin, $target); if (!file_exists($target)) { throw new IOException('Symbolic link is broken'); } }
/** * @param $dir * @param InputInterface $input * @param OutputInterface $output * @return bool */ private function installPluginAssets($dir, InputInterface $input, OutputInterface $output) { // Create the specific assets directory otherwise symlink will fail. $assetsDir = $dir . '/assets/plugins/'; $this->filesystem->mkdir($assetsDir, 0777); $plugins = $this->getContainer()->get('simplr.pluginmanager')->getActivePlugins(); if (!empty($plugins)) { foreach ($plugins as $name => $configuration) { $activePluginPath = $this->getContainer()->get('simplr.pluginmanager')->getPathToPlugin($name); if (is_dir($originDir = $activePluginPath . '/Resources/public')) { $targetDir = $assetsDir . strtolower($name); $output->writeln(sprintf("Installing assets for plugin <comment>%s</comment> into <comment>%s</comment>", $name, $targetDir)); $this->filesystem->remove($targetDir); if ($input->getOption('symlink')) { if ($input->getOption('relative')) { $relativeOriginDir = $this->filesystem->makePathRelative($originDir, realpath($assetsDir)); } else { $relativeOriginDir = $originDir; } $this->filesystem->symlink($relativeOriginDir, $targetDir); } else { $this->filesystem->mkdir($targetDir, 0777); // We use a custom iterator to ignore VCS files $this->filesystem->mirror($originDir, $targetDir, Finder::create()->in($originDir)); } } } } else { $output->writeln('Installing assets for plugins... no plugins found!'); } return true; }
protected static function symlink($origin, $target) { $filesystem = new Filesystem(); try { $filesystem->symlink($origin, $target); } catch (\Exception $e) { } }
/** * Symlink given path to latest in file system * * @param string $path * @author Daniel Wendlandt */ public function symlinkLatestBackup($path) { $latestPath = dirname($path) . DIRECTORY_SEPARATOR . self::SYMLINK_LATEST; if ($this->filesytsem->exists($latestPath)) { $this->filesytsem->remove($latestPath); } $this->filesytsem->symlink($path, $latestPath); }
/** * {@inheritdoc} */ public function symlink($origin_dir, $target_dir, $copy_on_windows = false) { try { $this->symfony_filesystem->symlink($origin_dir, $target_dir, $copy_on_windows); } catch (\Symfony\Component\Filesystem\Exception\IOException $e) { throw new filesystem_exception('CANNOT_CREATE_SYMLINK', $origin_dir, array(), $e); } }
/** * */ public function save() { $fs = new Filesystem(); $fs->dumpFile(Platform::sharedDir() . '/settings.local.php', $this->string); // Relink if missing. if (!$fs->exists(Platform::webDir() . '/sites/default/settings.local.php')) { $fs->symlink('../../../shared/settings.local.php', Platform::webDir() . '/sites/default/settings.local.php'); } }
/** * {@inheritdoc} */ public function download(PackageInterface $package, $path) { $url = $package->getDistUrl(); $realUrl = realpath($url); if (false === $realUrl || !file_exists($realUrl) || !is_dir($realUrl)) { throw new \RuntimeException(sprintf('Source path "%s" is not found for package %s', $url, $package->getName())); } if (strpos(realpath($path) . DIRECTORY_SEPARATOR, $realUrl . DIRECTORY_SEPARATOR) === 0) { throw new \RuntimeException(sprintf('Package %s cannot install to "%s" inside its source at "%s"', $package->getName(), realpath($path), $realUrl)); } // Get the transport options with default values $transportOptions = $package->getTransportOptions() + array('symlink' => null); // When symlink transport option is null, both symlink and mirror are allowed $currentStrategy = self::STRATEGY_SYMLINK; $allowedStrategies = array(self::STRATEGY_SYMLINK, self::STRATEGY_MIRROR); if (true === $transportOptions['symlink']) { $currentStrategy = self::STRATEGY_SYMLINK; $allowedStrategies = array(self::STRATEGY_SYMLINK); } elseif (false === $transportOptions['symlink']) { $currentStrategy = self::STRATEGY_MIRROR; $allowedStrategies = array(self::STRATEGY_MIRROR); } $fileSystem = new Filesystem(); $this->filesystem->removeDirectory($path); $this->io->writeError(sprintf(' - Installing <info>%s</info> (<comment>%s</comment>)', $package->getName(), $package->getFullPrettyVersion())); if (self::STRATEGY_SYMLINK == $currentStrategy) { try { if (Platform::isWindows()) { // Implement symlinks as NTFS junctions on Windows $this->filesystem->junction($realUrl, $path); $this->io->writeError(sprintf(' Junctioned from %s', $url)); } else { $absolutePath = $path; if (!$this->filesystem->isAbsolutePath($absolutePath)) { $absolutePath = getcwd() . DIRECTORY_SEPARATOR . $path; } $shortestPath = $this->filesystem->findShortestPath($absolutePath, $realUrl); $path = rtrim($path, "/"); $fileSystem->symlink($shortestPath, $path); $this->io->writeError(sprintf(' Symlinked from %s', $url)); } } catch (IOException $e) { if (in_array(self::STRATEGY_MIRROR, $allowedStrategies)) { $this->io->writeError(' <error>Symlink failed, fallback to use mirroring!</error>'); $currentStrategy = self::STRATEGY_MIRROR; } else { throw new \RuntimeException(sprintf('Symlink from "%s" to "%s" failed!', $realUrl, $path)); } } } // Fallback if symlink failed or if symlink is not allowed for the package if (self::STRATEGY_MIRROR == $currentStrategy) { $fileSystem->mirror($realUrl, $path); $this->io->writeError(sprintf(' Mirrored from %s', $url)); } $this->io->writeError(''); }
/** * Creates symbolic link. * * @param string $originDir * @param string $targetDir * @param bool $relative * * @throws IOException If link can not be created. */ private function symlink($originDir, $targetDir, $relative = false) { if ($relative) { $originDir = $this->filesystem->makePathRelative($originDir, realpath(dirname($targetDir))); } $this->filesystem->symlink($originDir, $targetDir); if (!file_exists($targetDir)) { throw new IOException(sprintf('Symbolic link "%s" was created but appears to be broken.', $targetDir), 0, null, $targetDir); } }
/** * @param Filesystem $filesystem * @param $path * @param $fileName * @param array|null $options */ public function save(Filesystem $filesystem, $path, $fileName, array $options = null) { $origin = "{$path}/{$fileName}"; $snapshotFileName = SnapshotManager::createNameForSnapshot(); $target = "{$path}/{$snapshotFileName}"; $freshFileName = SnapshotManager::FRESH_FILE; $freshFilePath = "{$path}/{$freshFileName}"; $filesystem->rename($origin, $target); $filesystem->symlink($target, $freshFilePath); }
/** * {@inheritdoc} */ public function download(PackageInterface $package, $path) { $fileSystem = new Filesystem(); $this->filesystem->removeDirectory($path); $this->io->writeError(sprintf(' - Installing <info>%s</info> (<comment>%s</comment>) from %s', $package->getName(), $package->getFullPrettyVersion(), $package->getDistUrl())); try { $fileSystem->symlink($package->getDistUrl(), $path); } catch (IOException $e) { $fileSystem->mirror($package->getDistUrl(), $path); } }
private function trySymlink($origin, $target) { try { $this->filesystem->symlink($origin, $target); if (file_exists($target)) { return true; } } catch (IOException $e) { } return false; }
public function testSymlinkIsNotOverwrittenIfAlreadyCreated() { $this->markAsSkippeIfSymlinkIsMissing(); $file = $this->workspace . DIRECTORY_SEPARATOR . 'file'; $link = $this->workspace . DIRECTORY_SEPARATOR . 'link'; touch($file); symlink($file, $link); $this->filesystem->symlink($file, $link); $this->assertTrue(is_link($link)); $this->assertEquals($file, readlink($link)); }
public function configure() { $fs = new Filesystem(); $fs->copy(CLI_ROOT . '/resources/stacks/wordpress/wp-config.php', Platform::webDir() . '/wp-config.php', true); $fs->remove(Platform::webDir() . '/wp-confg-sample.php'); $fs->dumpFile(Platform::sharedDir() . '/wp-config.local.php', $this->string); // Relink if missing. if (!$fs->exists(Platform::webDir() . '/wp-config.local.php')) { $fs->symlink('../shared/wp-config.local.php', Platform::webDir() . '/wp-config .local.php'); } }
/** * @inheritdoc */ protected function execute(InputInterface $input, OutputInterface $output) { $fs = new Filesystem(); $addon_id = $input->getArgument('name'); $abs_cart_path = rtrim(realpath($input->getArgument('cart-directory')), '\\/') . '/'; $this->validateCartPath($abs_cart_path, $input, $output); $abs_addon_path = rtrim(realpath($input->getArgument('addon-directory')), '\\/') . '/'; chdir($abs_addon_path); $addon = new Addon($addon_id, $abs_addon_path); $addon_files_glob_masks = $addon->getFilesGlobMasks(); $addon_files_glob_masks = array_filter($addon_files_glob_masks, function ($glob_mask) { // Always ignore "design/themes/" masks because there shouldn't // be such directory in add-on files directory if (mb_strpos($glob_mask, 'design/themes/') === 0) { return false; } return true; }); $glob_matches = $addon->matchFilesAgainstGlobMasks($addon_files_glob_masks, $abs_addon_path); $output->writeln(sprintf('<fg=magenta;options=bold>Creating symlinks at the "%s" directory:</>', $abs_cart_path)); foreach ($glob_matches as $rel_filepath) { $abs_addon_filepath = $abs_addon_path . $rel_filepath; // Add-on templates at the "var/themes_repository/" directory will be // symlinked to the "design/themes/" directory. if ($input->getOption('templates-to-design') && mb_strpos($rel_filepath, 'var/themes_repository/') === 0) { $abs_cart_filepath = $abs_cart_path . 'design/themes/' . mb_substr($rel_filepath, mb_strlen('var/themes_repository/')); } else { $abs_cart_filepath = $abs_cart_path . $rel_filepath; } // Delete existing files and links located at cart directory clearstatcache(true, $abs_cart_filepath); if (file_exists($abs_cart_filepath)) { $is_link = is_link($abs_cart_filepath); $is_file = $is_link ? is_file(readlink($abs_cart_filepath)) : is_file($abs_cart_filepath); $is_dir = $is_link ? is_dir(readlink($abs_cart_filepath)) : is_dir($abs_cart_filepath); // Confirm overwriting of the found conflicting file or directory on the same path. // We only ask confirmation for files which are not symbolic links, because we assume // that symbolic links were created by this command earlier and can be overwritten without // the loss of any data. if (!$is_link && ($is_file || $is_dir)) { $helper = $this->getHelper('question'); $question = new ConfirmationQuestion(sprintf('<question>%s "%s" already exists. Overwrite? [y/N]:</question> ', $is_dir ? 'Directory' : 'File', $abs_cart_filepath), false); if (!$helper->ask($input, $output, $question)) { continue; } } $fs->remove($abs_cart_filepath); } $symlink_target_filepath = $input->getOption('relative') ? $fs->makePathRelative(dirname($abs_addon_filepath), dirname($abs_cart_filepath)) . basename($abs_cart_filepath) : $abs_addon_filepath; $fs->symlink($symlink_target_filepath, $abs_cart_filepath); $output->writeln(sprintf('Creating symlink for %s... <info>OK</info>', $rel_filepath)); } }
/** * */ public function configure() { $fs = new Filesystem(); if (!file_exists(Platform::webDir() . '/sites/default/settings.php')) { $fs->copy(CLI_ROOT . '/resources/stacks/drupal/drupal7.settings.php', Platform::webDir() . '/sites/default/settings.php', true); } $fs->dumpFile(Platform::sharedDir() . '/settings.local.php', $this->string); // Relink if missing. if (!$fs->exists(Platform::webDir() . '/sites/default/settings.local.php')) { $fs->symlink('../../../shared/settings.local.php', Platform::webDir() . '/sites/default/settings.local.php'); } }
public function testSymlinkCreatesTargetDirectoryIfItDoesNotExist() { $this->markAsSkippedIfSymlinkIsMissing(); $file = $this->workspace . DIRECTORY_SEPARATOR . 'file'; $link1 = $this->workspace . DIRECTORY_SEPARATOR . 'dir' . DIRECTORY_SEPARATOR . 'link'; $link2 = $this->workspace . DIRECTORY_SEPARATOR . 'dir' . DIRECTORY_SEPARATOR . 'subdir' . DIRECTORY_SEPARATOR . 'link'; $this->filesystem->symlink($file, $link1); $this->filesystem->symlink($file, $link2); $this->assertTrue(is_link($link1)); $this->assertEquals($file, readlink($link1)); $this->assertTrue(is_link($link2)); $this->assertEquals($file, readlink($link2)); }