Subversion Repositories XServices

/*

 *   Copyright 2013 Brian Rosenberger (Brutex Network)

 *

 *   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.

 */

import java.io.FileInputStream;

import java.io.FileOutputStream;

import java.io.IOException;

import java.io.OutputStream;

import java.net.URI;

import java.nio.file.DirectoryStream;

import java.nio.file.FileSystems;

import java.nio.file.FileVisitOption;

import java.nio.file.FileVisitResult;

import java.nio.file.Path;

import java.nio.file.PathMatcher;

import java.nio.file.SimpleFileVisitor;

import java.nio.file.attribute.BasicFileAttributeView;

import java.nio.file.attribute.BasicFileAttributes;

import java.util.EnumSet;

import java.util.zip.ZipEntry;

import java.util.zip.ZipOutputStream;

import javax.ws.rs.NotAuthorizedException;

import javax.ws.rs.WebApplicationException;

import javax.ws.rs.core.MediaType;

import javax.ws.rs.core.UriInfo;

import net.brutex.xservices.util.FileWalker;

import org.apache.log4j.Logger;

import org.apache.shiro.SecurityUtils;

import org.apache.shiro.authz.UnauthorizedException;

 *

public class FileInfoImpl  implements FileInfo {

	Logger logger = Logger.getLogger(FileInfoImpl.class);

  /* (non-Javadoc)

   * @see net.brutex.xservices.ws.rs.FileInfo#getFiles(javax.ws.rs.core.HttpHeaders, java.lang.String, boolean, boolean, int, java.lang.String, int, int)

  {

    if (level <= 0) level = 1;

      logger.debug(String.format("Hitting cache with cachekey '%s'", cachekey));

      List<FileInfoType> list = (List<FileInfoType>)jcs.get(cachekey);

      logger.info(String.format("Returning items %s to %s from total of %s items in the list.", fromIndex, toIndex, list.size()));

  /**

   * Sets the directory.

   *

   * @param list the list

   * @param dir the dir

   * @param withDirectories the with directories

   * @param withFiles the with files

   * @param depth the depth

   * @param search the search

    		search = "*";

    	FileWalker finder = new FileWalker(search);

			Files.walkFileTree(dir.toPath(), EnumSet.of(FileVisitOption.FOLLOW_LINKS), depth, finder);

	    	}

		} catch (IOException e2) {

			logger.error(e2.getMessage(), e2);;

  /**

   * Sets the directory.

   *

   * @param dir the dir

   * @param withDirectories the with directories

   * @param withFiles the with files

   * @param depth the depth

   * @param search the search

   * @return the list

  }

@Override

public Response getFile(HttpHeaders paramHttpHeaders, String file) {

	isPermitted(file);

	try {

	Path path = FileSystems.getDefault().getPath(file);

	BasicFileAttributeView basicView = Files.getFileAttributeView(path, BasicFileAttributeView.class);

	BasicFileAttributes basic;

	basic = basicView.readAttributes();

	//In case this is a directory

	//we zip it and return the zip stream

	if(basic.isDirectory()) return getDirectoryAsZip(path);

	MediaType mime = MediaType.APPLICATION_OCTET_STREAM_TYPE;

	try {

		mime = MediaType.valueOf(Files.probeContentType(path));

	} catch (IllegalArgumentException | IOException e) {

		//In case we can not find the media type for some reason

		//the default assignment is taken, so we can

		//ignore this error.

		logger.debug(String.format("Could not probe media type for file '%s'. Default is '%s'", path.toString(), mime.getType()), e);

	}

	Response r = Response.ok(path.toFile(), mime).build();

	String fileName = path.getFileName().toString();

	if(mime == MediaType.APPLICATION_OCTET_STREAM_TYPE) r.getHeaders().add("Content-Disposition", "attachment; filename=\"" + fileName + "\"");

	return r;

		} catch (IOException e1) {

			// TODO Auto-generated catch block

			logger.error(e1.getMessage(), e1);

			return Response.serverError().build();

		}

}

private Response getDirectoryAsZip(final Path path) {

	StreamingOutput output = new StreamingOutput() {

		@Override

		public void write(OutputStream os) throws IOException,

				WebApplicationException {

			ZipOutputStream zos = new ZipOutputStream(os);

			//read directory content (files only)

			try (DirectoryStream<Path> stream = Files.newDirectoryStream(path)) {

			    for (Path file: stream) {

			    	//skip anything not being a file

			        if(! file.toFile().isFile()) continue;

			        //ZipEntry

			        String filename = file.getFileName().toString();

			        ZipEntry ze = new ZipEntry(filename);

			        zos.putNextEntry( ze );

			        //read a file and put it into the output stream

			        FileInputStream fis = new FileInputStream(file.toFile());

			        byte[] buffer = new byte[1024];

			        int len;

			        while ((len = fis.read(buffer)) > 0) {

			        	zos.write(buffer, 0, len);

			        }

			        zos.flush();

			        fis.close();

			    }

			    zos.close();

			}

		}

	};

	Response r = Response.ok(output, MediaType.APPLICATION_OCTET_STREAM_TYPE).build();

	String zipname = (path.getFileName()==null) ? "null.zip" : path.getFileName().toString()+".zip";

	r.getHeaders().add("Content-Disposition", "attachment; filename=\"" + zipname + "\"");

	return r;

}

private boolean isPermitted(String dir) {

	if(! SecurityUtils.getSubject().isPermitted( new DirectoryPermission(dir))) {

		logger.warn(String.format("User '%s' does not have permission to access '%s'.",SecurityUtils.getSubject().getPrincipal(), dir ));

		throw new NotAuthorizedException(new UnauthorizedException("User does not have permission to access "+ dir));

	}

	return true;