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.File;

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.Files;

import java.nio.file.Path;

import java.nio.file.PathMatcher;

import java.nio.file.SimpleFileVisitor;

import java.nio.file.attribute.BasicFileAttributeView;

import java.util.ArrayList;

import java.util.List;

import java.util.zip.ZipEntry;

import java.util.zip.ZipOutputStream;

import javax.ws.rs.NotAuthorizedException;

import javax.ws.rs.core.HttpHeaders;

import javax.ws.rs.core.StreamingOutput;

import javax.ws.rs.core.UriInfo;

import net.brutex.xservices.types.FileInfoType;

import org.apache.jcs.JCS;

import org.apache.jcs.access.exception.CacheException;

import org.apache.log4j.Logger;

/**

 * @author Brian Rosenberger, bru(at)brutex.de

 */

public class FileInfoImpl  implements FileInfo {

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

   */

    if(dir==null) {dir = "c:/"; System.out.println("No directory specified.");}

    if ((!withDir) && (!withFiles)) withFiles = true;

    try {

      JCS jcs = JCS.getInstance("FileCache");

      fromIndex = (page - 1) * count;

    } catch (CacheException e) {

      Response.serverError().build();

    }

    return null;

  }

  /**

   * Sets the directory.

   *

   * @param list the list

  private void setDirectory(final URI baseuri, final List<FileInfoType> list, File dir, boolean withDirectories, boolean withFiles, final int depth, String search)

    	if(search==null || search.equals("") ) {

    		logger.info("No search pattern supplied, using default '*'.");

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

			logger.info("FileWalker returned '"+finder.getCount()+"' hits. '" + finder.getTotal() + "' files have been scanned.");

			List<Path> result = finder.getResult();

	    	}

		} catch (IOException e2) {

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

		}

  }

  /**

   * Sets the directory.

   *

   * @param dir the dir

  private List<FileInfoType> setDirectory(URI baseuri, String dir, boolean withDirectories, boolean withFiles, int depth, String search)

  {

    List<FileInfoType> list = new ArrayList<FileInfoType>();

    setDirectory(baseuri, list, new File(dir), withDirectories, withFiles, depth, search);

    return 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) {