public static SyncFile addFolderSyncFile(
Path filePath, long parentFolderId, long repositoryId, long syncAccountId) throws Exception {
// Local sync file
if (Files.notExists(filePath)) {
return null;
}
String name = String.valueOf(filePath.getFileName());
SyncFile syncFile =
addSyncFile(
null,
null,
null,
filePath.toString(),
Files.probeContentType(filePath),
name,
parentFolderId,
repositoryId,
SyncFile.STATE_SYNCED,
syncAccountId,
SyncFile.TYPE_FOLDER);
// Remote sync file
FileEventUtil.addFolder(parentFolderId, repositoryId, syncAccountId, name, syncFile);
return syncFile;
}
public static FileInfo pathToFileInfo(Path filePath, Path start) {
FileInfo fileInfo = new FileInfo();
if (!Files.exists(filePath)) {
fileInfo.setName("Unknown");
return fileInfo;
}
fileInfo.setName(start.relativize(filePath).toString());
if (Files.isDirectory(filePath)) {
fileInfo.setDir(true);
} else {
fileInfo.setDir(false);
try {
fileInfo.setSize(Files.size(filePath));
} catch (IOException e) {
fileInfo.setSize(0);
}
try {
fileInfo.setMimeType(Files.probeContentType(filePath));
} catch (IOException e) {
fileInfo.setMimeType("application/octet-stream");
}
if (fileInfo.getMimeType() == null) {
fileInfo.setMimeType("application/octet-stream");
}
}
return fileInfo;
}
public static SyncFile addFileSyncFile(
Path filePath, long folderId, long repositoryId, long syncAccountId) throws Exception {
// Local sync file
if (Files.notExists(filePath)) {
return null;
}
String checksum = FileUtil.getChecksum(filePath);
String name = String.valueOf(filePath.getFileName());
String mimeType = Files.probeContentType(filePath);
SyncFile syncFile =
addSyncFile(
null,
checksum,
null,
filePath.toString(),
mimeType,
name,
folderId,
repositoryId,
SyncFile.STATE_SYNCED,
syncAccountId,
SyncFile.TYPE_FILE);
// Remote sync file
FileEventUtil.addFile(
filePath, folderId, repositoryId, syncAccountId, checksum, name, mimeType, syncFile);
return syncFile;
}
public static String getFileMimeType(File f) {
String fileType = "application/octet-stream";
try {
fileType = Files.probeContentType(f.toPath());
System.out.println("Read File Type as " + fileType + " " + f.getName());
} catch (IOException e) {
// TODO Auto-generated catch block
fileType = "unknown";
}
return fileType;
}
public static String getMimeType(String fileName) {
try {
return Files.probeContentType(Paths.get(fileName));
} catch (IOException e) {
return "application/octet-stream";
}
/*
* Collection types = MimeUtil.getMimeTypes(fileName); return
* MimeUtil2.getMostSpecificMimeType(types).toString();
*/
}
@Override
public boolean accept(File file) {
if (file.isDirectory()) return true;
else {
try {
return Files.probeContentType(file.toPath()).indexOf("video") == 0;
} catch (IOException e) {
e.printStackTrace();
return false;
}
}
}
public String getAttachmentContentType(String defaultType, String filename) {
if (filename != null && fileContentTypes.containsKey(filename))
return fileContentTypes.get(filename);
File file = new File(filename);
String contentType = defaultType;
try {
contentType = Files.probeContentType(file.toPath());
} catch (IOException e) {
log.info("Failed to determine content type of attachment [" + filename + "]: ", e);
}
return contentType;
}
/**
* Get file mime type
*
* @param filepath
* @return mime filetype
*/
public String getMimeFileType(String filepath) {
try {
String mimeType = Files.probeContentType(new File(filepath).toPath());
if (mimeType == null) {
// handle special case when OS cannot detect file type
// get file extension
int i = filepath.lastIndexOf('.');
mimeType = filepath.substring(i + 1);
mimeType = "application/" + mimeType;
}
return mimeType;
} catch (IOException e) {
return null;
}
}
/** Process all events for the key queued to the watcher. */
void processEvents() {
for (; ; ) {
// wait for key to be signaled
WatchKey key;
try {
key = watcher.take();
} catch (InterruptedException x) {
return;
}
for (WatchEvent<?> event : key.pollEvents()) {
WatchEvent.Kind kind = event.kind();
if (kind == OVERFLOW) {
continue;
}
// The filename is the context of the event.
WatchEvent<Path> ev = (WatchEvent<Path>) event;
Path filename = ev.context();
// Verify that the new file is a text file.
try {
Path child = dir.resolve(filename);
if (!Files.probeContentType(child).equals("text/plain")) {
System.err.format("New file '%s' is not a plain text file.%n", filename);
continue;
}
} catch (IOException x) {
System.err.println(x);
continue;
}
// Email the file to the specified email alias.
System.out.format("Emailing file %s%n", filename);
}
// Reset the key -- this step is critical if you want to receive
// further watch events. If the key is no longer valid, the directory
// is inaccessible so exit the loop.
boolean valid = key.reset();
if (!valid) {
break;
}
}
}
public static String probeContentType(Path path) {
String mimeType = null;
try {
mimeType = Files.probeContentType(path);
} catch (IOException e) {
// if any exception they try Apache Tika, ignore this exception
// do nothing
}
if (null == mimeType || mimeType.trim().length() == 0) {
try {
mimeType = tika.detect(path.toFile());
} catch (IOException ex) {
Log.exception(ex);
throw new RuntimeException(ex);
}
}
return mimeType;
}
@GET
@Path("{url : .+}")
public Response get(@PathParam("url") String url) throws IOException {
java.nio.file.Path path = LocalImageCache.getInstance().resolveLocal(url);
if (!Files.isReadable(path) || Files.size(path) == 0) {
if (url.endsWith(".jpg")) {
String[] groups = RegExp.parseGroups(url, "([\\w]+)/([\\d]+)\\.[\\w]+");
if (groups != null) {
String type = groups[0];
Long downloadableId = Long.parseLong(groups[1]);
Downloadable instance = DownloadableFactory.getInstance().createInstance(downloadableId);
if (instance != null) {
FindDownloadableImageTask instanceTask =
DynamoObjectFactory.createInstance(FindDownloadableImageTask.class, instance);
if (instanceTask != null) {
BackLogProcessor.getInstance().schedule(instanceTask, false);
}
}
}
InputStream in = this.getClass().getResourceAsStream("/ring.svg");
return Response.ok(in).header("Content-Type", "image/svg+xml").build();
}
return Response.status(404).build();
} else {
Calendar calendar = Calendar.getInstance();
calendar.add(Calendar.DAY_OF_MONTH, 2);
InputStream in = Files.newInputStream(path, StandardOpenOption.READ);
return Response.ok(in)
.header("Content-Length", Files.size(path))
.header("Content-Type", Files.probeContentType(path))
.header("Expires", calendar.getTimeInMillis())
.build();
}
}
/** {@inheritDoc} */
@Override
public Message process(Message message) {
String directoryAsString = ExpressionUtils.evaluateNoFail(this.directory, message, "/");
File directory = new File(directoryAsString);
if (directory.isDirectory()) {
String fileAsString = ExpressionUtils.evaluateNoFail(this.filePath, message, "");
File file = new File(directory, fileAsString);
try {
FileInputStream io = new FileInputStream(file);
message.setPayload(IOUtils.toByteArray(io));
String contentType = Files.probeContentType(file.toPath());
message.putProperty(MessageUtils.FILE_BASE_PROPERTY + ".contentType", contentType);
} catch (IOException e) {
log.error("Error reading the file", e);
}
}
return message;
}
@Action(
value = "/viewResultFile",
results = {
@Result(name = "success", location = "/file_view.jsp"),
@Result(name = "error", location = "/file_view.jsp")
})
public String viewFileData() {
String uuid = getUuid();
String project = getProject();
if (absolutePath != null) {
try {
String realPath = context.getRealPath("/tmp-files");
String id = UUID.randomUUID().toString();
File dir = new File(realPath, id);
dir.mkdir();
String[] parentsArr = PortEnginUtils.convertAbsolutePathToArray(absolutePath, true, true);
fileName = PortEnginUtils.retrieveFileNameFromAbsolutePath(absolutePath);
InputStream is = jobMonitoringService.download(uuid, project, jobId, parentsArr, fileName);
File file = new File(dir, fileName);
PortEnginUtils.convertInputStreamToFile(is, file);
String mime = Files.probeContentType(file.toPath());
FileViewer viewer = FileViewerFactory.createFileViewer(mime);
relativePath = "tmp-files/" + id + "/" + fileName;
view = viewer.createView(relativePath);
file.deleteOnExit();
} catch (MonitoringServiceException e) {
PortEnginUtils.handleException(e, logger);
} catch (IOException e) {
PortEnginUtils.handleException(e, logger);
} catch (UserNotAuthorizedException e) {
PortEnginUtils.handleException(e, logger);
}
return SUCCESS;
}
close = true;
return ERROR;
}
/**
* Tell the kernel to stream a file as specified by {@code filename} directly from disk to the
* outgoing connection, bypassing userspace altogether (where supported by the underlying
* operating system. This is a very efficient way to serve files.
*
* <p>
*/
public HttpServerResponse sendFile(String filename) {
if (headWritten) {
throw new IllegalStateException("Head already written");
}
checkWritten();
File file = new File(filename);
if (!file.exists()) {
HttpResponse response = new DefaultHttpResponse(HTTP_1_1, HttpResponseStatus.NOT_FOUND);
writeFuture = conn.write(response);
} else {
HttpResponse response = new DefaultHttpResponse(HTTP_1_1, OK);
response.setHeader(Names.CONTENT_LENGTH, String.valueOf(file.length()));
try {
String contenttype = Files.probeContentType(Paths.get(filename));
if (contenttype != null) {
response.setHeader(Names.CONTENT_TYPE, contenttype);
}
} catch (IOException e) {
e.printStackTrace();
}
conn.write(response);
writeFuture = conn.sendFile(file);
}
// Close the non-keep-alive connection after the write operation is done.
if (!keepAlive) {
writeFuture.addListener(ChannelFutureListener.CLOSE);
}
headWritten = written = true;
conn.responseComplete();
return this;
}