org.apache.commons.vfs2.provider.AbstractFileName Java Examples

/**
 * Creates a url for {@link ConnectionFileName}
 *
 * @param abstractFileName  File name
 * @param connectionDetails Connection details for the file name
 * @return created url otherwise null
 */
public static String getUrl( AbstractFileName abstractFileName, ConnectionDetails connectionDetails ) {
  VFSConnectionDetails vfsConnectionDetails = (VFSConnectionDetails) connectionDetails;
  String url = null;

  if ( vfsConnectionDetails != null ) {
    String domain = vfsConnectionDetails.getDomain();
    if ( !domain.equals( "" ) ) {
      domain = "/" + domain;
    }
    url = vfsConnectionDetails.getType() + ":/" + domain + abstractFileName.getPath();
    if ( url.matches( DOMAIN_ROOT ) ) {
      url += vfsConnectionDetails.getName();
    }
  }

  return url;
}
 

protected JarFileObject(final AbstractFileName name, final ZipEntry entry, final JarFileSystem fs,
         final boolean zipExists) throws FileSystemException {
     super(name, entry, fs, zipExists);
     if (entry != null) {
// For Java 9 and up: Force the certificates to be read and cached now. This avoids an
// IllegalStateException in java.util.jar.JarFile.isMultiRelease() when it tries
// to read the certificates and the file is closed.
     	((JarEntry) entry).getCertificates();
     }
     this.fs = fs;

     try {
         getAttributes(); // early get the attributes as the zip file might be closed
     } catch (final IOException e) {
         throw new FileSystemException(e);
     }
 }
 

protected TarFileSystem(final AbstractFileName rootName, final FileObject parentLayer,
        final FileSystemOptions fileSystemOptions) throws FileSystemException {
    super(rootName, parentLayer, fileSystemOptions);

    // Make a local copy of the file
    file = parentLayer.getFileSystem().replicateFile(parentLayer, Selectors.SELECT_SELF);

    // Open the Tar file
    if (!file.exists()) {
        // Don't need to do anything
        tarFile = null;
        return;
    }

    // tarFile = createTarFile(this.file);
}
 

/**
 * Creates a file object. This method is called only if the requested file is not cached.
 */
@Override
protected FileObject createFile(final AbstractFileName name) throws Exception {
    // Find the file that the name points to
    final FileName junctionPoint = getJunctionForFile(name);
    final FileObject file;
    if (junctionPoint != null) {
        // Resolve the real file
        final FileObject junctionFile = junctions.get(junctionPoint);
        final String relName = junctionPoint.getRelativeName(name);
        file = junctionFile.resolveFile(relName, NameScope.DESCENDENT_OR_SELF);
    } else {
        file = null;
    }

    // Return a wrapper around the file
    return new DelegateFileObject(name, this, file);
}
 

protected GoogleDriveFileObject( final AbstractFileName fileName, final GoogleDriveFileSystem fileSystem )
    throws FileSystemException {
  super( fileName, fileSystem );
  try {
    HTTP_TRANSPORT = GoogleNetHttpTransport.newTrustedTransport();
    DATA_STORE_FACTORY = new CustomDataStoreFactory( DATA_STORE_DIR );
    driveService = getDriveService();
    resolveFileMetadata();
  } catch ( Exception e ) {
    throw new FileSystemException( e );
  }
}
 

private synchronized FileObject processFile( FileName name, boolean useCache ) throws FileSystemException {
  if ( !super.getRootName().getRootURI().equals( name.getRootURI() ) ) {
    throw new FileSystemException( "vfs.provider/mismatched-fs-for-name.error",
        new Object[] { name, super.getRootName(), name.getRootURI() } );
  } else {
    FileObject file;
    if ( useCache ) {
      file = super.getFileFromCache( name );
    } else {
      file = null;
    }

    if ( file == null ) {
      try {
        file = this.createFile( (AbstractFileName) name );
      } catch ( Exception var5 ) {
        return null;
      }

      file = super.decorateFileObject( file );
      if ( useCache ) {
        super.putFileToCache( file );
      }
    }

    if ( super.getFileSystemManager().getCacheStrategy().equals( CacheStrategy.ON_RESOLVE ) ) {
      file.refresh();
    }

    return file;
  }
}
 

/**
 * Creates a virtual file system, with the supplied file as its root.
 *
 * @param rootFile The root of the file system.
 * @return A FileObject in the FileSystem.
 * @throws FileSystemException if an error occurs.
 */
public FileObject createFileSystem(final FileObject rootFile) throws FileSystemException {
    final AbstractFileName rootName = (AbstractFileName) getContext().getFileSystemManager()
            .resolveName(rootFile.getName(), FileName.ROOT_PATH);
    final VirtualFileSystem fs = new VirtualFileSystem(rootName, rootFile.getFileSystem().getFileSystemOptions());
    addComponent(fs);
    fs.addJunction(FileName.ROOT_PATH, rootFile);
    return fs.getRoot();
}
 

@Override
public FileObject resolveFile( FileName name ) throws FileSystemException {
  try {
    return this.createFile( (AbstractFileName) name );
  } catch ( Exception e ) {
    throw new FileSystemException( "vfs.provider/resolve-file.error", name, e );
  }
}
 

/**
 * Creates a layered file system. This method is called if the file system is not cached.
 *
 * @param scheme The URI scheme.
 * @param file The file to create the file system on top of.
 * @return The file system.
 */
@Override
protected FileSystem doCreateFileSystem(final String scheme, final FileObject file,
        final FileSystemOptions fileSystemOptions) throws FileSystemException {
    final AbstractFileName rootName = new LayeredFileName(scheme, file.getName(), FileName.ROOT_PATH,
            FileType.FOLDER);
    return new TarFileSystem(rootName, file, fileSystemOptions);
}
 

public WebSolutionFileObject( final AbstractFileName name,
                              final AbstractFileSystem fileSystem,
                              final SolutionFileModel fs )
{
  super( name, fileSystem );
  this.fs = fs;
}
 

protected TarFileObject(final AbstractFileName name, final TarArchiveEntry entry, final TarFileSystem fs,
        final boolean tarExists) throws FileSystemException {
    super(name, fs);
    setTarEntry(entry);
    if (!tarExists) {
        type = FileType.IMAGINARY;
    }
}
 

public ZipFileSystem(final AbstractFileName rootName, final FileObject parentLayer,
        final FileSystemOptions fileSystemOptions) throws FileSystemException {
    super(rootName, parentLayer, fileSystemOptions);

    // Make a local copy of the file
    file = parentLayer.getFileSystem().replicateFile(parentLayer, Selectors.SELECT_SELF);
    this.charset = ZipFileSystemConfigBuilder.getInstance().getCharset(fileSystemOptions);

    // Open the Zip file
    if (!file.exists()) {
        // Don't need to do anything
        zipFile = null;
        return;
    }
}
 

protected ZipFileObject(final AbstractFileName name, final ZipEntry entry, final ZipFileSystem fs,
        final boolean zipExists) throws FileSystemException {
    super(name, fs);
    setZipEntry(entry);
    if (!zipExists) {
        type = FileType.IMAGINARY;
    }
}
 

protected HttpFileObject(final AbstractFileName name, final FS fileSystem,
        final HttpFileSystemConfigBuilder builder) {
    super(name, fileSystem);
    final FileSystemOptions fileSystemOptions = fileSystem.getFileSystemOptions();
    urlCharset = builder.getUrlCharset(fileSystemOptions);
    userAgent = builder.getUserAgent(fileSystemOptions);
    followRedirect = builder.getFollowRedirect(fileSystemOptions);
}
 

protected CompressedFileFileObject(final AbstractFileName name, final FileObject container, final FS fs) {
    super(name, fs);
    this.container = container;

    // todo, add getBaseName(String) to FileName
    String basename = container.getName().getBaseName();
    final int pos = basename.lastIndexOf('.');
    if (pos > 0) {
        basename = basename.substring(0, pos);
    }
    children = new String[] { basename };
}
 

protected FtpFileObject(final AbstractFileName name, final FtpFileSystem fileSystem, final FileName rootName)
        throws FileSystemException {
    super(name, fileSystem);
    final String relPath = UriParser.decode(rootName.getRelativeName(name));
    if (".".equals(relPath)) {
        // do not use the "." as path against the ftp-server
        // e.g. the uu.net ftp-server do a recursive listing then
        // this.relPath = UriParser.decode(rootName.getPath());
        // this.relPath = ".";
        this.relPath = null;
    } else {
        this.relPath = relPath;
    }
}
 

protected GoogleDriveFileObject( final AbstractFileName fileName, final GoogleDriveFileSystem fileSystem )
    throws FileSystemException {
  super( fileName, fileSystem );
  try {
    HTTP_TRANSPORT = GoogleNetHttpTransport.newTrustedTransport();
    DATA_STORE_FACTORY = new CustomDataStoreFactory( DATA_STORE_DIR );
    driveService = getDriveService();
    resolveFileMetadata();
  } catch ( Exception e ) {
    throw new FileSystemException( e );
  }
}
 

@Override
protected FileObject createFile(final AbstractFileName name) throws Exception {
    return new Http4FileObject<>(name, this);
}
 

public TestFileWithDomainObject( AbstractFileName name,
                                 TestFileWithDomainSystem fs ) {
  super( name, fs );
}
 

public static AbstractFileName parseUri( String uri, FileNameParser fileNameParser ) throws FileSystemException {
  StringBuilder name = new StringBuilder();

  String scheme = UriParser.extractScheme( uri, name );
  UriParser.canonicalizePath( name, 0, name.length(), fileNameParser );

  UriParser.fixSeparators( name );

  FileType fileType = UriParser.normalisePath( name );

  // Extract the named connection name
  final String connection = UriParser.extractFirstElement( name );

  String path = name.toString();

  return new ConnectionFileName( scheme, connection, path, fileType );
}
 

protected HttpFileObject(final AbstractFileName name, final FS fileSystem) {
    this(name, fileSystem, HttpFileSystemConfigBuilder.getInstance());
}
 

protected UrlFileObject(final UrlFileSystem fs, final AbstractFileName fileName) {
    super(fileName, fs);
}
 

@Override
protected FileObject createFile(final AbstractFileName name) throws FileSystemException {
    return new GzipFileObject(name, getParentLayer(), this);
}
 

protected GzipFileObject(final AbstractFileName name, final FileObject container, final GzipFileSystem fs) {
    super(name, container, fs);
}
 

protected SftpFileObject(final AbstractFileName name, final SftpFileSystem fileSystem) throws FileSystemException {
    super(name, fileSystem);
    relPath = UriParser.decode(fileSystem.getRootName().getRelativeName(name));
}
 

/**
 * Creates a file object. This method is called only if the requested file is not cached.
 */
@Override
protected FileObject createFile(final AbstractFileName name) throws FileSystemException {
    return new SftpFileObject(name, this);
}
 

/**
 * Creates a file object.
 */
@Override
protected FileObject createFile(final AbstractFileName name) throws FileSystemException {
    return new FtpFileObject(name, this, getRootName());
}
 

@Override
protected FileObject createFile(final AbstractFileName name) throws FileSystemException {
    return new Bzip2FileObject(name, getParentLayer(), this);
}
 

public ConnectionFileObject( AbstractFileName name, ConnectionFileSystem fs, AbstractFileObject resolvedFileObject,
                             String domain ) {
  super( name, fs );
  this.resolvedFileObject = resolvedFileObject;
  this.domain = domain;
}
 

public TestFileObject( AbstractFileName name,
                       TestFileSystem fs ) {
  super( name, fs );
}