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

package net.brutex.xservices.ws.rs;

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.FileVisitResult;
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.nio.file.attribute.BasicFileAttributes;
import java.util.ArrayList;
import java.util.EnumSet;
import java.util.List;
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.GenericEntity;
import javax.ws.rs.core.HttpHeaders;
import javax.ws.rs.core.MediaType;
import javax.ws.rs.core.Response;
import javax.ws.rs.core.StreamingOutput;
import javax.ws.rs.core.UriInfo;

import net.brutex.xservices.security.DirectoryPermission;
import net.brutex.xservices.types.FileInfoType;
import net.brutex.xservices.util.FileWalker;

import org.apache.commons.jcs.JCS;
import org.apache.commons.jcs.access.CacheAccess;
import org.apache.commons.jcs.access.exception.CacheException;
import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;
import org.apache.shiro.SecurityUtils;
import org.apache.shiro.authz.UnauthorizedException;

/**
 * The Class FileInfoImpl.
 *
 * @author Brian Rosenberger, bru(at)brutex.de
 */
public class FileInfoImpl  implements FileInfo {
        
        
        Logger logger = LogManager.getLogger();
        

  /* (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)
   */
  public Response getFiles(HttpHeaders h, UriInfo uriInfo, String dir, boolean withDir, boolean withFiles, int level, String search, int count, int page, boolean useCache)
  {
        if(dir==null) {
                dir = "c:/"; 
                logger.warn("No directory specified. Default is 'c:/'.");
                }
        isPermitted(dir);
        
    URI baseuri = URI.create(uriInfo.getBaseUri()+FileInfo.BASE_PATH+"getFile?file=");
    
    logger.info(String.format("Listing directory '%s'.", dir));
    if (level <= 0) level = 1;

    if ((!withDir) && (!withFiles)) withFiles = true;
    String cachekey = level + "||" + withFiles + "||" + withDir + "||" + search + "||" + dir;
    try {
      logger.debug(String.format("Hitting cache with cachekey '%s'", cachekey));
      CacheAccess<Object, Object> jcs = JCS.getInstance("FileCache");

      /*Try to retrieve the file list from the cache*/
      List<FileInfoType> list = (List<FileInfoType>)jcs.get(cachekey);
      
      if (list == null || !useCache) {
        list = setDirectory(baseuri, dir, withDir, withFiles, level, search);
        jcs.put(cachekey, list);
        logger.debug("Stored in Cache: " + list.toString());
      } else {
        logger.debug("Got from Cache: " + list.toString());
      }

      int fromIndex = 0;
      int toIndex = 0;
      fromIndex = (page - 1) * count;
      toIndex = page * count;
      if (toIndex > list.size()) toIndex = list.size();
      if (fromIndex > toIndex) fromIndex = toIndex;
      GenericEntity<List<FileInfoType>> sublist = new GenericEntity<List<FileInfoType>>(list.subList(fromIndex, toIndex)) {};
      logger.info(String.format("Returning items %s to %s from total of %s items in the list.", fromIndex, toIndex, list.size()));
      return Response.ok(sublist).build();
    } catch (CacheException e) {
      return Response.serverError().build();
    }
  }

  /**
   * 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
   */
  private void setDirectory(final URI baseuri, final List<FileInfoType> list, File dir, boolean withDirectories, boolean withFiles, final int depth, String search)
  {
    if (depth <= 0) return;
    
        if(search==null || search.equals("") ) {
                search = "*";
                logger.info("No search pattern supplied, using default '*'.");
        }
        
        FileWalker finder = new FileWalker(search);
        try {
                        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();
                for(Path f : result) {
                        if(! withDirectories) {
                                if(f.toFile().isDirectory()) continue;
                        }
                        if(! withFiles) {
                                if(f.toFile().isFile()) continue;
                        }
                        list.add(new FileInfoType(f, baseuri));
                }
                } 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
   */
  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) {
        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;
}

//http://stackoverflow.com/questions/3758606/how-to-convert-byte-size-into-human-readable-format-in-java
private static String humanReadableByteCount(long bytes, boolean si) {
    int unit = si ? 1000 : 1024;
    if (bytes < unit) return bytes + " B";
    int exp = (int) (Math.log(bytes) / Math.log(unit));
    String pre = (si ? "kMGTPE" : "KMGTPE").charAt(exp-1) + (si ? "" : "i");
    return String.format("%.1f %sB", bytes / Math.pow(unit, exp), pre);
}

}