com.foreach.common.filemanager.services.FileManagerImpl Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of common-file-manager Show documentation
A number of general purpose libraries for Java. Dependencies are kept minimal but Spring framework is considered a base requirement for most libraries.
The newest version!
/*
 * Copyright 2014 the original author or authors
 *
 * Licensed 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 com.foreach.common.filemanager.services;

import com.foreach.common.filemanager.business.*;
import lombok.NonNull;
import org.apache.commons.lang3.StringUtils;
import org.springframework.stereotype.Service;
import org.springframework.util.AntPathMatcher;
import org.springframework.util.Assert;

import javax.annotation.PreDestroy;
import java.io.File;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.util.*;
import java.util.function.BiFunction;
import java.util.stream.Collectors;
import java.util.stream.Stream;

/**
 * Implementation of both FileManager and FileRepositoryRegistry.  The registry deals out
 * delegate implementations ensuring that the actual implementation can be replaced at runtime.
 *
 * @see FileRepositoryDelegate
 */
@SuppressWarnings({ "deprecation", "squid:CallToDeprecatedMethod" })
@Service
public class FileManagerImpl implements FileManager, FileRepositoryRegistry
{
	private FileRepositoryFactory repositoryFactory;
	private final Map repositories = new TreeMap<>();

	@Override
	public FileResource createFileResource( String repositoryId ) {
		return requireRepository( repositoryId ).createFileResource();
	}

	@Override
	public FileResource createFileResource() {
		return requireRepository( DEFAULT_REPOSITORY ).createFileResource();
	}

	@Override
	public FileResource createFileResource( boolean allocateImmediately ) {
		return requireRepository( DEFAULT_REPOSITORY ).createFileResource( allocateImmediately );
	}

	@Override
	public FileResource createFileResource( File originalFile, boolean deleteOriginal ) throws IOException {
		return requireRepository( DEFAULT_REPOSITORY ).createFileResource( originalFile, deleteOriginal );
	}

	@Override
	public FileResource createFileResource( InputStream inputStream ) throws IOException {
		return requireRepository( DEFAULT_REPOSITORY ).createFileResource( inputStream );
	}

	@Override
	public FileResource getFileResource( FileDescriptor descriptor ) {
		return requireRepository( descriptor.getRepositoryId() ).getFileResource( descriptor );
	}

	@Override
	public FolderResource getRootFolderResource() {
		return requireRepository( DEFAULT_REPOSITORY ).getRootFolderResource();
	}

	@Override
	public FolderResource getFolderResource( FolderDescriptor descriptor ) {
		return requireRepository( descriptor.getRepositoryId() ).getFolderResource( descriptor );
	}

	@Override
	public FileDescriptor generateFileDescriptor() {
		return requireRepository( DEFAULT_REPOSITORY ).generateFileDescriptor();
	}

	@Override
	public File createTempFile() {
		FileRepository tempRepository = repositories.get( TEMP_REPOSITORY );

		if ( tempRepository != null ) {
			FileResource tempFileResource = tempRepository.createFileResource( true );

			if ( tempFileResource instanceof FileResource.TargetFile ) {
				return ( (FileResource.TargetFile) tempFileResource ).getTargetFile();
			}
			else {
				throw new FileStorageException(
						String.format( "File repository '%s' registered, but does not provide FileResource.TargetFile implementations. " +
								               "Any FileRepository used for temp files must return FileResource implementations that implement TargetFile.",
						               TEMP_REPOSITORY ) );
			}
		}

		try {
			return File.createTempFile( UUID.randomUUID().toString(), "" );
		}
		catch ( IOException ioe ) {
			throw new FileStorageException( ioe );
		}
	}

	@Override
	public String getRepositoryId() {
		return requireRepository( DEFAULT_REPOSITORY ).getRepositoryId();
	}

	@Override
	public FileDescriptor createFile() {
		return createFile( DEFAULT_REPOSITORY );
	}

	@Override
	public FileDescriptor moveInto( File file ) {
		return moveInto( DEFAULT_REPOSITORY, file );
	}

	@Override
	public FileDescriptor save( File file ) {
		return save( DEFAULT_REPOSITORY, file );
	}

	@Override
	public FileDescriptor save( String repositoryId, File file ) {
		return requireRepository( repositoryId ).save( file );
	}

	@Override
	public FileDescriptor save( InputStream inputStream ) {
		return save( DEFAULT_REPOSITORY, inputStream );
	}

	@Override
	public FileDescriptor save( String repositoryId, InputStream inputStream ) {
		return requireRepository( repositoryId ).save( inputStream );
	}

	@Override
	public void save( FileDescriptor target, InputStream inputStream, boolean replaceExisting ) {
		requireRepository( target.getRepositoryId() ).save( target, inputStream, true );
	}

	@Override
	public FileDescriptor createFile( String repositoryId ) {
		return requireRepository( repositoryId ).createFile();
	}

	@Override
	public FileDescriptor moveInto( String repositoryId, File file ) {
		return requireRepository( repositoryId ).moveInto( file );
	}

	@Override
	public boolean delete( FileDescriptor descriptor ) {
		return requireRepository( descriptor.getRepositoryId() ).delete( descriptor );
	}

	@Override
	public OutputStream getOutputStream( FileDescriptor descriptor ) {
		return requireRepository( descriptor.getRepositoryId() ).getOutputStream( descriptor );
	}

	@Override
	public InputStream getInputStream( FileDescriptor descriptor ) {
		return requireRepository( descriptor.getRepositoryId() ).getInputStream( descriptor );
	}

	@Override
	public File getAsFile( FileDescriptor descriptor ) {
		return requireRepository( descriptor.getRepositoryId() ).getAsFile( descriptor );
	}

	@Override
	public boolean exists( FileDescriptor descriptor ) {
		return requireRepository( descriptor.getRepositoryId() ).exists( descriptor );
	}

	@Override
	public boolean move( FileDescriptor source, FileDescriptor target ) {
		FileRepository sourceRep = requireRepository( source.getRepositoryId() );
		if ( source.getRepositoryId().equals( target.getRepositoryId() ) ) {
			return sourceRep.move( source, target );
		}
		else {
			save( target, sourceRep.getInputStream( source ), true );
			return delete( source );
		}
	}

	@Override
	public void setFileRepositoryFactory( FileRepositoryFactory factory ) {
		this.repositoryFactory = factory;
	}

	@Override
	public FileRepository getRepository( FileDescriptor descriptor ) {
		return getRepository( descriptor.getRepositoryId() );
	}

	@Override
	public FileRepository getRepository( String repositoryId ) {
		FileRepository repository = repositories.get( repositoryId );

		if ( repository == null ) {
			return createAndRegister( repositoryId );
		}

		return repository;
	}

	@Override
	public boolean repositoryExists( String repositoryId ) {
		return repositories.containsKey( repositoryId );
	}

	@Override
	public FileRepository registerRepository( FileRepository fileRepository ) {
		Assert.notNull( fileRepository.getRepositoryId(), "A FileRepository must have a valid repository id" );
		FileRepositoryDelegate delegate = repositories.get( fileRepository.getRepositoryId() );

		if ( delegate == null ) {
			delegate = new FileRepositoryDelegate();
			repositories.put( fileRepository.getRepositoryId(), delegate );
		}

		delegate.setActualImplementation( fileRepository );

		if ( fileRepository instanceof FileManagerAware ) {
			( (FileManagerAware) fileRepository ).setFileManager( this );
		}

		return delegate;
	}

	@Override
	public Collection listRepositories() {
		return Collections.unmodifiableCollection( new ArrayList<>( repositories.values() ) );
	}

	@Override
	public Collection findFiles( String pattern ) {
		return findResources( pattern, FileRepository::findFiles );
	}

	@Override
	public  Collection findResources( String pattern, Class resourceType ) {
		BiFunction> searchFunction = ( repository, p ) -> repository.findResources( p, resourceType );
		return findResources( pattern, searchFunction );
	}

	@Override
	public Collection findResources( @NonNull String pattern ) {
		return findResources( pattern, FileRepository::findResources );
	}

	private  Collection findResources( @NonNull String pattern,
	                                                                        BiFunction> searchFunction ) {
		String withoutProtocol = StringUtils.removeStart( pattern, FileDescriptor.PROTOCOL );
		boolean protocolWasPresent = withoutProtocol.length() < pattern.length();
		int repositoryDelimiter = withoutProtocol.indexOf( ':' );

		if ( protocolWasPresent && ( repositoryDelimiter <= 0 || repositoryDelimiter == withoutProtocol.length() - 1 ) ) {
			throw new IllegalArgumentException( "Pattern must contain a repository pattern when starting with axfs:// protocol" );
		}

		AntPathMatcher pathMatcher = new AntPathMatcher();
		String repositoryPattern = repositoryDelimiter > 0 ? withoutProtocol.substring( 0, repositoryDelimiter ) : DEFAULT_REPOSITORY;
		String resourcesPattern = StringUtils.replaceOnce( withoutProtocol.substring( repositoryDelimiter + 1 ), ":", "/" );

		return matchingRepositories( pathMatcher, repositoryPattern )
				.flatMap( repository -> searchFunction.apply( repository, resourcesPattern ).stream() )
				.collect( Collectors.toList() );
	}

	private Stream matchingRepositories( AntPathMatcher matcher, String pattern ) {
		boolean isPattern = matcher.isPattern( pattern );

		return repositories.values()
		                   .stream()
		                   .filter(
				                   repository -> isPattern
						                   ? matcher.match( pattern, repository.getRepositoryId() )
						                   : StringUtils.equals( pattern, repository.getRepositoryId() )
		                   );
	}

	/**
	 * Signal shutdown of the file manager to all repositories.
	 * This also removes all registered repositories, even though after a call
	 * to shutdown the manager can be reused.
	 */
	@PreDestroy
	public void shutdown() {
		repositories.values()
		            .stream()
		            .map( FileRepositoryDelegate::getActualImplementation )
		            .filter( FileManagerAware.class::isInstance )
		            .map( FileManagerAware.class::cast )
		            .forEach( FileManagerAware::shutdown );
		repositories.clear();
	}

	private FileRepository requireRepository( String repositoryId ) {
		FileRepository repository = getRepository( repositoryId );

		if ( repository == null ) {
			if ( repositoryFactory != null ) {
				throw new FileStorageException( String.format(
						"No FileRepository with id %s available.  The factory did not create an instance.",
						repositoryId ) );
			}

			throw new FileStorageException( String.format(
					"No FileRepository with id %s available, it has not been registered and no factory is available.",
					repositoryId ) );
		}

		return repository;
	}

	private FileRepository createAndRegister( String repositoryId ) {
		if ( repositoryFactory == null ) {
			throw new IllegalArgumentException(
					String.format( "No FileRepository with id %s available and none could be created (no FileRepositoryFactory)", repositoryId ) );
		}

		FileRepository repository = repositoryFactory.create( repositoryId );

		if ( repository != null ) {
			return registerRepository( repository );
		}

		return null;
	}
}