Subversion Repositories XServices

Rev

Details | Last modification | View Log | RSS feed

Rev Author Line No. Line
147 brianR 1
/*
2
 *   Copyright 2013 Brian Rosenberger (Brutex Network)
3
 *
4
 *   Licensed under the Apache License, Version 2.0 (the "License");
5
 *   you may not use this file except in compliance with the License.
6
 *   You may obtain a copy of the License at
7
 *
8
 *       http://www.apache.org/licenses/LICENSE-2.0
9
 *
10
 *   Unless required by applicable law or agreed to in writing, software
11
 *   distributed under the License is distributed on an "AS IS" BASIS,
12
 *   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13
 *   See the License for the specific language governing permissions and
14
 *   limitations under the License.
15
 */
16
 
92 brianR 17
package net.brutex.xservices.ws.rs;
18
 
19
import java.io.File;
147 brianR 20
import java.io.FileInputStream;
21
import java.io.FileOutputStream;
22
import java.io.IOException;
23
import java.io.OutputStream;
24
import java.net.URI;
25
import java.nio.file.DirectoryStream;
26
import java.nio.file.FileSystems;
27
import java.nio.file.FileVisitOption;
28
import java.nio.file.FileVisitResult;
29
import java.nio.file.Files;
30
import java.nio.file.Path;
31
import java.nio.file.PathMatcher;
32
import java.nio.file.SimpleFileVisitor;
33
import java.nio.file.attribute.BasicFileAttributeView;
34
import java.nio.file.attribute.BasicFileAttributes;
92 brianR 35
import java.util.ArrayList;
147 brianR 36
import java.util.EnumSet;
92 brianR 37
import java.util.List;
147 brianR 38
import java.util.zip.ZipEntry;
39
import java.util.zip.ZipOutputStream;
40
 
41
import javax.ws.rs.NotAuthorizedException;
42
import javax.ws.rs.WebApplicationException;
92 brianR 43
import javax.ws.rs.core.GenericEntity;
44
import javax.ws.rs.core.HttpHeaders;
147 brianR 45
import javax.ws.rs.core.MediaType;
92 brianR 46
import javax.ws.rs.core.Response;
147 brianR 47
import javax.ws.rs.core.StreamingOutput;
48
import javax.ws.rs.core.UriInfo;
49
 
50
import net.brutex.xservices.security.DirectoryPermission;
109 brianR 51
import net.brutex.xservices.types.FileInfoType;
147 brianR 52
import net.brutex.xservices.util.FileWalker;
92 brianR 53
 
54
import org.apache.jcs.JCS;
55
import org.apache.jcs.access.exception.CacheException;
147 brianR 56
import org.apache.log4j.Logger;
57
import org.apache.shiro.SecurityUtils;
58
import org.apache.shiro.authz.UnauthorizedException;
92 brianR 59
 
60
/**
147 brianR 61
 * The Class FileInfoImpl.
62
 *
109 brianR 63
 * @author Brian Rosenberger, bru(at)brutex.de
92 brianR 64
 */
147 brianR 65
public class FileInfoImpl  implements FileInfo {
66
 
67
 
68
	Logger logger = Logger.getLogger(FileInfoImpl.class);
69
 
70
 
71
  /* (non-Javadoc)
72
   * @see net.brutex.xservices.ws.rs.FileInfo#getFiles(javax.ws.rs.core.HttpHeaders, java.lang.String, boolean, boolean, int, java.lang.String, int, int)
73
   */
74
  public Response getFiles(HttpHeaders h, UriInfo uriInfo, String dir, boolean withDir, boolean withFiles, int level, String search, int count, int page, boolean useCache)
109 brianR 75
  {
177 brianR 76
	if(dir==null) {
77
		dir = "c:/";
78
		logger.warn("No directory specified. Default is 'c:/'.");
79
		}
147 brianR 80
	isPermitted(dir);
81
 
82
    URI baseuri = URI.create(uriInfo.getBaseUri()+FileInfo.BASE_PATH+"getFile?file=");
83
 
84
    logger.info(String.format("Listing directory '%s'.", dir));
85
    if (level <= 0) level = 1;
92 brianR 86
 
109 brianR 87
    if ((!withDir) && (!withFiles)) withFiles = true;
88
    String cachekey = level + "||" + withFiles + "||" + withDir + "||" + search + "||" + dir;
89
    try {
147 brianR 90
      logger.debug(String.format("Hitting cache with cachekey '%s'", cachekey));
109 brianR 91
      JCS jcs = JCS.getInstance("FileCache");
94 brianR 92
 
147 brianR 93
      /*Try to retrieve the file list from the cache*/
94
      List<FileInfoType> list = (List<FileInfoType>)jcs.get(cachekey);
95
 
96
      if (list == null || !useCache) {
97
        list = setDirectory(baseuri, dir, withDir, withFiles, level, search);
109 brianR 98
        jcs.put(cachekey, list);
147 brianR 99
        logger.debug("Stored in Cache: " + list.toString());
109 brianR 100
      } else {
147 brianR 101
        logger.debug("Got from Cache: " + list.toString());
109 brianR 102
      }
92 brianR 103
 
109 brianR 104
      int fromIndex = 0;
105
      int toIndex = 0;
106
      fromIndex = (page - 1) * count;
107
      toIndex = page * count;
108
      if (toIndex > list.size()) toIndex = list.size();
109
      if (fromIndex > toIndex) fromIndex = toIndex;
147 brianR 110
      GenericEntity<List<FileInfoType>> sublist = new GenericEntity<List<FileInfoType>>(list.subList(fromIndex, toIndex)) {};
111
      logger.info(String.format("Returning items %s to %s from total of %s items in the list.", fromIndex, toIndex, list.size()));
109 brianR 112
      return Response.ok(sublist).build();
113
    } catch (CacheException e) {
177 brianR 114
      return Response.serverError().build();
109 brianR 115
    }
116
  }
92 brianR 117
 
147 brianR 118
  /**
119
   * Sets the directory.
120
   *
121
   * @param list the list
122
   * @param dir the dir
123
   * @param withDirectories the with directories
124
   * @param withFiles the with files
125
   * @param depth the depth
126
   * @param search the search
127
   */
128
  private void setDirectory(final URI baseuri, final List<FileInfoType> list, File dir, boolean withDirectories, boolean withFiles, final int depth, String search)
109 brianR 129
  {
130
    if (depth <= 0) return;
147 brianR 131
 
132
    	if(search==null || search.equals("") ) {
133
    		search = "*";
134
    		logger.info("No search pattern supplied, using default '*'.");
135
    	}
136
 
137
    	FileWalker finder = new FileWalker(search);
138
    	try {
139
			Files.walkFileTree(dir.toPath(), EnumSet.of(FileVisitOption.FOLLOW_LINKS), depth, finder);
140
			logger.info("FileWalker returned '"+finder.getCount()+"' hits. '" + finder.getTotal() + "' files have been scanned.");
141
			List<Path> result = finder.getResult();
142
	    	for(Path f : result) {
156 brianR 143
	    		if(! withDirectories) {
144
	    			if(f.toFile().isDirectory()) continue;
145
	    		}
146
	    		if(! withFiles) {
147
	    			if(f.toFile().isFile()) continue;
148
	    		}
147 brianR 149
	    		list.add(new FileInfoType(f, baseuri));
150
	    	}
151
		} catch (IOException e2) {
152
			logger.error(e2.getMessage(), e2);;
153
		}
109 brianR 154
  }
147 brianR 155
 
156
  /**
157
   * Sets the directory.
158
   *
159
   * @param dir the dir
160
   * @param withDirectories the with directories
161
   * @param withFiles the with files
162
   * @param depth the depth
163
   * @param search the search
164
   * @return the list
165
   */
166
  private List<FileInfoType> setDirectory(URI baseuri, String dir, boolean withDirectories, boolean withFiles, int depth, String search)
109 brianR 167
  {
147 brianR 168
    List<FileInfoType> list = new ArrayList<FileInfoType>();
169
    setDirectory(baseuri, list, new File(dir), withDirectories, withFiles, depth, search);
109 brianR 170
    return list;
171
  }
147 brianR 172
 
173
@Override
174
public Response getFile(HttpHeaders paramHttpHeaders, String file) {
175
	isPermitted(file);
176
	try {
177
	Path path = FileSystems.getDefault().getPath(file);
178
 
179
	BasicFileAttributeView basicView = Files.getFileAttributeView(path, BasicFileAttributeView.class);
180
	BasicFileAttributes basic;
181
	basic = basicView.readAttributes();
182
 
183
 
184
	//In case this is a directory
185
	//we zip it and return the zip stream
186
	if(basic.isDirectory()) return getDirectoryAsZip(path);
187
 
188
 
189
 
190
	MediaType mime = MediaType.APPLICATION_OCTET_STREAM_TYPE;
191
	try {
192
		mime = MediaType.valueOf(Files.probeContentType(path));
193
	} catch (IllegalArgumentException | IOException e) {
194
		//In case we can not find the media type for some reason
195
		//the default assignment is taken, so we can
196
		//ignore this error.
197
		logger.debug(String.format("Could not probe media type for file '%s'. Default is '%s'", path.toString(), mime.getType()), e);
198
	}
199
	Response r = Response.ok(path.toFile(), mime).build();
200
	String fileName = path.getFileName().toString();
201
	if(mime == MediaType.APPLICATION_OCTET_STREAM_TYPE) r.getHeaders().add("Content-Disposition", "attachment; filename=\"" + fileName + "\"");
202
	return r;
203
		} catch (IOException e1) {
204
			// TODO Auto-generated catch block
205
			logger.error(e1.getMessage(), e1);
206
			return Response.serverError().build();
207
		}
208
}
209
 
210
private Response getDirectoryAsZip(final Path path) {
211
 
212
	StreamingOutput output = new StreamingOutput() {
213
 
214
		@Override
215
		public void write(OutputStream os) throws IOException,
216
				WebApplicationException {
217
			ZipOutputStream zos = new ZipOutputStream(os);
218
 
219
			//read directory content (files only)
220
			try (DirectoryStream<Path> stream = Files.newDirectoryStream(path)) {
221
			    for (Path file: stream) {
222
			    	//skip anything not being a file
223
			        if(! file.toFile().isFile()) continue;
224
 
225
			        //ZipEntry
226
			        String filename = file.getFileName().toString();
227
			        ZipEntry ze = new ZipEntry(filename);
228
			        zos.putNextEntry( ze );
229
 
230
			        //read a file and put it into the output stream
231
			        FileInputStream fis = new FileInputStream(file.toFile());
232
			        byte[] buffer = new byte[1024];
233
			        int len;
234
			        while ((len = fis.read(buffer)) > 0) {
235
			        	zos.write(buffer, 0, len);
236
			        }
237
			        zos.flush();
238
			        fis.close();
239
			    }
240
			    zos.close();
241
			}
242
 
243
		}
244
	};
245
	Response r = Response.ok(output, MediaType.APPLICATION_OCTET_STREAM_TYPE).build();
246
	String zipname = (path.getFileName()==null) ? "null.zip" : path.getFileName().toString()+".zip";
247
	r.getHeaders().add("Content-Disposition", "attachment; filename=\"" + zipname + "\"");
248
	return r;
249
}
250
 
251
private boolean isPermitted(String dir) {
252
	if(! SecurityUtils.getSubject().isPermitted( new DirectoryPermission(dir))) {
253
		logger.warn(String.format("User '%s' does not have permission to access '%s'.",SecurityUtils.getSubject().getPrincipal(), dir ));
254
		throw new NotAuthorizedException(new UnauthorizedException("User does not have permission to access "+ dir));
255
	}
256
	return true;
257
}
177 brianR 258
 
259
//http://stackoverflow.com/questions/3758606/how-to-convert-byte-size-into-human-readable-format-in-java
260
private static String humanReadableByteCount(long bytes, boolean si) {
261
    int unit = si ? 1000 : 1024;
262
    if (bytes < unit) return bytes + " B";
263
    int exp = (int) (Math.log(bytes) / Math.log(unit));
264
    String pre = (si ? "kMGTPE" : "KMGTPE").charAt(exp-1) + (si ? "" : "i");
265
    return String.format("%.1f %sB", bytes / Math.pow(unit, exp), pre);
266
}
267
 
109 brianR 268
}