/** * Move file. * * @param string $directory * @param null|string $name * @param bool $overwrite * * @return File */ public function move($directory, $name = null, $overwrite = false) { $targetFile = $this->getTargetFile($directory, $name); $this->fileSystem->rename($this->getPathname(), $targetFile, $overwrite); $this->fileSystem->chmod($targetFile, 0666, umask()); return $targetFile; }
public static function createRequiredFiles(Event $event) { $fs = new Filesystem(); $root = static::getDrupalRoot(getcwd()); $dirs = ['modules', 'profiles', 'themes']; // Required for unit testing foreach ($dirs as $dir) { if (!$fs->exists($root . '/' . $dir)) { $fs->mkdir($root . '/' . $dir); $fs->touch($root . '/' . $dir . '/.gitkeep'); } } // Prepare the settings file for installation if (!$fs->exists($root . '/sites/default/settings.php')) { $fs->copy($root . '/sites/default/default.settings.php', $root . '/sites/default/settings.php'); $fs->chmod($root . '/sites/default/settings.php', 0666); $event->getIO()->write("Create a sites/default/settings.php file with chmod 0666"); } // Prepare the services file for installation if (!$fs->exists($root . '/sites/default/services.yml')) { $fs->copy($root . '/sites/default/default.services.yml', $root . '/sites/default/services.yml'); $fs->chmod($root . '/sites/default/services.yml', 0666); $event->getIO()->write("Create a sites/default/services.yml file with chmod 0666"); } // Create the files directory with chmod 0777 if (!$fs->exists($root . '/sites/default/files')) { $oldmask = umask(0); $fs->mkdir($root . '/sites/default/files', 0777); umask($oldmask); $event->getIO()->write("Create a sites/default/files directory with chmod 0777"); } }
/** * {@inheritdoc} */ public function chmod($file, $mode) { try { $this->filesystem->chmod($this->getRealPathName($file), $mode); return true; } catch (\Exception $e) { return false; } }
/** * @param int $mode * @throws IOException * @return Dir */ protected function ensureWritable($mode = 0777) { try { $this->io->mkdir($this->dir, $mode); $this->io->chmod($this->dir, $mode, 00, TRUE); } catch (SfException $e) { throw new IOException("Please make directory '{$this->dir}' writable, it cannot be done automatically", 0, $e); } return $this; }
protected function tearDown() { parent::tearDown(); $this->filesystem->chmod(self::REMOTE_REPOSITORY_DIRECTORY, 0777, 00, true); $this->filesystem->remove(self::REMOTE_REPOSITORY_DIRECTORY); if (is_dir(self::LOCAL_REPOSITORY_DIRECTORY)) { $this->filesystem->chmod(self::LOCAL_REPOSITORY_DIRECTORY, 0777, 00, true); $this->filesystem->remove(self::LOCAL_REPOSITORY_DIRECTORY); } }
/** * @override \ComponentManager\Step\Step * * @param \ComponentManager\Task\InstallTask $task */ public function execute($task, LoggerInterface $logger) { $resolvedComponentVersions = $task->getResolvedComponentVersions(); foreach ($resolvedComponentVersions as $resolvedComponentVersion) { $logger->info('Installing component', ['component' => $resolvedComponentVersion->getComponent()->getName(), 'packageRepository' => $resolvedComponentVersion->getPackageRepository()->getName(), 'version' => $resolvedComponentVersion->getVersion()->getVersion(), 'release' => $resolvedComponentVersion->getVersion()->getRelease()]); $projectLockFile = $this->project->getProjectLockFile(); $component = $resolvedComponentVersion->getComponent(); $packageSource = $this->project->getPackageSource($resolvedComponentVersion->getSpecification()->getPackageSource()); $typeDirectory = $this->moodle->getPluginTypeDirectory($component->getPluginType()); $targetDirectory = $this->platform->joinPaths([$typeDirectory, $component->getPluginName()]); $tempDirectory = $this->platform->createTempDirectory(); $sourceDirectory = $packageSource->obtainPackage($tempDirectory, $resolvedComponentVersion, $this->filesystem, $logger); if ($resolvedComponentVersion->getFinalVersion() === null) { $logger->warning('Package source did not indicate final version; defaulting to desired version', ['version' => $resolvedComponentVersion->getVersion()->getVersion()]); $resolvedComponentVersion->setFinalVersion($resolvedComponentVersion->getVersion()->getVersion()); } $logger->debug('Downloaded component source', ['packageSource' => $packageSource->getName(), 'sourceDirectory' => $sourceDirectory]); if ($this->filesystem->exists($targetDirectory)) { $logger->info('Component directory already exists; removing', ['targetDirectory' => $targetDirectory]); $this->filesystem->remove($targetDirectory); } $logger->info('Copying component source to Moodle directory', ['sourceDirectory' => $sourceDirectory, 'targetDirectory' => $targetDirectory]); $this->filesystem->mirror($sourceDirectory, $targetDirectory); $logger->info('Pinning component at installed final version', ['finalVersion' => $resolvedComponentVersion->getFinalVersion()]); $projectLockFile->addResolvedComponentVersion($resolvedComponentVersion); $logger->info('Cleaning up after component installation', ['tempDirectory' => $tempDirectory]); try { $this->filesystem->chmod([$tempDirectory], 0750, 00, true); $this->filesystem->remove([$tempDirectory]); } catch (IOException $e) { $logger->warning('Unable to clean up temporary directory', ['code' => $e->getCode(), 'message' => $e->getMessage(), 'tempDirectory' => $tempDirectory]); } } }
/** * Creates the container file from the discovered providers. * * @param Discovery $discovery */ public static function compileContainer(Discovery $discovery) { $containerFile = self::getContainerFilePath(); $compiler = new Compiler(); $bindings = $discovery->findBindings('container-interop/DefinitionProviderFactories'); $definitionProviders = []; $priorities = []; foreach ($bindings as $binding) { /* @var $binding ClassBinding */ $definitionProviderFactoryClassName = $binding->getClassName(); // From the factory class name, let's call the buildDefinitionProvider static method to get the definitionProvider. $definitionProviders[] = call_user_func([$definitionProviderFactoryClassName, 'buildDefinitionProvider'], $discovery); $priorities[] = $binding->getParameterValue('priority'); } // Sort definition providers according to their priorities. array_multisort($priorities, $definitionProviders); foreach ($definitionProviders as $provider) { $compiler->register($provider); } $containerFileContent = $compiler->compile('\\TheCodingMachine\\Yaco\\Container'); $filesystem = new Filesystem(); if (!$filesystem->exists(dirname($containerFile))) { $filesystem->mkdir(dirname($containerFile)); } $filesystem->dumpFile($containerFile, $containerFileContent); $filesystem->chmod($containerFile, 0664); }
/** * @return int 0 if OK, 1 if ERROR */ public function installHooks() { try { if (!$this->filesystem->exists($this->hooksDestinationPath)) { $this->filesystem->mkdir($this->hooksDestinationPath); } $hooks = []; foreach (new \DirectoryIterator($this->hooksSourcePath) as $hook) { if ($hook->isDot()) { continue; } $hooks[] = $hook->getFilename(); } $this->progressBarInit(count($hooks)); foreach ($hooks as $hook) { $sourceFile = $this->hooksSourcePath . '/' . $hook; $destinationFile = $this->hooksDestinationPath . '/' . $hook; $this->backupHook($destinationFile); $this->filesystem->copy($sourceFile, $destinationFile, true); $this->filesystem->chmod($destinationFile, 0755); $this->progressBarAdvance(); $this->outputWriteln(" <info>Copying {$sourceFile} to {$destinationFile}</info>", true); } $this->progressBarFinish(); $this->outputWriteln(''); $this->outputWriteln(sprintf('<info>Hooks installed succesfully %s</info>', Constants::CHARACTER_THUMB_UP)); } catch (\Exception $e) { $this->outputWriteln(" <error>" . $e->getMessage() . " Aborting</error>"); return 1; } return 0; }
/** * Loads a container and returns it. * * If the cache file for the service container exists and is current, it * will be loaded and returned. Otherwise, a new container will be built * using the configuration file and the provided optional builder. The * builder will be used to make changes to the service container before * it is compiled and cached. * * It may be important to note that debug mode for the `ConfigCache` class * is enabled by default. This will ensure that cached configuration files * are updated whenever they are changed. * * @param string $containerCacheFilePath The container cache file path. * @param callable $containerBuilderCallable The new container builder callable. * @param string $compiledContainerClassName The compiled container class name. * @param boolean $debug Is debugging mode enabled? * * @return Jarvis The loaded application. */ public static function create($containerCacheFilePath, callable $containerBuilderCallable = null, $compiledContainerClassName = 'AppCachedContainer', $debug = true) { $cacheManager = new ConfigCache($containerCacheFilePath, $debug); if (!$cacheManager->isFresh()) { $container = static::createContainer(); if (null !== $containerBuilderCallable) { $containerBuilderCallable($container); } if ($debug) { $filename = pathinfo($containerCacheFilePath, PATHINFO_DIRNAME) . '/' . pathinfo($containerCacheFilePath, PATHINFO_FILENAME) . '.xml'; $container->setParameter('debug.container.dump', $filename); } $container->compile(); $dumper = new PhpDumper($container); $cacheManager->write($dumper->dump(array('class' => $compiledContainerClassName)), $container->getResources()); if ($debug) { $filename = $container->getParameter('debug.container.dump'); $dumper = new XmlDumper($container); $filesystem = new Filesystem(); $filesystem->dumpFile($filename, $dumper->dump(), null); try { $filesystem->chmod($filename, 0666, umask()); } catch (IOException $e) { // discard chmod failure (some filesystem may not support it) } } } if (!class_exists($compiledContainerClassName)) { /** @noinspection PhpIncludeInspection */ require $containerCacheFilePath; } return new Jarvis(new $compiledContainerClassName()); }
/** * @param string $currentRevision * @param string $distantRevision */ protected function upgrade($currentRevision, $distantRevision) { $fs = new Filesystem(); $versionDir = sprintf('%s/versions', $this->config->get('twgit.protected.global.root_dir')); if (!is_dir($versionDir)) { mkdir($versionDir, 0755); } $newPharFile = sprintf('%s/twgit-%s.phar', $versionDir, $distantRevision); $oldPharFile = sprintf('%s/twgit-%s.phar-old', $versionDir, $currentRevision); $currentPharFile = realpath(str_replace(['phar://', '/src/NMR/Command'], ['', ''], __DIR__)); $this->getLogger()->info('Download new version...'); $this->getClient()->get(self::REMOTE_URL_PHAR, ['save_to' => $newPharFile]); if ($fs->exists($newPharFile)) { $this->getLogger()->info('Backup current version...'); if ($fs->exists($oldPharFile)) { $fs->remove($oldPharFile); } $fs->rename($currentPharFile, $oldPharFile); $this->getLogger()->info('Install new version...'); $fs->remove($currentPharFile); $fs->rename($newPharFile, $currentPharFile); $fs->chmod($currentPharFile, 0777); } else { $this->getLogger()->error('Failed to download new version.'); } }
/** * @param InputInterface $input * @param OutputInterface $output * * @throws Exception * @return void */ protected function execute(InputInterface $input, OutputInterface $output) { $fs = new Filesystem(); $localFilename = realpath($_SERVER['argv'][0]) ?: $_SERVER['argv'][0]; $tmpDir = dirname($localFilename); $tmpFilename = 'forge-cli-tmp.phar'; $tmpFilepath = $tmpDir . '/' . $tmpFilename; if (!is_writable($tmpDir)) { throw new Exception('Forge update failed: "' . $tmpDir . '" is not writable. Try `sudo !!`.'); } if (!is_writable($localFilename)) { throw new Exception('Forge update failed: "' . $localFilename . '" is not writable. Try `sudo !!`.'); } $output->writeln('<info>Updating ' . $localFilename . '...</info>'); $file = file_get_contents(self::SRC, false, $this->createStreamContext($output)); $fs->dumpFile($tmpFilepath, $file, true); if ($fs->exists($tmpFilepath)) { $fs->rename($tmpFilepath, $localFilename, true); $fs->remove($tmpFilepath); $fs->chmod($localFilename, 0777); $output->writeln('<info>Update completed!</info>'); } else { throw new Exception('Update Failed...'); } }
protected function tearDown() { parent::tearDown(); $filesystem = new Filesystem(); // Ensure all files in the directory are writable before removing $filesystem->chmod($this->tempDir, 0755, 00, true); $filesystem->remove($this->tempDir); }
/** * Create default directories for domain. * * @param Domain $domain */ public function createDirectories(Domain $domain) { $fs = new Filesystem(); $dirs = array_merge(array($domain->getPath()), $this->_getDefaultDirs($domain->getPath())); $fs->mkdir($dirs, 0750); $fs->chmod($dirs, 0750); $this->_changeDirectoryOwner($domain); }
protected static function chmod($dir, $mode) { $filesystem = new Filesystem(); try { $filesystem->chmod($dir, $mode); } catch (\Exception $e) { } }
public function write($content, array $metadata = null) { $mode = 0666; $umask = umask(); $filesystem = new Filesystem(); $filesystem->dumpFile($this->file, $content, null); try { $filesystem->chmod($this->file, $mode, $umask); } catch (IOException $e) { } if (null !== $metadata) { $filesystem->dumpFile($this->getMetaFile(), serialize($metadata), null); try { $filesystem->chmod($this->getMetaFile(), $mode, $umask); } catch (IOException $e) { } } }
/** * Creates named temporary file * * @param $fileName * @param bool $preserve * @return \SplFileInfo * @throws \Exception */ public function createFile($fileName, $preserve = false) { $this->initRunFolder(); $fileInfo = new \SplFileInfo($this->tmpRunFolder . DIRECTORY_SEPARATOR . $fileName); $this->filesystem->touch($fileInfo); $this->files[] = array('file' => $fileInfo, 'preserve' => $preserve); $this->filesystem->chmod($fileInfo, 0600); return $fileInfo; }
/** * @param string $directory * @param OutputInterface $output * * @throws AccessDeniedException if directory/file permissions cannot be changed */ private function changePermissions($directory, OutputInterface $output) { try { $this->filesystem->chmod($directory, 0755, 00, true); $output->writeln(sprintf('<comment>Changed "%s" permissions to 0755.</comment>', $directory)); } catch (IOException $exception) { throw new AccessDeniedException(dirname($directory)); } }
/** * Create directory * @param string $directory */ private function createDirectory($directory) { if (!$this->filesystem->exists($directory)) { $this->filesystem->mkdir($directory); } $directory = new \SplFileInfo($directory); if (!$directory->isWritable()) { $this->filesystem->chmod($directory->getRealPath(), 0777); } }
/** * @param object $item * @param FeedTypeInterface[] $types * @param bool $force * * @return bool */ public function cacheItem($item, array $types = [], $force = false) { if (false === $this->supports($item)) { return false; } if (empty($types)) { $types = $this->getTypesForItem($item); } foreach ($types as $type) { $template = $type->getTemplate(); $cacheFile = $this->getItemCacheFilename($item, $type); if (!file_exists($cacheFile) || $force) { $xml = $this->getWriter($type)->renderItem($item, $template); $this->filesystem->dumpFile($cacheFile, $xml, null); $this->filesystem->chmod($cacheFile, 0666, umask()); } } return true; }
/** * {@inheritdoc} */ public function chmod($paths, int $mode, int $umask = 00, bool $recursive = false) { try { $this->filesystem->chmod($paths, $mode, $umask, $recursive); } catch (IOException $exception) { throw new FilesystemException($exception->getMessage(), $exception->getPath(), $exception); } catch (Exception $exception) { throw new FilesystemException($exception->getMessage(), null, $exception); } }
/** * @test * @expectedException \RuntimeException */ public function NotWritable_ThrowException() { $fs = new Filesystem(); $fs->remove(self::$kernelCacheDir); $fs->mkdir(self::$kernelCacheDir, 00); $this->initContainer(); $this->container->compile(); $fs->chmod(self::$kernelCacheDir, 7777); $fs->remove(self::$kernelCacheDir); }
protected function tearDown() { $fs = new Filesystem(); try { $fs->chmod([$this->root, $this->file], 0755); } catch (IOException $e) { // ignore exception } $fs->remove($this->root); }
/** * @param string $name * @param string $operation * @param array $configuration */ private function buildConfig($name, $operation, array $configuration) { $upperOperation = strtoupper($operation); $path = sprintf('%s/%s.%s', $this->pathBuild, $name, $operation); list($operationSkl, $functionSkl, $caseSkl, $mainSkl) = $this->getSkeletons($operation); $content = $operationSkl; $contentMain = $mainSkl; $contentFunctions = ''; $contentCases = ''; foreach ($configuration['connections'] as $connectionName => $connection) { list($function, $case) = $this->buildConnection($operation, $connectionName, $connection, $functionSkl, $caseSkl); $contentFunctions .= $function; $contentCases .= $case; } $content = str_replace(sprintf('__%s_FUNCTIONS__', $upperOperation), $contentFunctions, $content); $contentMain = str_replace('__CASES__', $contentCases, $contentMain); $content = str_replace(sprintf('__%s_MAIN__', $upperOperation), $contentMain, $content); $this->fileSystem->dumpFile($path, $content); $this->fileSystem->chmod($path, 0775); }
/** * Writes cache. * * @param string $content The content to write in the cache * @param ResourceInterface[] $metadata An array of ResourceInterface instances * * @throws \RuntimeException When cache file can't be wrote */ public function write($content, array $metadata = null) { $mode = 0666; $umask = umask(); $filesystem = new Filesystem(); $filesystem->dumpFile($this->file, $content, null); try { $filesystem->chmod($this->file, $mode, $umask); } catch (IOException $e) { // discard chmod failure (some filesystem may not support it) } if (null !== $metadata && true === $this->debug) { $filesystem->dumpFile($this->getMetaFile(), serialize($metadata), null); try { $filesystem->chmod($this->getMetaFile(), $mode, $umask); } catch (IOException $e) { // discard chmod failure (some filesystem may not support it) } } }
public function testChmodChangesZeroModeOnSubdirectoriesOnRecursive() { $this->markAsSkippedIfChmodIsMissing(); $directory = $this->workspace . DIRECTORY_SEPARATOR . 'directory'; $subdirectory = $directory . DIRECTORY_SEPARATOR . 'subdirectory'; mkdir($directory); mkdir($subdirectory); chmod($subdirectory, 00); $this->filesystem->chmod($directory, 0753, 00, true); $this->assertEquals(753, $this->getFilePermissions($subdirectory)); }
/** * */ public function configure() { $fs = new Filesystem(); $fs->chmod(Platform::webDir() . '/sites/default', 0775); $fs->chmod(Platform::webDir() . '/sites/default/settings.php', 0664); if ($this->version == DrupalStackHelper::DRUPAL7) { $fs->copy(CLI_ROOT . '/resources/stacks/drupal/drupal7.settings.php', Platform::webDir() . '/sites/default/settings.php', true); } elseif ($this->version == DrupalStackHelper::DRUPAL8) { $fs->copy(CLI_ROOT . '/resources/stacks/drupal/drupal8.settings.php', Platform::webDir() . '/sites/default/settings.php', true); } if ($this->version == DrupalStackHelper::DRUPAL8) { $fs->mkdir([Platform::sharedDir() . '/config', Platform::sharedDir() . '/config/active', Platform::sharedDir() . '/config/staging']); } $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'); } $this->drushrc(); }
public function process(ContainerBuilder $container) { $filename = self::getCompilerLogFilename($container); $filesystem = new Filesystem(); $filesystem->dumpFile($filename, implode("\n", $container->getCompiler()->getLog()), null); try { $filesystem->chmod($filename, 0666, umask()); } catch (IOException $e) { // discard chmod failure (some filesystem may not support it) } }
public function testChmodChangesModeOfTraversableFileObject() { $directory = $this->workspace . DIRECTORY_SEPARATOR . 'directory'; $file = $this->workspace . DIRECTORY_SEPARATOR . 'file'; $files = new \ArrayObject(array($directory, $file)); mkdir($directory); touch($file); $this->filesystem->chmod($files, 0753); $this->assertEquals(753, $this->getFilePermisions($file)); $this->assertEquals(753, $this->getFilePermisions($directory)); }
public static function create($kernelRootDir, Filesystem $filesystem) { $branchLogoDir = realpath($kernelRootDir . '/../web') . Logo::PATH_TO_LOGO_DIR; if (!$filesystem->exists($branchLogoDir)) { $filesystem->mkdir($branchLogoDir); } $branchLogoDir = new \SplFileInfo($branchLogoDir); if (!$branchLogoDir->isWritable()) { $filesystem->chmod($branchLogoDir->getRealPath(), 0777); } return new BranchLogoHandler($branchLogoDir, $filesystem); }
/** * @param InputInterface $input * @param OutputInterface $output * * @return int|void */ public function execute(InputInterface $input, OutputInterface $output) { $this->input = $input; $gitHooksPath = $this->paths()->getGitHooksDir(); $resourceHooksPath = $this->paths()->getGitHookTemplatesDir() . $this->grumPHP->getHooksPreset(); $resourceHooksPath = $this->paths()->getPathWithTrailingSlash($resourceHooksPath); $customHooksPath = $this->paths()->getPathWithTrailingSlash($this->grumPHP->getHooksDir()); // Some git clients to not automatically create a git hooks folder. if (!$this->filesystem->exists($gitHooksPath)) { $this->filesystem->mkdir($gitHooksPath); $output->writeln(sprintf('<fg=yellow>Created git hooks folder at: %s</fg=yellow>', $gitHooksPath)); } foreach (self::$hooks as $hook) { $gitHook = $gitHooksPath . $hook; $hookTemplate = $resourceHooksPath . $hook; if ($customHooksPath && $this->filesystem->exists($customHooksPath . $hook)) { $hookTemplate = $customHooksPath . $hook; } if (!$this->filesystem->exists($hookTemplate)) { throw new \RuntimeException(sprintf('Could not find hook template for %s at %s.', $hook, $hookTemplate)); } $content = $this->parseHookBody($hook, $hookTemplate); file_put_contents($gitHook, $content); $this->filesystem->chmod($gitHook, 0775); } $output->writeln('<fg=yellow>Watch out! GrumPHP is sniffing your commits!<fg=yellow>'); }