Make Quorum directories.
178434
def make_directories
      begin
        `rm -rf #{@blastdb_dir}` if File.directory?(@blastdb_dir) && @rebuild_db
        Dir.mkdir(@blastdb_dir) unless File.directory?(@blastdb_dir)

        `rm -rf #{@gff_dir}` if File.directory?(@gff_dir) && @rebuild_db
        Dir.mkdir(@gff_dir) unless File.directory?(@gff_dir)

        Dir.mkdir(@log_dir) unless File.directory?(@log_dir)
      rescue SystemCallError => e
        @output.puts e.message
        raise "Unable to make directory. " <<
          "Perhaps you forgot to execute the quorum initializer. \n\n" <<
          "rails generate quorum:install"
      end
    end
1001732
def mkdir(dir, enter):
    

    if not os.path.exists(dir):
        os.makedirs(dir)
1058053
def makedirs(*args, **kwargs):
    
    try:
        os.makedirs(*args, **kwargs)
    except OSError as ex:
        if ex.errno != errno.EEXIST:
            raise
570
def safe_makedirs(path):
    """"""
    try:
        os.makedirs(path)
    except OSError as err:
        if err.errno == errno.EEXIST:
            if not os.path.isdir(path):
                raise
        else:
            raise
575518
def _makedirs(self, path):
        
        try:
            oldmask = os.umask(0)
            os.makedirs(path, self._conf['dmode'])
            os.umask(oldmask)
        except OSError as e:
            if(e.errno == errno.EACCES):
                raise Exception('not sufficent permissions to write on fsdb folder: "{0}"'.format(path))
            elif(e.errno == errno.EEXIST):
                fstat = os.stat(path)
                if not stat.S_ISDIR(fstat.st_mode):
                    raise Exception('fsdb folder already exists but it is not a regular folder: "{0}"'.format(path))
                elif not os.access(path, os.R_OK and os.W_OK):
                    raise Exception('not sufficent permissions to write on fsdb folder: "{0}"'.format(path))
            else:
                raise e
1270801
def make_folder_for_today(log_dir):
    """"""
    now = datetime.datetime.now()
    sub_folders_list = ['{0:04d}'.format(now.year),
                        '{0:02d}'.format(now.month),
                        '{0:02d}'.format(now.day)]
    folder = log_dir
    for sf in sub_folders_list:
        folder = os.path.join(folder, sf)
        if not os.path.exists(folder):
            os.makedirs(folder)
    return folder
974990
def setup_dir(self):
        """"""
        cd = self.opts.cd or self.config['crony'].get('directory')
        if cd:
            self.logger.debug(f'Adding cd to {cd}')
            self.cmd = f'cd {cd} && {self.cmd}'
755344
def mkdirp(kls, path, mode=0o755):
		""""""
		os.makedirs(path, mode=mode, exist_ok=True)
360200
def do_mkdir(self, path):
        """"""
        path = path[0]

        self.n.makeDirectory(self.current_path + path)
        self.dirs = self.dir_complete()
48767
def create_dir_unless_exists(*args):
    """"""
    path = os.path.join(*args)
    if not os.path.isdir(path):
        os.makedirs(path)
515303
def makedirs(self):
        
        normpath = os.path.normpath(self.path)
        parentfolder = os.path.dirname(normpath)
        if parentfolder:
            try:
                os.makedirs(parentfolder)
            except OSError:
                pass
522596
def setup_dirs(self, storage_dir):
        ''''''
        self.storage_dir = expanduser(storage_dir)
        if ' ' in self.storage_dir:
            raise ValueError('storage dir path cannot contain spaces, please '
                             'specify a path with --storage-dir')
        self.build_dir = join(self.storage_dir, 'build')
        self.dist_dir = join(self.storage_dir, 'dists')
357659
def setup_directories(base_dir, subdirs):
  """"""
  base_dir = os.path.expanduser(base_dir)
  tf.gfile.MakeDirs(base_dir)

  all_dirs = {}
  for subdir in subdirs:
    if isinstance(subdir, six.string_types):
      subdir_tuple = (subdir,)
    else:
      subdir_tuple = subdir
    dir_name = os.path.join(base_dir, *subdir_tuple)
    tf.gfile.MakeDirs(dir_name)
    all_dirs[subdir] = dir_name
  return all_dirs
710117
def mkdirs(filename, mode=0o777):
    """"""
    dirname = os.path.dirname(filename)
    if not dirname:
        return
    _compat.makedirs(dirname, mode=mode, exist_ok=True)
664521
def cli(env, volume_id, sortby, columns):
    """"""
    file_manager = SoftLayer.FileStorageManager(env.client)
    snapshots = file_manager.get_file_volume_snapshot_list(
        volume_id,
        mask=columns.mask()
    )

    table = formatting.Table(columns.columns)
    table.sortby = sortby

    for snapshot in snapshots:
        table.add_row([value or formatting.blank()
                       for value in columns.row(snapshot)])

    env.fout(table)
1042261
def create_directory(self, filename):
        """"""
        path = os.path.join(self.path, filename)
        makedirs(path)
        return path
677250
function makeDirectories(dirs, callback) {
  var mkdir = function(dir, mkCallback) {
    exec('mkdir -p ' + dir, function(err, stdout, stderr) {
      return mkCallback(err);
    });
  };

  async.forEach(dirs, mkdir, callback);
}