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
  {
147 brianR 76
 
77
	isPermitted(dir);
78
 
79
    URI baseuri = URI.create(uriInfo.getBaseUri()+FileInfo.BASE_PATH+"getFile?file=");
80
 
81
    if(dir==null) {dir = "c:/"; System.out.println("No directory specified.");}
82
    logger.info(String.format("Listing directory '%s'.", dir));
83
    if (level <= 0) level = 1;
92 brianR 84
 
109 brianR 85
    if ((!withDir) && (!withFiles)) withFiles = true;
86
    String cachekey = level + "||" + withFiles + "||" + withDir + "||" + search + "||" + dir;
87
    try {
147 brianR 88
      logger.debug(String.format("Hitting cache with cachekey '%s'", cachekey));
109 brianR 89
      JCS jcs = JCS.getInstance("FileCache");
94 brianR 90
 
147 brianR 91
      /*Try to retrieve the file list from the cache*/
92
      List<FileInfoType> list = (List<FileInfoType>)jcs.get(cachekey);
93
 
94
      if (list == null || !useCache) {
95
        list = setDirectory(baseuri, dir, withDir, withFiles, level, search);
109 brianR 96
        jcs.put(cachekey, list);
147 brianR 97
        logger.debug("Stored in Cache: " + list.toString());
109 brianR 98
      } else {
147 brianR 99
        logger.debug("Got from Cache: " + list.toString());
109 brianR 100
      }
92 brianR 101
 
109 brianR 102
      int fromIndex = 0;
103
      int toIndex = 0;
104
      fromIndex = (page - 1) * count;
105
      toIndex = page * count;
106
      if (toIndex > list.size()) toIndex = list.size();
107
      if (fromIndex > toIndex) fromIndex = toIndex;
147 brianR 108
      GenericEntity<List<FileInfoType>> sublist = new GenericEntity<List<FileInfoType>>(list.subList(fromIndex, toIndex)) {};
109
      logger.info(String.format("Returning items %s to %s from total of %s items in the list.", fromIndex, toIndex, list.size()));
109 brianR 110
      return Response.ok(sublist).build();
111
    } catch (CacheException e) {
112
      Response.serverError().build();
113
    }
114
    return null;
115
  }
92 brianR 116
 
147 brianR 117
  /**
118
   * Sets the directory.
119
   *
120
   * @param list the list
121
   * @param dir the dir
122
   * @param withDirectories the with directories
123
   * @param withFiles the with files
124
   * @param depth the depth
125
   * @param search the search
126
   */
127
  private void setDirectory(final URI baseuri, final List<FileInfoType> list, File dir, boolean withDirectories, boolean withFiles, final int depth, String search)
109 brianR 128
  {
129
    if (depth <= 0) return;
147 brianR 130
 
131
    	if(search==null || search.equals("") ) {
132
    		search = "*";
133
    		logger.info("No search pattern supplied, using default '*'.");
134
    	}
135
 
136
    	FileWalker finder = new FileWalker(search);
137
    	try {
138
			Files.walkFileTree(dir.toPath(), EnumSet.of(FileVisitOption.FOLLOW_LINKS), depth, finder);
139
			logger.info("FileWalker returned '"+finder.getCount()+"' hits. '" + finder.getTotal() + "' files have been scanned.");
140
			List<Path> result = finder.getResult();
141
	    	for(Path f : result) {
142
	    		list.add(new FileInfoType(f, baseuri));
143
	    	}
144
		} catch (IOException e2) {
145
			logger.error(e2.getMessage(), e2);;
146
		}
109 brianR 147
  }
147 brianR 148
 
149
  /**
150
   * Sets the directory.
151
   *
152
   * @param dir the dir
153
   * @param withDirectories the with directories
154
   * @param withFiles the with files
155
   * @param depth the depth
156
   * @param search the search
157
   * @return the list
158
   */
159
  private List<FileInfoType> setDirectory(URI baseuri, String dir, boolean withDirectories, boolean withFiles, int depth, String search)
109 brianR 160
  {
147 brianR 161
    List<FileInfoType> list = new ArrayList<FileInfoType>();
162
    setDirectory(baseuri, list, new File(dir), withDirectories, withFiles, depth, search);
109 brianR 163
    return list;
164
  }
147 brianR 165
 
166
@Override
167
public Response getFile(HttpHeaders paramHttpHeaders, String file) {
168
	isPermitted(file);
169
	try {
170
	Path path = FileSystems.getDefault().getPath(file);
171
 
172
	BasicFileAttributeView basicView = Files.getFileAttributeView(path, BasicFileAttributeView.class);
173
	BasicFileAttributes basic;
174
	basic = basicView.readAttributes();
175
 
176
 
177
	//In case this is a directory
178
	//we zip it and return the zip stream
179
	if(basic.isDirectory()) return getDirectoryAsZip(path);
180
 
181
 
182
 
183
	MediaType mime = MediaType.APPLICATION_OCTET_STREAM_TYPE;
184
	try {
185
		mime = MediaType.valueOf(Files.probeContentType(path));
186
	} catch (IllegalArgumentException | IOException e) {
187
		//In case we can not find the media type for some reason
188
		//the default assignment is taken, so we can
189
		//ignore this error.
190
		logger.debug(String.format("Could not probe media type for file '%s'. Default is '%s'", path.toString(), mime.getType()), e);
191
	}
192
	Response r = Response.ok(path.toFile(), mime).build();
193
	String fileName = path.getFileName().toString();
194
	if(mime == MediaType.APPLICATION_OCTET_STREAM_TYPE) r.getHeaders().add("Content-Disposition", "attachment; filename=\"" + fileName + "\"");
195
	return r;
196
		} catch (IOException e1) {
197
			// TODO Auto-generated catch block
198
			logger.error(e1.getMessage(), e1);
199
			return Response.serverError().build();
200
		}
201
}
202
 
203
private Response getDirectoryAsZip(final Path path) {
204
 
205
	StreamingOutput output = new StreamingOutput() {
206
 
207
		@Override
208
		public void write(OutputStream os) throws IOException,
209
				WebApplicationException {
210
			ZipOutputStream zos = new ZipOutputStream(os);
211
 
212
			//read directory content (files only)
213
			try (DirectoryStream<Path> stream = Files.newDirectoryStream(path)) {
214
			    for (Path file: stream) {
215
			    	//skip anything not being a file
216
			        if(! file.toFile().isFile()) continue;
217
 
218
			        //ZipEntry
219
			        String filename = file.getFileName().toString();
220
			        ZipEntry ze = new ZipEntry(filename);
221
			        zos.putNextEntry( ze );
222
 
223
			        //read a file and put it into the output stream
224
			        FileInputStream fis = new FileInputStream(file.toFile());
225
			        byte[] buffer = new byte[1024];
226
			        int len;
227
			        while ((len = fis.read(buffer)) > 0) {
228
			        	zos.write(buffer, 0, len);
229
			        }
230
			        zos.flush();
231
			        fis.close();
232
			    }
233
			    zos.close();
234
			}
235
 
236
		}
237
	};
238
	Response r = Response.ok(output, MediaType.APPLICATION_OCTET_STREAM_TYPE).build();
239
	String zipname = (path.getFileName()==null) ? "null.zip" : path.getFileName().toString()+".zip";
240
	r.getHeaders().add("Content-Disposition", "attachment; filename=\"" + zipname + "\"");
241
	return r;
242
}
243
 
244
private boolean isPermitted(String dir) {
245
	if(! SecurityUtils.getSubject().isPermitted( new DirectoryPermission(dir))) {
246
		logger.warn(String.format("User '%s' does not have permission to access '%s'.",SecurityUtils.getSubject().getPrincipal(), dir ));
247
		throw new NotAuthorizedException(new UnauthorizedException("User does not have permission to access "+ dir));
248
	}
249
	return true;
250
}
109 brianR 251
}