Gets the full HDFS path when sealed.
168154
private Path getSealedFilePath(String segmentName) {
        Preconditions.checkState(segmentName != null && segmentName.length() > 0, "segmentName must be non-null and non-empty");
        return new Path(String.format(NAME_FORMAT, getPathPrefix(segmentName), SEALED));
    }
1314396
def get_working_path(self):
        
        self.set_section('Files')
        raw_path = self.option("working_path")
        if raw_path.startswith('~'):
            raw_path = os.path.expanduser('~') + raw_path[1:]

        return raw_path
149626
def _get_key_file_path():
        """"""
        if os.getenv(USER_HOME) is not None and os.access(os.getenv(USER_HOME),
                                                          os.W_OK):
            return os.path.join(os.getenv(USER_HOME), KEY_FILE_NAME)

        return os.path.join(os.getcwd(), KEY_FILE_NAME)
422162
def GetRootFileEntry(self):
    
    path_spec = tsk_partition_path_spec.TSKPartitionPathSpec(
        location=self.LOCATION_ROOT, parent=self._path_spec.parent)
    return self.GetFileEntryByPathSpec(path_spec)
1372969
public String getFullPath()
  {
    if (_root == this || _root == null)
      return getPath();

    String rootPath = _root.getFullPath();
    String path = getPath();

    if (rootPath.length() <= 1)
      return path;
    else if (path.length() <= 1)
      return rootPath;
    else
      return rootPath + path;
  }
952889
def get_path_name(self):
        
        complete_path = os.path.dirname(os.path.abspath(self.path))
        name = self.path.replace(complete_path + PATH_SEPARATOR, "")
        if name.endswith("/"):
            name = name[: -1]

        return complete_path, name
270969
def GetAPFSVolumeByPathSpec(self, path_spec):
    
    volume_index = apfs_helper.APFSContainerPathSpecGetVolumeIndex(path_spec)
    if volume_index is None:
      return None

    return self._fsapfs_container.get_volume(volume_index)
1103063
def _get_fullpath(self, filepath):
        
        if filepath[0] == '/':
            return filepath
        return os.path.join(self._base_path, filepath)
557452
def full_path(self):
        
        if "local" in self.driver.name.lower():
            return "%s/%s" % self.container.key, self.path
        return self.path
937620
def path(self):
        """"""
        names = []
        obj = self
        while obj:
            names.insert(0, obj.name)
            obj = obj.parent_dir
        sep = self.filesystem._path_separator(self.name)
        if names[0] == sep:
            names.pop(0)
            dir_path = sep.join(names)
            # Windows paths with drive have a root separator entry
            # which should be removed
            is_drive = names and len(names[0]) == 2 and names[0][1] == ':'
            if not is_drive:
                dir_path = sep + dir_path
        else:
            dir_path = sep.join(names)
        dir_path = self.filesystem.absnormpath(dir_path)
        return dir_path
375458
public String getFullMobilePath() {
		String path = null;
		if (this.mobilePath != null) {
			path = (this.rootPath == null ? this.mobilePath : getCleanPath(this.rootPath) + this.mobilePath);
		}
		return path;
	}
758228
def get_processed_path(self):
        
        location = self.get_storage().location
        return self.get_processed_key_name()[len(location):]
401281
def dfs_present(path):
    '''
    
    '''
    cmd_return = _hadoop_cmd('dfs', 'stat', path)
    match = 'No such file or directory'
    return False if match in cmd_return else True
675064
def getSendPath(self, volume):
        
        try:
            return self._fullPath(next(iter(self.getPaths(volume))))
        except StopIteration:
            return None
1346297
def _get_cached_file_name(bucket_name, saltenv, path):
    '''
    
    '''

    file_path = os.path.join(_get_cache_dir(), saltenv, bucket_name, path)

    # make sure bucket and saltenv directories exist
    if not os.path.exists(os.path.dirname(file_path)):
        os.makedirs(os.path.dirname(file_path))

    return file_path
400121
def ls(self, src, extra_args=[]):
        ''''''
        src = [self._full_hdfs_path(x) for x in src]
        output = self._getStdOutCmd([self._hadoop_cmd, 'fs', '-ls'] + extra_args + src, True)
        return self._transform_ls_output(output, self.hdfs_url)
1142311
def _fillVolumesAndPaths(self, paths):
        
        with self.btrfs as mount:
            for bv in mount.subvolumes:
                if not bv.readOnly:
                    continue

                vol = self._btrfsVol2StoreVol(bv)
                if vol is None:
                    continue

                path = bv.fullPath

                if path is None:
                    logger.info("Skipping deleted volume %s", bv.uuid)
                    continue

                relPath = None

                for path in bv.linuxPaths:
                    path = self._relativePath(path)

                    if path is None:
                        continue  # path is outside store scope

                    paths[vol].append(path)

                    infoPath = self._fullPath(path + Store.theInfoExtension)
                    if os.path.exists(infoPath):
                        logger.debug("Reading %s", infoPath)
                        with open(infoPath) as info:
                            Store.Volume.readInfo(info)

                    if not path.startswith("/"):
                        relPath = path

                if vol not in paths:
                    continue

                logger.debug("%s", vol.display(sink=self, detail='phrase'))

                if vol.uuid in self.butterVolumes:
                    logger.warn(
                        "Duplicate effective uuid %s in '%s' and '%s'",
                        vol.uuid, path, self.butterVolumes[vol.uuid].fullPath
                    )

                self.butterVolumes[vol.uuid] = bv

                if relPath is not None:
                    # vol is inside Store directory
                    self.extraVolumes[vol] = relPath