PHP Filesystem::createDirectory方法代码示例

 public final function getLogPath()
 {
     $path = PhabricatorEnv::getEnvConfig('notification.log');
     try {
         $dir = dirname($path);
         if (!Filesystem::pathExists($dir)) {
             Filesystem::createDirectory($dir, 0755, true);
         }
     } catch (FilesystemException $ex) {
         throw new Exception(pht("Failed to create '%s'. You should manually create this directory.", $dir));
     }
     return $path;
 }

 private function installHookDirectory($path)
 {
     $readme = pht("To add custom hook scripts to this repository, add them to this " . "directory.\n\nPhabricator will run any executables in this directory " . "after running its own checks, as though they were normal hook " . "scripts.");
     Filesystem::createDirectory($path, 0755);
     Filesystem::writeFile($path . '/README', $readme);
 }

 /**
  * Get the path to a scratch file, if possible.
  *
  * @param string  Scratch file name.
  * @return mixed  File path, or false on failure.
  * @task scratch
  */
 public function getScratchFilePath($path)
 {
     $new_scratch_path = Filesystem::resolvePath('arc', $this->getMetadataPath());
     static $checked = false;
     if (!$checked) {
         $checked = true;
         $old_scratch_path = $this->getPath('.arc');
         // we only want to do the migration once
         // unfortunately, people have checked in .arc directories which
         // means that the old one may get recreated after we delete it
         if (Filesystem::pathExists($old_scratch_path) && !Filesystem::pathExists($new_scratch_path)) {
             Filesystem::createDirectory($new_scratch_path);
             $existing_files = Filesystem::listDirectory($old_scratch_path, true);
             foreach ($existing_files as $file) {
                 $new_path = Filesystem::resolvePath($file, $new_scratch_path);
                 $old_path = Filesystem::resolvePath($file, $old_scratch_path);
                 Filesystem::writeFile($new_path, Filesystem::readFile($old_path));
             }
             Filesystem::remove($old_scratch_path);
         }
     }
     return Filesystem::resolvePath($path, $new_scratch_path);
 }

 public function writeLocalArcConfig(array $config)
 {
     $json_encoder = new PhutilJSON();
     $json = $json_encoder->encodeFormatted($config);
     $dir = $this->localMetaDir;
     if (!strlen($dir)) {
         throw new Exception(pht('No working copy to write config into!'));
     }
     $local_dir = $dir . DIRECTORY_SEPARATOR . 'arc';
     if (!Filesystem::pathExists($local_dir)) {
         Filesystem::createDirectory($local_dir, 0755);
     }
     $config_file = $local_dir . DIRECTORY_SEPARATOR . 'config';
     Filesystem::writeFile($config_file, $json);
 }

 /**
  * @task storage
  */
 private function lockCache($wait = 0)
 {
     if ($this->lock) {
         throw new Exception('Trying to lockCache() with a lock!');
     }
     if (!Filesystem::pathExists($this->getCacheDirectory())) {
         Filesystem::createDirectory($this->getCacheDirectory(), 0755, true);
     }
     $lock = PhutilFileLock::newForPath($this->getCacheDirectory() . '.lock');
     $lock->lock($wait);
     $this->lock = $lock;
 }

 private function getBulkFileDataAtRevision($paths, $revision)
 {
     // Calling 'hg cat' on each file individually is slow (1 second per file
     // on a large repo) because mercurial has to decompress and parse the
     // entire manifest every time. Do it in one large batch instead.
     // hg cat will write the file data to files in a temp directory
     $tmpdir = Filesystem::createTemporaryDirectory();
     // Mercurial doesn't create the directories for us :(
     foreach ($paths as $path) {
         $tmppath = $tmpdir . '/' . $path;
         Filesystem::createDirectory(dirname($tmppath), 0755, true);
     }
     list($err, $stdout) = $this->execManualLocal('cat --rev %s --output %s -- %C', $revision, $tmpdir . '/%p', implode(' ', $paths));
     $filedata = array();
     foreach ($paths as $path) {
         $tmppath = $tmpdir . '/' . $path;
         if (Filesystem::pathExists($tmppath)) {
             $filedata[$path] = Filesystem::readFile($tmppath);
         }
     }
     Filesystem::remove($tmpdir);
     return $filedata;
 }

 public function writeToDisk($path)
 {
     $changes = $this->getChanges();
     $change_list = array();
     foreach ($changes as $change) {
         $change_list[] = $change->toDictionary();
     }
     $hunks = array();
     foreach ($change_list as $change_key => $change) {
         foreach ($change['hunks'] as $key => $hunk) {
             $hunks[] = $hunk['corpus'];
             $change_list[$change_key]['hunks'][$key]['corpus'] = count($hunks) - 1;
         }
     }
     $blobs = array();
     foreach ($change_list as $change) {
         if (!empty($change['metadata']['old:binary-phid'])) {
             $blobs[$change['metadata']['old:binary-phid']] = null;
         }
         if (!empty($change['metadata']['new:binary-phid'])) {
             $blobs[$change['metadata']['new:binary-phid']] = null;
         }
     }
     foreach ($blobs as $phid => $null) {
         $blobs[$phid] = $this->getBlob($phid);
     }
     $meta_info = array('version' => 5, 'projectName' => $this->getProjectID(), 'baseRevision' => $this->getBaseRevision(), 'revisionID' => $this->getRevisionID(), 'encoding' => $this->getEncoding(), 'authorName' => $this->getAuthorName(), 'authorEmail' => $this->getAuthorEmail());
     $dir = Filesystem::createTemporaryDirectory();
     Filesystem::createDirectory($dir . '/hunks');
     Filesystem::createDirectory($dir . '/blobs');
     Filesystem::writeFile($dir . '/changes.json', json_encode($change_list));
     Filesystem::writeFile($dir . '/meta.json', json_encode($meta_info));
     foreach ($hunks as $key => $hunk) {
         Filesystem::writeFile($dir . '/hunks/' . $key, $hunk);
     }
     foreach ($blobs as $key => $blob) {
         Filesystem::writeFile($dir . '/blobs/' . $key, $blob);
     }
     execx('(cd %s; tar -czf %s *)', $dir, Filesystem::resolvePath($path));
     Filesystem::remove($dir);
 }

 private function writeCache($root, $file, $data)
 {
     $path = $this->getCachePath($root, $file);
     $cache_dir = dirname($path);
     if (!Filesystem::pathExists($cache_dir)) {
         Filesystem::createDirectory($cache_dir, 0755, true);
     }
     Filesystem::writeFile($path, $data);
 }

 protected function parseLaunchArguments(PhutilArgumentParser $args)
 {
     $config_file = $args->getArg('config');
     if ($config_file) {
         $full_path = Filesystem::resolvePath($config_file);
         $show_path = $full_path;
     } else {
         $root = dirname(dirname(phutil_get_library_root('phabricator')));
         $try = array('phabricator/conf/aphlict/aphlict.custom.json', 'phabricator/conf/aphlict/aphlict.default.json');
         foreach ($try as $config) {
             $full_path = $root . '/' . $config;
             $show_path = $config;
             if (Filesystem::pathExists($full_path)) {
                 break;
             }
         }
     }
     echo tsprintf("%s\n", pht('Reading configuration from: %s', $show_path));
     try {
         $data = Filesystem::readFile($full_path);
     } catch (Exception $ex) {
         throw new PhutilArgumentUsageException(pht('Failed to read configuration file. %s', $ex->getMessage()));
     }
     try {
         $data = phutil_json_decode($data);
     } catch (Exception $ex) {
         throw new PhutilArgumentUsageException(pht('Configuration file is not properly formatted JSON. %s', $ex->getMessage()));
     }
     try {
         PhutilTypeSpec::checkMap($data, array('servers' => 'list<wild>', 'logs' => 'optional list<wild>', 'cluster' => 'optional list<wild>', 'pidfile' => 'string', 'memory.hint' => 'optional int'));
     } catch (Exception $ex) {
         throw new PhutilArgumentUsageException(pht('Configuration file has improper configuration keys at top ' . 'level. %s', $ex->getMessage()));
     }
     $servers = $data['servers'];
     $has_client = false;
     $has_admin = false;
     $port_map = array();
     foreach ($servers as $index => $server) {
         PhutilTypeSpec::checkMap($server, array('type' => 'string', 'port' => 'int', 'listen' => 'optional string|null', 'ssl.key' => 'optional string|null', 'ssl.cert' => 'optional string|null', 'ssl.chain' => 'optional string|null'));
         $port = $server['port'];
         if (!isset($port_map[$port])) {
             $port_map[$port] = $index;
         } else {
             throw new PhutilArgumentUsageException(pht('Two servers (at indexes "%s" and "%s") both bind to the same ' . 'port ("%s"). Each server must bind to a unique port.', $port_map[$port], $index, $port));
         }
         $type = $server['type'];
         switch ($type) {
             case 'admin':
                 $has_admin = true;
                 break;
             case 'client':
                 $has_client = true;
                 break;
             default:
                 throw new PhutilArgumentUsageException(pht('A specified server (at index "%s", on port "%s") has an ' . 'invalid type ("%s"). Valid types are: admin, client.', $index, $port, $type));
         }
         $ssl_key = idx($server, 'ssl.key');
         $ssl_cert = idx($server, 'ssl.cert');
         if ($ssl_key && !$ssl_cert || $ssl_cert && !$ssl_key) {
             throw new PhutilArgumentUsageException(pht('A specified server (at index "%s", on port "%s") specifies ' . 'only one of "%s" and "%s". Each server must specify neither ' . '(to disable SSL) or specify both (to enable it).', $index, $port, 'ssl.key', 'ssl.cert'));
         }
         $ssl_chain = idx($server, 'ssl.chain');
         if ($ssl_chain && (!$ssl_key && !$ssl_cert)) {
             throw new PhutilArgumentUsageException(pht('A specified server (at index "%s", on port "%s") specifies ' . 'a value for "%s", but no value for "%s" or "%s". Servers ' . 'should only provide an SSL chain if they also provide an SSL ' . 'key and SSL certificate.', $index, $port, 'ssl.chain', 'ssl.key', 'ssl.cert'));
         }
     }
     if (!$servers) {
         throw new PhutilArgumentUsageException(pht('Configuration file does not specify any servers. This service ' . 'will not be able to interact with the outside world if it does ' . 'not listen on any ports. You must specify at least one "%s" ' . 'server and at least one "%s" server.', 'admin', 'client'));
     }
     if (!$has_client) {
         throw new PhutilArgumentUsageException(pht('Configuration file does not specify any client servers. This ' . 'service will be unable to transmit any notifications without a ' . 'client server. You must specify at least one server with ' . 'type "%s".', 'client'));
     }
     if (!$has_admin) {
         throw new PhutilArgumentUsageException(pht('Configuration file does not specify any administrative ' . 'servers. This service will be unable to receive messages. ' . 'You must specify at least one server with type "%s".', 'admin'));
     }
     $logs = idx($data, 'logs', array());
     foreach ($logs as $index => $log) {
         PhutilTypeSpec::checkMap($log, array('path' => 'string'));
         $path = $log['path'];
         try {
             $dir = dirname($path);
             if (!Filesystem::pathExists($dir)) {
                 Filesystem::createDirectory($dir, 0755, true);
             }
         } catch (FilesystemException $ex) {
             throw new PhutilArgumentUsageException(pht('Failed to create directory "%s" for specified log file (with ' . 'index "%s"). You should manually create this directory or ' . 'choose a different logfile location. %s', $dir, $ex->getMessage()));
         }
     }
     $peer_map = array();
     $cluster = idx($data, 'cluster', array());
     foreach ($cluster as $index => $peer) {
         PhutilTypeSpec::checkMap($peer, array('host' => 'string', 'port' => 'int', 'protocol' => 'string'));
         $host = $peer['host'];
         $port = $peer['port'];
         $protocol = $peer['protocol'];
         switch ($protocol) {
             case 'http':
             case 'https':
                 break;
             default:
//.........这里部分代码省略.........

 /**
  * Try to write a scratch file, if there's somewhere to put it and we can
  * write there.
  *
  * @param  string Scratch file name to write.
  * @param  string Data to write.
  * @return bool   True on success, false on failure.
  * @task scratch
  */
 public function writeScratchFile($path, $data)
 {
     $dir = $this->getScratchFilePath('');
     if (!$dir) {
         return false;
     }
     if (!Filesystem::pathExists($dir)) {
         try {
             Filesystem::createDirectory($dir);
         } catch (Exception $ex) {
             return false;
         }
     }
     try {
         Filesystem::writeFile($this->getScratchFilePath($path), $data);
     } catch (FilesystemException $ex) {
         return false;
     }
     return true;
 }

 /**
  * @task pull
  */
 public function pullRepository(PhabricatorRepository $repository)
 {
     $vcs = $repository->getVersionControlSystem();
     $is_svn = $vcs == PhabricatorRepositoryType::REPOSITORY_TYPE_SVN;
     $is_git = $vcs == PhabricatorRepositoryType::REPOSITORY_TYPE_GIT;
     $is_hg = $vcs == PhabricatorRepositoryType::REPOSITORY_TYPE_MERCURIAL;
     if ($is_svn) {
         return;
     }
     $callsign = $repository->getCallsign();
     if (!$is_git && !$is_hg) {
         throw new Exception("Unknown VCS '{$vcs}' for repository '{$callsign}'!");
     }
     $local_path = $repository->getDetail('local-path');
     if (!$local_path) {
         throw new Exception("No local path is available for repository '{$callsign}'.");
     }
     if (!Filesystem::pathExists($local_path)) {
         $dirname = dirname($local_path);
         if (!Filesystem::pathExists($dirname)) {
             Filesystem::createDirectory($dirname, 0755, $recursive = true);
         }
         if ($is_git) {
             return $this->executeGitCreate($repository, $local_path);
         } else {
             if ($is_hg) {
                 return $this->executeHgCreate($repository, $local_path);
             }
         }
     } else {
         if ($is_git) {
             return $this->executeGitUpdate($repository, $local_path);
         } else {
             if ($is_hg) {
                 return $this->executeHgUpdate($repository, $local_path);
             }
         }
     }
 }

 private function writeDocument(DivinerAtom $atom, $content)
 {
     $root = $this->getConfig('root');
     $path = $root . DIRECTORY_SEPARATOR . $this->getAtomRelativePath($atom);
     if (!Filesystem::pathExists($path)) {
         Filesystem::createDirectory($path, $umask = 0755, $recursive = true);
     }
     Filesystem::writeFile($path . 'index.html', $content);
     return $this;
 }