The UNC mount point for this path.
        This is empty for paths on local drives.
480564
def uncshare(self):
        
        unc, r = self.module.splitunc(self)
        return self._next_class(unc)
683042
public void start() throws IOException {
    // Initialize UFS states
    for (AlluxioURI syncPoint : mSyncPathList) {

      MountTable.Resolution resolution = null;
      long mountId = 0;
      try {
        resolution = mMountTable.resolve(syncPoint);
        mountId = resolution.getMountId();
      } catch (InvalidPathException e) {
        LOG.info("Invalid Path encountered during start up of ActiveSyncManager, "
            + "path {}, exception {}", syncPoint, e);
        continue;
      }

      try (CloseableResource<UnderFileSystem> ufsResource = resolution.acquireUfsResource()) {
        if (!ufsResource.get().supportsActiveSync()) {
          throw new UnsupportedOperationException("Active Sync is not supported on this UFS type: "
              + ufsResource.get().getUnderFSType());
        }
        ufsResource.get().startSync(resolution.getUri());
      }
    }
    // attempt to restart from a past txid, if this fails, it will result in MissingEventException
    // therefore forces a sync
    for (long mountId: mFilterMap.keySet()) {
      long txId = mStartingTxIdMap.getOrDefault(mountId, SyncInfo.INVALID_TXID);
      launchPollingThread(mountId, txId);

      try {
        if ((txId == SyncInfo.INVALID_TXID)
            && ServerConfiguration.getBoolean(PropertyKey.MASTER_ACTIVE_UFS_SYNC_INITIAL_SYNC)) {
          mExecutorService.submit(
              () -> mFilterMap.get(mountId).parallelStream().forEach(
                  syncPoint -> {
                    try {
                      RetryUtils.retry("active sync during start",
                          () -> mFileSystemMaster.activeSyncMetadata(syncPoint,
                              null, getExecutor()),
                          RetryUtils.defaultActiveSyncClientRetry(ServerConfiguration
                              .getMs(PropertyKey.MASTER_ACTIVE_UFS_POLL_TIMEOUT)));
                    } catch (IOException e) {
                      LOG.warn("IOException encountered during active sync while starting {}", e);
                    }
                  }
          ));
        }
      } catch (Exception e) {
        LOG.warn("exception encountered during initial sync {}", e);
      }
    }
  }
796939
def get_mounts_by_path():
    '''
    
    '''
    mount_info = []
    f = open('/proc/mounts', 'r')
    for line in f:
        _tmp = line.split(" ")
        mount_info.append({'path': _tmp[1],
                           'device': _tmp[0],
                           'type': _tmp[2],
                           'options': _tmp[3]
                           }
                          )
    return mount_info
606105
@Override
    public void addMountPoint(String path, Class<? extends Page> pageClass) {
        LOGGER.debug("Adding mount point for path {} = {}", path, pageClass.getName());
        mountPoints.add(new DefaultMountPointInfo(path, pageClass));
    }
417034
def exists(self, filename):
        
        if is_package(filename):
            filepath = os.path.join(self.connection["mount_point"],
                                    "Packages", filename)
        else:
            filepath = os.path.join(self.connection["mount_point"],
                                    "Scripts", filename)
        return os.path.exists(filepath)
1272895
public alluxio.grpc.MountPointInfo getMountPointsOrDefault(
      java.lang.String key,
      alluxio.grpc.MountPointInfo defaultValue) {
    if (key == null) { throw new java.lang.NullPointerException(); }
    java.util.Map<java.lang.String, alluxio.grpc.MountPointInfo> map =
        internalGetMountPoints().getMap();
    return map.containsKey(key) ? map.get(key) : defaultValue;
  }
588962
def __root_path(self):
        
        if self.root_path is not None:
            if os.path.isdir(self.root_path):
                sys.path.append(self.root_path)
                return
            raise RuntimeError('EverNode requires a valid root path.'
                               ' Directory: %s does not exist'
                               % (self.root_path))
76209
static boolean objectHasDirectoryPath(String objectName) {
    return !Strings.isNullOrEmpty(objectName)
        && objectName.endsWith(GoogleCloudStorage.PATH_DELIMITER);
  }
72696
def mount_tune(path, data = {})
      json = client.post("/v1/sys/mounts/#{encode_path(path)}/tune", JSON.fast_generate(data))
      return true
    end
843452
def mount(self, source, target, options=[]):
        

        if len(options) == 0:
            options = ['']

        args = {
            'options': ','.join(options),
            'source': source,
            'target': target,
        }

        self._mount_chk.check(args)
        response = self._client.raw('disk.mount', args)

        result = response.get()

        if result.state != 'SUCCESS':
            raise RuntimeError('failed to mount partition: %s' % result.stderr)
12904
def mount(self, path, fs):
        # type: (Text, Union[FS, Text]) -> None
        
        if isinstance(fs, text_type):
            from .opener import open_fs

            fs = open_fs(fs)

        if not isinstance(fs, FS):
            raise TypeError("fs argument must be an FS object or a FS URL")

        if fs is self:
            raise ValueError("Unable to mount self")
        _path = forcedir(abspath(normpath(path)))

        for mount_path, _ in self.mounts:
            if _path.startswith(mount_path):
                raise MountError("mount point overlaps existing mount")

        self.mounts.append((_path, fs))
        self.default_fs.makedirs(_path, recreate=True)
175133
def GetRawDevice(path):
  """"""
  device_map = GetMountpoints()

  path = utils.SmartUnicode(path)
  mount_point = path = utils.NormalizePath(path, "/")

  result = rdf_paths.PathSpec(pathtype=rdf_paths.PathSpec.PathType.OS)

  # Assign the most specific mount point to the result
  while mount_point:
    try:
      result.path, fs_type = device_map[mount_point]
      if fs_type in [
          "ext2", "ext3", "ext4", "vfat", "ntfs", "Apple_HFS", "hfs", "msdos"
      ]:
        # These are read filesystems
        result.pathtype = rdf_paths.PathSpec.PathType.OS
      else:
        result.pathtype = rdf_paths.PathSpec.PathType.UNSET

      # Drop the mount point
      path = utils.NormalizePath(path[len(mount_point):])

      return result, path
    except KeyError:
      mount_point = os.path.dirname(mount_point)
723164
def p(self, path):
        
        if path.startswith("/"):
            path = path[1:]
        p = os.path.join(self.mount_point, path)
        logger.debug("path = %s", p)
        return p
130854
def find_mounts(self):
        

        for mountpoint, (orig, fs, opts) in self.mountpoints.items():
            if 'bind' not in opts and (re.match(self.orig_re_pattern, orig) or
                                       (self.be_greedy and re.match(self.re_pattern, mountpoint))):
                yield mountpoint
857433
def mounts(cls):
		
		result = []
		with open(cls.__mounts_file__) as f:
			for mount_record in f:
				result.append(WMountPoint(mount_record))
		return tuple(result)
604089
def mount(self, readonly=True):
        
        self._handler.add_drive_opts(self.disk_path, readonly=True)
        self._handler.launch()

        for mountpoint, device in self._inspect_disk():
            if readonly:
                self._handler.mount_ro(device, mountpoint)
            else:
                self._handler.mount(device, mountpoint)

        if self._handler.inspect_get_type(self._root) == 'windows':
            self.path = self._windows_path
        else:
            self.path = posix_path
837480
async def mount(self, mount_point, *, mount_options=None):
        """"""
        self._data = await self._handler.mount(
            system_id=self.block_device.node.system_id,
            device_id=self.block_device.id, id=self.id,
            mount_point=mount_point,
            mount_options=mount_options)