489 lines
16 KiB
Java
489 lines
16 KiB
Java
package workers;
|
|
|
|
import GUI.SOMGUI;
|
|
import javafx.concurrent.Task;
|
|
import model.SOMConfig;
|
|
import model.SOMEvent;
|
|
import model.SOMImage;
|
|
import org.apache.commons.io.FileUtils;
|
|
import org.apache.commons.io.filefilter.DirectoryFileFilter;
|
|
import org.apache.commons.io.filefilter.TrueFileFilter;
|
|
|
|
import javax.activation.MimetypesFileTypeMap;
|
|
import java.io.File;
|
|
import java.io.IOException;
|
|
import java.net.InetSocketAddress;
|
|
import java.net.Socket;
|
|
import java.nio.file.*;
|
|
import java.util.ArrayList;
|
|
import java.util.Collection;
|
|
import java.util.List;
|
|
|
|
import static java.nio.file.StandardWatchEventKinds.*;
|
|
|
|
public class FilesWorker {
|
|
|
|
private static final SOMEvent event = SOMEvent.getInstance();
|
|
|
|
public FilesWorker() {
|
|
|
|
}
|
|
|
|
/**
|
|
* Returns true if a File is an image and returns false if not.
|
|
*
|
|
* @param path
|
|
* @return
|
|
*/
|
|
public static boolean isImage(Path path) {
|
|
File f = path.toFile();
|
|
String mimeType = new MimetypesFileTypeMap().getContentType(f);
|
|
String type = mimeType.split("/")[0];
|
|
return type.equals("image");
|
|
}
|
|
|
|
/**
|
|
* Returns the Path to the Source (direct from Camera) images directory, or
|
|
* if a File of one of the other Folders is given the Source File' Path
|
|
*
|
|
* @return
|
|
*/
|
|
public static File getSourcePath() {
|
|
File src = new File(SOMConfig.PICTURES_PATH.toString() + "/src");
|
|
|
|
// TODO catch possible fail
|
|
src.mkdirs();
|
|
return src;
|
|
}
|
|
|
|
/**
|
|
* Returns the Path to the Preview Images (Full Screen) images directory, or
|
|
* if a File of one of the other Folders is given the Preview File' Path
|
|
*
|
|
* @return
|
|
*/
|
|
public static File getPreviewPath() {
|
|
File prv = new File(SOMConfig.PICTURES_PATH.toString() + "/prv");
|
|
|
|
// TODO catch possible fail
|
|
prv.mkdirs();
|
|
return prv;
|
|
}
|
|
|
|
/**
|
|
* Returns the Path to the Thumbnail (Gallery) images directory, or if a
|
|
* File of one of the other Folders is given the Thumbnail File' Path
|
|
*
|
|
* @return
|
|
*/
|
|
public static File getThumbPath() {
|
|
File tmb = new File(SOMConfig.PICTURES_PATH.toString() + "/tmb");
|
|
|
|
// TODO catch possible fail
|
|
tmb.mkdirs();
|
|
return tmb;
|
|
}
|
|
|
|
/**
|
|
* Returns the Path to the Final images directory, or if a File of one of
|
|
* the other Folders is given the Final Files' Path
|
|
*
|
|
* @return
|
|
*/
|
|
public static File getFinalPath() {
|
|
File fnl = new File(SOMConfig.PICTURES_PATH.toString() + "/fnl");
|
|
|
|
// TODO catch possible fail
|
|
fnl.mkdirs();
|
|
return fnl;
|
|
}
|
|
|
|
/**
|
|
* Returns the Path to the Temporary (pre-source) images directory, or if a
|
|
* File of one of the other Folders is given the Thumbnail File' Path
|
|
*
|
|
* @return
|
|
*/
|
|
public static File getTempPath() {
|
|
File tmp = new File(SOMConfig.PICTURES_PATH.toString() + "/tmp");
|
|
|
|
// TODO catch possible fail
|
|
tmp.mkdirs();
|
|
return tmp;
|
|
}
|
|
|
|
private static boolean internet() {
|
|
|
|
Socket sock = new Socket();
|
|
InetSocketAddress socketAddress = new InetSocketAddress("google.com", 80);
|
|
|
|
try {
|
|
sock.connect(socketAddress, 3000);
|
|
System.out.println("Internet available");
|
|
return true;
|
|
} catch (IOException e) {
|
|
System.out.println("Internet NOT available");
|
|
return false;
|
|
} finally {
|
|
try {
|
|
sock.close();
|
|
} catch (IOException e) {
|
|
e.printStackTrace();
|
|
}
|
|
}
|
|
}
|
|
|
|
public static void upload() {
|
|
try {
|
|
|
|
// Get all Files in the image Folder
|
|
List<File> images = allFilesForUpload();
|
|
// Lists for either dirs or pictures
|
|
List<File> dirs = new ArrayList<File>();
|
|
List<File> pics = new ArrayList<File>();
|
|
|
|
// Check for internet connection
|
|
if (internet()) {
|
|
|
|
// Count Files and Dirs
|
|
|
|
// DIRS
|
|
String[] splits = SOMConfig.getEventPicDir().split("/");
|
|
String currentdir = "";
|
|
|
|
for (String split : splits) {
|
|
currentdir = currentdir + "/" + split;
|
|
dirs.add(new File(currentdir));
|
|
|
|
System.out.println("DIR added:" + currentdir);
|
|
}
|
|
|
|
// FILES
|
|
for (int i = 0; i < images.size(); i++) {
|
|
|
|
// get the current file
|
|
File file = images.get(i);
|
|
|
|
System.out.println(file);
|
|
|
|
// get pics
|
|
if (file.isFile()
|
|
&& file.toString().contains("src")) {
|
|
pics.add(file);
|
|
}
|
|
}
|
|
|
|
// REPORT TO CONSOLE
|
|
System.out.println(dirs.size() + " Directories");
|
|
System.out.println(pics.size() + " Pics");
|
|
|
|
int uploadeddirs = 0;
|
|
int uploadedfiles = 0;
|
|
|
|
// GET THE UI
|
|
SOMGUI.changetoupload();
|
|
|
|
// UPLOAD DIRECTORIES
|
|
List<File> limitdirs = new ArrayList<File>();
|
|
|
|
for (File dir : dirs) {
|
|
|
|
uploadeddirs++;
|
|
|
|
System.out.println("Queueing Directories " + dir.toString());
|
|
limitdirs.add(dir);
|
|
if (limitdirs.size() >= SOMConfig.PARALLEL_UPLOADS
|
|
// Upload even if limit is not reached
|
|
|| (dirs.size() - uploadeddirs) < SOMConfig.PARALLEL_UPLOADS) {
|
|
|
|
System.out.println("Launch Dir upload");
|
|
uploadDir(limitdirs);
|
|
|
|
System.out.println("Clear Queue");
|
|
limitdirs.clear();
|
|
}
|
|
}
|
|
|
|
// UPLOAD FILES
|
|
List<File> limitpics = new ArrayList<File>();
|
|
for (File pic : pics
|
|
) {
|
|
|
|
uploadedfiles++;
|
|
|
|
System.out.println("Queueing File " + pic.toString());
|
|
limitpics.add(pic);
|
|
|
|
if (limitpics.size() >= SOMConfig.PARALLEL_UPLOADS
|
|
// Upload even if limit is not reached
|
|
|| (pics.size() - uploadedfiles) < SOMConfig.PARALLEL_UPLOADS) {
|
|
|
|
System.out.println("Launch File upload");
|
|
uploadFile(limitpics);
|
|
|
|
System.out.println("Clear File Queue");
|
|
limitpics.clear();
|
|
}
|
|
}
|
|
|
|
SOMGUI.changetopicture();
|
|
}
|
|
} catch (IOException e) {
|
|
e.printStackTrace();
|
|
} catch (InterruptedException e) {
|
|
// TODO Auto-generated catch block
|
|
e.printStackTrace();
|
|
} catch (Exception e) {
|
|
e.printStackTrace();
|
|
}
|
|
}
|
|
|
|
private static void uploadFile(final List<File> files) throws Exception {
|
|
final Thread[] threads = new Thread[files.size()];
|
|
|
|
for (int i = 0; i < threads.length; i++) {
|
|
|
|
System.out.println("LAUNCH Upload Process: " + i);
|
|
|
|
final File file = files.get(i);
|
|
final String target = "https://cloud.selfomat.de/remote.php/webdav/" + SOMConfig.getEventPicDir() + "/" + file.getName();
|
|
|
|
System.out.println(file.toString());
|
|
System.out.println("----------->");
|
|
System.out.println(target);
|
|
System.out.println("");
|
|
System.out.println("");
|
|
|
|
final int pictureCounter = i + 1;
|
|
Task<Boolean> task = new Task<Boolean>() {
|
|
|
|
@Override
|
|
protected Boolean call() throws Exception {
|
|
// build the upload process
|
|
// TODO remove -k option (this option skips certificate verification)
|
|
ProcessBuilder builder = new ProcessBuilder(
|
|
"bash",
|
|
"SELFOMAT/sh/upload.sh",
|
|
file.toString(),
|
|
target,
|
|
SOMConfig.CLOUD_CREDENTIALS
|
|
);
|
|
|
|
// make the process traceable
|
|
builder.redirectErrorStream(true);
|
|
// launch upload process
|
|
Process process = builder.start();
|
|
|
|
// wait for the process to end
|
|
if (process.waitFor() == 0) {
|
|
// process ended successful
|
|
System.out.println("file uploaded: " + file);
|
|
|
|
// TODO get the length of all threads
|
|
// TODO bind to UI
|
|
updateProgress(pictureCounter, threads.length);
|
|
|
|
return true;
|
|
|
|
} else {
|
|
// process ended failing
|
|
// TODO Catch failed uploads
|
|
System.out.println("process ended failing " + file);
|
|
Thread.sleep(1000);
|
|
return false;
|
|
}
|
|
}
|
|
};
|
|
|
|
SOMGUI.uploadCtl.pictureProgressBar.progressProperty().bind(task.progressProperty());
|
|
|
|
threads[i] = new Thread(task);
|
|
threads[i].setDaemon(true);
|
|
threads[i].start();
|
|
}
|
|
int i = 0;
|
|
while (i < threads.length) {
|
|
threads[i].join();
|
|
i++;
|
|
}
|
|
//TODO Catch fails
|
|
}
|
|
|
|
private static void uploadDir(final List<File> dirs) throws Exception {
|
|
|
|
final Thread[] threads = new Thread[dirs.size()];
|
|
for (int i = 0; i < threads.length; i++) {
|
|
|
|
System.out.println("launch mkdir Process: " + i);
|
|
|
|
final File dir = dirs.get(i);
|
|
final int directoryCounter = i + 1;
|
|
Task<Boolean> task = new Task<Boolean>() {
|
|
|
|
@Override
|
|
protected Boolean call() throws Exception {
|
|
// build the Upload process with curl
|
|
// TODO remove -k option (this option skips certificate verification)
|
|
ProcessBuilder builder = new ProcessBuilder("curl",
|
|
"-u",
|
|
"upload:geheim",
|
|
"-X",
|
|
"MKCOL",
|
|
"https://cloud.selfom.at/remote.php/webdav/" + SOMConfig.getEventPicDir(),
|
|
// dir.toString().replace("/src", ""),
|
|
"-k");
|
|
|
|
// make the process traceable
|
|
builder.redirectErrorStream(true);
|
|
|
|
// launch upload process
|
|
Process process = builder.start();
|
|
|
|
// wait for the process to end
|
|
if (process.waitFor() == 0) {
|
|
// Process ended successful
|
|
System.out.println("directory made: " + dir);
|
|
|
|
//Set upload Progress
|
|
// TODO get the length of all threads
|
|
// TODO bind to UI
|
|
updateProgress(directoryCounter, threads.length);
|
|
return true;
|
|
|
|
} else {
|
|
// Process ended failing
|
|
System.out.println("process ended failing " + dir);
|
|
return false;
|
|
}
|
|
}
|
|
};
|
|
|
|
SOMGUI.uploadCtl.folderProgressBar.progressProperty().bind(task.progressProperty());
|
|
|
|
// Start the Task
|
|
threads[i] = new Thread(task);
|
|
threads[i].setDaemon(true);
|
|
threads[i].start();
|
|
} // End of loop
|
|
|
|
// Join the tasks
|
|
int i = 0;
|
|
while (i < threads.length) {
|
|
threads[i].join();
|
|
i++;
|
|
}
|
|
|
|
//TODO Catch upload fails
|
|
}
|
|
|
|
private static List<File> allFilesForUpload() {
|
|
|
|
File dir = SOMConfig.PICTURES_PATH;
|
|
|
|
Collection filesAndDirs = FileUtils.listFilesAndDirs(dir, TrueFileFilter.INSTANCE, DirectoryFileFilter.DIRECTORY);
|
|
|
|
return new ArrayList<File>(filesAndDirs);
|
|
}
|
|
|
|
// TODO static??
|
|
public static SOMImage waitForImageAndCapture() {
|
|
//Behandelt
|
|
try {
|
|
|
|
// Set the Source Path to be watched
|
|
Path dir = getSourcePath().toPath();
|
|
|
|
// REGISTER WATCH SERVICE
|
|
WatchService watcher = FileSystems.getDefault().newWatchService();
|
|
dir.register(watcher, ENTRY_CREATE, ENTRY_DELETE, ENTRY_MODIFY);
|
|
|
|
System.out.println("Watch Service registered for dir: "
|
|
+ dir.getFileName());
|
|
|
|
// TRIGGER THE CAPTURE
|
|
System.out.println("START CAPTURE THREAD");
|
|
SOMImage newImage = CaptureWorker.now();
|
|
|
|
while (true) {
|
|
|
|
WatchKey key;
|
|
|
|
try {
|
|
key = watcher.take();
|
|
} catch (InterruptedException ex) {
|
|
return newImage;
|
|
}
|
|
|
|
for (WatchEvent<?> event : key.pollEvents()) {
|
|
WatchEvent.Kind<?> kind = event.kind();
|
|
|
|
@SuppressWarnings("unchecked")
|
|
WatchEvent<Path> ev = (WatchEvent<Path>) event;
|
|
Path fileName = ev.context();
|
|
|
|
System.out.println(kind.name() + ": " + fileName);
|
|
// check for a file being created
|
|
if (
|
|
// Make sure there is an Image created
|
|
kind == ENTRY_CREATE
|
|
// Check that filename is the same as expected image
|
|
&& fileName.toString().equals(
|
|
newImage.getSrc().getName())) {
|
|
|
|
//Set the Progress Indicator to 0.5
|
|
SOMGUI.captureCtl.pictureLoadIndicator.setProgress(0.5);
|
|
|
|
// START THE "PICTURE HAS ARRIVED" ACTION
|
|
System.out.println("The image is there!!!");
|
|
|
|
// ADD THE IMAGE TO THE EVENT
|
|
FilesWorker.event.addImage(newImage);
|
|
|
|
// Set last Image
|
|
System.out.println("Set the taken Picture to UI");
|
|
FilesWorker.event.createAndSetImage(FilesWorker.event.getLastImage());
|
|
|
|
// Hide the Progress Indicator
|
|
SOMGUI.captureCtl.pictureLoadIndicator.setVisible(false);
|
|
// Set back the Progress Indicator
|
|
SOMGUI.captureCtl.pictureLoadIndicator.setProgress(-1);
|
|
|
|
//Close Watcher
|
|
watcher.close();
|
|
} else if (
|
|
// Make sure there is an Image created
|
|
kind == ENTRY_CREATE
|
|
// Check that filename is the same as expected image
|
|
&& !fileName.toString().equals(
|
|
newImage.getSrc().getName())) {
|
|
// TODO Catch wrong pictures, only for testing
|
|
// Hide the Progress Indicator
|
|
SOMGUI.captureCtl.pictureLoadIndicator.setVisible(false);
|
|
// Set back the Progress Indicator
|
|
SOMGUI.captureCtl.pictureLoadIndicator.setProgress(-1);
|
|
|
|
//Close Watcher
|
|
watcher.close();
|
|
}
|
|
|
|
}
|
|
|
|
|
|
boolean valid = key.reset();
|
|
if (!valid) {
|
|
break;
|
|
}
|
|
}
|
|
|
|
// return the new image
|
|
newImage.updateImageState();
|
|
return newImage;
|
|
|
|
} catch (IOException ex) {
|
|
System.err.println(ex);
|
|
return null;
|
|
}
|
|
|
|
}
|
|
}
|