Java tutorial
/* * Licensed to the Apache Software Foundation (ASF) under one or more * contributor license agreements. See the NOTICE file distributed with * this work for additional information regarding copyright ownership. * The ASF licenses this file to You under the Apache License, Version 2.0 * (the "License"); you may not use this file except in compliance with * the License. You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. * */ package org.apache.ivy.plugins.repository.vfs; import java.io.File; import java.io.FileInputStream; import java.io.IOException; import java.util.ArrayList; import java.util.Arrays; import java.util.List; import org.apache.commons.vfs.FileContent; import org.apache.commons.vfs.FileObject; import org.apache.commons.vfs.FileSystemException; import org.apache.commons.vfs.FileSystemManager; import org.apache.commons.vfs.FileType; import org.apache.commons.vfs.impl.StandardFileSystemManager; import org.apache.ivy.plugins.repository.AbstractRepository; import org.apache.ivy.plugins.repository.RepositoryCopyProgressListener; import org.apache.ivy.plugins.repository.Resource; import org.apache.ivy.plugins.repository.TransferEvent; import org.apache.ivy.util.CopyProgressListener; import org.apache.ivy.util.FileUtil; import org.apache.ivy.util.Message; /** * Implementation of a VFS repository */ public class VfsRepository extends AbstractRepository { /** * Name of the resource defining the Ivy VFS Repo configuration. */ private static final String IVY_VFS_CONFIG = "ivy_vfs.xml"; private StandardFileSystemManager manager = null; private final CopyProgressListener progress = new RepositoryCopyProgressListener(this); /** * Create a new Ivy VFS Repository Instance */ public VfsRepository() { } private FileSystemManager getVFSManager() throws IOException { synchronized (this) { if (manager == null) { manager = createVFSManager(); } } return manager; } private StandardFileSystemManager createVFSManager() throws IOException { StandardFileSystemManager result = null; try { /* * The DefaultFileSystemManager gets its configuration from the jakarta-vfs-common * implementation which includes the res and tmp schemes which are of no use to use * here. Using StandardFileSystemManager lets us specify which schemes to support as * well as providing a mechanism to change this support without recompilation. */ result = new StandardFileSystemManager() { protected void configurePlugins() throws FileSystemException { // disable automatic loading potential unsupported extensions } }; result.setConfiguration(getClass().getResource(IVY_VFS_CONFIG)); result.init(); // Generate and print a list of available schemes Message.verbose("Available VFS schemes..."); String[] schemes = result.getSchemes(); Arrays.sort(schemes); for (int i = 0; i < schemes.length; i++) { Message.verbose("VFS Supported Scheme: " + schemes[i]); } } catch (FileSystemException e) { /* * If our attempt to initialize a VFS Repository fails we log the failure but continue * on. Given that an Ivy instance may involve numerous different repository types, it * seems overly cautious to throw a runtime exception on the initialization failure of * just one repository type. */ Message.error("Unable to initialize VFS repository manager!"); Message.error(e.getLocalizedMessage()); IOException error = new IOException(e.getLocalizedMessage()); error.initCause(e); throw error; } return result; } protected void finalize() { if (manager != null) { manager.close(); manager = null; } } /** * Get a VfsResource * * @param source * a <code>String</code> identifying a VFS Resource * @throws <code>IOException</code> on failure * @see "Supported File Systems in the jakarta-commons-vfs documentation" */ public Resource getResource(String vfsURI) throws IOException { return new VfsResource(vfsURI, getVFSManager()); } /** * Transfer a VFS Resource from the repository to the local file system. * * @param srcVfsURI * a <code>String</code> identifying the VFS resource to be fetched * @param destination * a <code>File</code> identifying the destination file * @throws <code>IOException</code> on failure * @see "Supported File Systems in the jakarta-commons-vfs documentation" */ public void get(String srcVfsURI, File destination) throws IOException { VfsResource src = new VfsResource(srcVfsURI, getVFSManager()); fireTransferInitiated(src, TransferEvent.REQUEST_GET); try { FileContent content = src.getContent(); if (content == null) { throw new IllegalArgumentException("invalid vfs uri " + srcVfsURI + ": no content found"); } FileUtil.copy(content.getInputStream(), destination, progress); } catch (IOException ex) { fireTransferError(ex); throw ex; } catch (RuntimeException ex) { fireTransferError(ex); throw ex; } } /** * Return a listing of the contents of a parent directory. Listing is a set of strings * representing VFS URIs. * * @param vfsURI * providing identifying a VFS provided resource * @throws IOException * on failure. * @see "Supported File Systems in the jakarta-commons-vfs documentation" */ public List list(String vfsURI) throws IOException { ArrayList list = new ArrayList(); Message.debug("list called for URI" + vfsURI); FileObject resourceImpl = getVFSManager().resolveFile(vfsURI); Message.debug("resourceImpl=" + resourceImpl.toString()); Message.debug("resourceImpl.exists()" + resourceImpl.exists()); Message.debug("resourceImpl.getType()" + resourceImpl.getType()); Message.debug("FileType.FOLDER" + FileType.FOLDER); if ((resourceImpl != null) && resourceImpl.exists() && (resourceImpl.getType() == FileType.FOLDER)) { FileObject[] children = resourceImpl.getChildren(); for (int i = 0; i < children.length; i++) { FileObject child = children[i]; Message.debug("child " + i + child.getName().getURI()); list.add(VfsResource.normalize(child.getName().getURI())); } } return list; } /** * Transfer an Ivy resource to a VFS repository * * @param source * a <code>File</code> indentifying the local file to transfer to the repository * @param vfsURI * a <code>String</code> identifying the destination VFS Resource. * @param overwrite * whether to overwrite an existing resource. * @throws <code>IOException</code> on failure. * @see "Supported File Systems in the jakarta-commons-vfs documentation" */ public void put(File source, String vfsURI, boolean overwrite) throws IOException { VfsResource dest = new VfsResource(vfsURI, getVFSManager()); fireTransferInitiated(dest, TransferEvent.REQUEST_PUT); if (dest.physicallyExists() && !overwrite) { throw new IOException( "Cannot copy. Destination file: " + dest.getName() + " exists and overwrite not set."); } if (dest.getContent() == null) { throw new IllegalArgumentException( "invalid vfs uri " + vfsURI + " to put data to: resource has no content"); } FileUtil.copy(new FileInputStream(source), dest.getContent().getOutputStream(), progress); } }