Add mulithreaded UDP client
parent
e46be57b8c
commit
733767c4de
@ -0,0 +1,297 @@
|
||||
package clientP2P;
|
||||
import java.util.List;
|
||||
import java.util.ArrayList;
|
||||
import java.net.DatagramSocket;
|
||||
import protocolP2P.ProtocolP2PPacketUDP;
|
||||
import protocolP2P.Payload;
|
||||
import protocolP2P.LoadRequest;
|
||||
import protocolP2P.FilePart;
|
||||
import exception.InternalError;
|
||||
import remoteException.EmptyDirectory;
|
||||
import remoteException.EmptyFile;
|
||||
import exception.ProtocolError;
|
||||
import remoteException.InternalRemoteError;
|
||||
import remoteException.VersionRemoteError;
|
||||
import exception.TransmissionError;
|
||||
import remoteException.ProtocolRemoteError;
|
||||
import exception.VersionError;
|
||||
import exception.SizeError;
|
||||
import remoteException.NotFound;
|
||||
import java.nio.file.Files;
|
||||
import java.io.File;
|
||||
import java.nio.file.Paths;
|
||||
import java.io.IOException;
|
||||
|
||||
/** Class to download file parts on udp.
|
||||
* @author Louis Royer
|
||||
* @author Flavien Haas
|
||||
* @author JS Auge
|
||||
* @version 1.0
|
||||
*/
|
||||
public class ClientDownloadPartUDP implements Runnable {
|
||||
|
||||
private List<Long> toDoTasks;
|
||||
private List<Long> pendingTasks;
|
||||
private List<Long> tasksDone;
|
||||
private volatile boolean tasksListsLock;
|
||||
private volatile boolean stop;
|
||||
private volatile boolean failed;
|
||||
private String filename;
|
||||
private DatagramSocket socket;
|
||||
private volatile boolean noTask;
|
||||
private String partsSubdir;
|
||||
private static final long MAX_PARTIAL_SIZE = 4096;
|
||||
|
||||
/** Constructor with filename, socket, and part subdir
|
||||
* @param filename name of file to download
|
||||
* @param socket socket to use
|
||||
* @param partsSubdir directory to store .part files
|
||||
*/
|
||||
public ClientDownloadPartUDP(String filename, DatagramSocket socket, String partsSubdir) {
|
||||
this.partsSubdir = partsSubdir;
|
||||
this.filename = filename;
|
||||
this.socket = socket;
|
||||
stop = false;
|
||||
failed = false;
|
||||
pendingTasks = new ArrayList<>();
|
||||
toDoTasks = new ArrayList<>();
|
||||
tasksDone = new ArrayList<>();
|
||||
noTask = true;
|
||||
tasksListsLock = false;
|
||||
}
|
||||
|
||||
/** True if thread has failed to get a file.
|
||||
* @return true if thread has failed to get a file
|
||||
*/
|
||||
public boolean hasFailed() {
|
||||
return failed;
|
||||
}
|
||||
|
||||
/** Asks to stop thread.
|
||||
* @throws InterruptedException
|
||||
*/
|
||||
public synchronized void setStop() throws InterruptedException {
|
||||
stop = true;
|
||||
this.notifyAll();
|
||||
}
|
||||
|
||||
/** Runnable implementation */
|
||||
public void run() {
|
||||
while(!stop) {
|
||||
try {
|
||||
doTasks();
|
||||
} catch(InterruptedException e) {
|
||||
try {
|
||||
setStop();
|
||||
} catch (InterruptedException e2) {
|
||||
}
|
||||
}
|
||||
}
|
||||
System.err.println("Closing socket");
|
||||
socket.close();
|
||||
}
|
||||
|
||||
/** Get list of offsets that have not be downloaded if failed, else
|
||||
* empty list.
|
||||
* @return list of offsets
|
||||
*/
|
||||
public List<Long> getFailed() {
|
||||
List<Long> ret = new ArrayList<>();
|
||||
if (failed) {
|
||||
ret.addAll(pendingTasks);
|
||||
ret.addAll(toDoTasks);
|
||||
}
|
||||
return ret;
|
||||
}
|
||||
|
||||
/** Get list of downloaded file parts offset, then clear this list.
|
||||
* @return list of offsets
|
||||
* @throws InterruptedException
|
||||
*/
|
||||
public List<Long> getDone() throws InterruptedException {
|
||||
if (tasksDone.size() == 0) {
|
||||
return new ArrayList<>();
|
||||
} else {
|
||||
synchronized (this) {
|
||||
while(tasksListsLock) {
|
||||
this.wait();
|
||||
}
|
||||
tasksListsLock = true;
|
||||
List<Long> ret = new ArrayList<>(tasksDone);
|
||||
tasksDone.clear();
|
||||
tasksListsLock = false;
|
||||
this.notifyAll();
|
||||
return ret;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/** Adds offset of files parts to download.
|
||||
* @param task offset to download
|
||||
* @throws InterruptedException
|
||||
*/
|
||||
public synchronized void assignTask(Long task) throws InterruptedException {
|
||||
synchronized(this) {
|
||||
while(tasksListsLock) {
|
||||
this.wait();
|
||||
}
|
||||
tasksListsLock = true;
|
||||
toDoTasks.add(task);
|
||||
noTask = false;
|
||||
tasksListsLock = false;
|
||||
this.notifyAll();
|
||||
}
|
||||
}
|
||||
|
||||
/** Send one request and wait for one response. Blocks when no task.
|
||||
* @throws InterruptedException
|
||||
*/
|
||||
public synchronized void doTasks() throws InterruptedException {
|
||||
while(noTask && !stop) {
|
||||
this.wait();
|
||||
}
|
||||
if (!stop) {
|
||||
try {
|
||||
Long offset = toDoTasks.get(0);
|
||||
ProtocolP2PPacketUDP p = reqPart(offset);
|
||||
if (p == null) {
|
||||
stop = true;
|
||||
}
|
||||
|
||||
failed = downloadPart(p);
|
||||
if (failed) {
|
||||
System.err.println("Error: DownloadPart failed.");
|
||||
stop = true;
|
||||
} else if (toDoTasks.isEmpty()) {
|
||||
noTask = true;
|
||||
}
|
||||
} catch (IndexOutOfBoundsException e) {
|
||||
noTask = true;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
public ProtocolP2PPacketUDP reqPart(Long offset) {
|
||||
System.err.println("New request: "+ offset);
|
||||
// maintain tracking of tasks
|
||||
if (toDoTasks.contains(offset)) {
|
||||
try {
|
||||
synchronized (this) {
|
||||
while(tasksListsLock) {
|
||||
this.wait();
|
||||
}
|
||||
tasksListsLock = true;
|
||||
toDoTasks.remove(offset);
|
||||
pendingTasks.add(offset);
|
||||
tasksListsLock = false;
|
||||
this.notifyAll();
|
||||
}
|
||||
} catch(InterruptedException e) {
|
||||
System.err.println("Error: reqPart interruptedException");
|
||||
return null;
|
||||
}
|
||||
} else {
|
||||
System.err.println("Error: reqPart (offset " + offset + " not in toDoTasks)");
|
||||
return null;
|
||||
}
|
||||
// send request
|
||||
try {
|
||||
ProtocolP2PPacketUDP d = new ProtocolP2PPacketUDP((Payload) new LoadRequest(filename, offset.longValue(), MAX_PARTIAL_SIZE));
|
||||
d.sendRequest((Object)socket);
|
||||
return d;
|
||||
} catch (InternalError e) {
|
||||
System.err.println("Error: reqPart internalError");
|
||||
return null;
|
||||
} catch (IOException e) {
|
||||
e.printStackTrace();
|
||||
System.err.println("Error: reqPart ioexception");
|
||||
return null;
|
||||
}
|
||||
}
|
||||
|
||||
public boolean downloadPart(ProtocolP2PPacketUDP d) {
|
||||
if (d == null) {
|
||||
System.err.println("Error: downloadPart -> d is null.");
|
||||
return true;
|
||||
}
|
||||
try {
|
||||
Payload p = d.receiveResponse().getPayload();
|
||||
assert p instanceof FilePart : "This payload must be instance of FilePart";
|
||||
if (!(p instanceof FilePart)) {
|
||||
System.err.println("Error: cannot get size.");
|
||||
return true;
|
||||
} else {
|
||||
FilePart fp = (FilePart)p;
|
||||
if (!fp.getFilename().equals(filename)) {
|
||||
System.err.println("Error: wrong file received: `" + fp.getFilename() + "`");
|
||||
return true;
|
||||
}
|
||||
Long offset = Long.valueOf(fp.getOffset());
|
||||
if (pendingTasks.contains(offset)) {
|
||||
try {
|
||||
Files.write(new File(partsSubdir + filename + "_" + offset + ".part").toPath(), fp.getPartialContent());
|
||||
} catch (IOException e) {
|
||||
System.err.println("Error: cannot write file (" + partsSubdir + filename + "_" + offset + ".part)");
|
||||
}
|
||||
} else {
|
||||
System.err.println("Error: wrong file part received.");
|
||||
return true;
|
||||
}
|
||||
try {
|
||||
synchronized(this) {
|
||||
while(tasksListsLock) {
|
||||
this.wait();
|
||||
}
|
||||
tasksListsLock = true;
|
||||
pendingTasks.remove(offset);
|
||||
tasksDone.add(offset);
|
||||
tasksListsLock = false;
|
||||
this.notifyAll();
|
||||
}
|
||||
} catch(InterruptedException e) {
|
||||
System.err.println("Error: DownloadPart Interrupted exception");
|
||||
return true;
|
||||
}
|
||||
}
|
||||
} catch (EmptyDirectory e) {
|
||||
System.err.println("Error: empty directory.");
|
||||
return true;
|
||||
} catch (EmptyFile e) {
|
||||
System.err.println("Error: downloadPart emptyFile");
|
||||
// TODO: use more specific errors
|
||||
return true;
|
||||
} catch (ProtocolError e) {
|
||||
System.err.println("Error: downloadPart protocolError");
|
||||
return true;
|
||||
} catch (InternalRemoteError e) {
|
||||
System.err.println("Error: downloadPart internalRemoteError");
|
||||
return true;
|
||||
} catch (VersionRemoteError e) {
|
||||
System.err.println("Error: downloadPart versionRemoteError");
|
||||
return true;
|
||||
} catch (ProtocolRemoteError e) {
|
||||
System.err.println("Error: downloadPart protocolRemoteError");
|
||||
return true;
|
||||
} catch (TransmissionError e) {
|
||||
System.err.println("Error: downloadPart transmissionError");
|
||||
return true;
|
||||
} catch (VersionError e) {
|
||||
System.err.println("Error: downloadPart versionError");
|
||||
return true;
|
||||
} catch (SizeError e) {
|
||||
System.err.println("Error: downloadPart sizeError");
|
||||
return true;
|
||||
} catch (NotFound e) {
|
||||
System.err.println("Error: downloadPart notFound");
|
||||
return true;
|
||||
} catch (IOException e) {
|
||||
System.err.println("Error: downloadPart ioexception");
|
||||
return true;
|
||||
} catch (InternalError e) {
|
||||
System.err.println("Error: downloadPart internalError");
|
||||
return true;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
}
|
||||
@ -0,0 +1,372 @@
|
||||
package clientP2P;
|
||||
import clientP2P.ClientDownloadPartUDP;
|
||||
import tools.HostItem;
|
||||
import java.util.List;
|
||||
import java.util.ArrayList;
|
||||
import java.util.Arrays;
|
||||
import java.util.Random;
|
||||
import remoteException.EmptyDirectory;
|
||||
import remoteException.EmptyFile;
|
||||
import remoteException.VersionRemoteError;
|
||||
import remoteException.ProtocolRemoteError;
|
||||
import remoteException.NotFound;
|
||||
import remoteException.InternalRemoteError;
|
||||
import protocolP2P.HashAlgorithm;
|
||||
import protocolP2P.HashResponse;
|
||||
import protocolP2P.HashRequest;
|
||||
import protocolP2P.ProtocolP2PPacketUDP;
|
||||
import protocolP2P.Payload;
|
||||
import exception.ProtocolError;
|
||||
import exception.InternalError;
|
||||
import exception.TransmissionError;
|
||||
import exception.SizeError;
|
||||
import exception.VersionError;
|
||||
import protocolP2P.FilePart;
|
||||
import protocolP2P.LoadRequest;
|
||||
import java.io.IOException;
|
||||
import java.nio.file.Files;
|
||||
import java.io.File;
|
||||
import java.nio.file.Paths;
|
||||
import java.nio.file.StandardOpenOption;
|
||||
import java.nio.file.StandardCopyOption;
|
||||
|
||||
/** Class to download file from udp
|
||||
* @author Louis Royer
|
||||
* @author Flavien Haas
|
||||
* @author JS Auge
|
||||
* @version 1.0
|
||||
*/
|
||||
public class ClientDownloadUDP implements Runnable {
|
||||
|
||||
private List<HostItem> hostList;
|
||||
private String filename;
|
||||
private byte[] hash512;
|
||||
private List<ClientDownloadPartUDP> sockList = new ArrayList<ClientDownloadPartUDP>();
|
||||
private List<Long> offsetsToAsk = new ArrayList<Long>();
|
||||
private List<Long> offsetsPending = new ArrayList<Long>();
|
||||
private boolean stop;
|
||||
private long size;
|
||||
private static final long MAX_PARTIAL_SIZE = 4096;
|
||||
private String partsSubdir;
|
||||
private String dirStorage;
|
||||
private boolean success = false;
|
||||
|
||||
/** Constructor with parameters: filename, list of hosts, parts subdirectory and dirStorage
|
||||
* @param filename name of file to download
|
||||
* @param hostList list of servers
|
||||
* @param partsSubdir directory to store .part files
|
||||
* @param dirStorage directory to write assembled file
|
||||
*/
|
||||
public ClientDownloadUDP(String filename, List<HostItem> hostList, String partsSubdir, String dirStorage) {
|
||||
this.partsSubdir = partsSubdir;
|
||||
this.dirStorage = dirStorage;
|
||||
this.filename = filename;
|
||||
this.hostList = hostList;
|
||||
this.stop = false;
|
||||
}
|
||||
|
||||
/** Asks thread to stop
|
||||
*/
|
||||
public void setStop() {
|
||||
stop = true;
|
||||
}
|
||||
|
||||
/** Runnable implementation
|
||||
*/
|
||||
public void run() {
|
||||
try {
|
||||
init();
|
||||
if (stop) {
|
||||
System.err.println("File is smaller than part max size.");
|
||||
hostList.get(0).closeUDPSocket();
|
||||
} else {
|
||||
System.err.println("File is bigger than part max size.");
|
||||
purgeList();
|
||||
initThreads();
|
||||
while(!stop) {
|
||||
checkTasksStatus();
|
||||
assignTasks();
|
||||
}
|
||||
}
|
||||
System.err.println("Reassembling file parts.");
|
||||
reassembleFile();
|
||||
} catch(InternalError e) {
|
||||
System.err.println("Error while downloading file. Aborting.");
|
||||
} finally {
|
||||
stopTasks();
|
||||
}
|
||||
}
|
||||
|
||||
/** Starts threads for each server in hostList.
|
||||
*/
|
||||
private void initThreads() {
|
||||
for(HostItem hostItem: hostList) {
|
||||
sockList.add(new ClientDownloadPartUDP(filename, hostItem.getUDPSocket(), partsSubdir));
|
||||
}
|
||||
for(ClientDownloadPartUDP c: sockList) {
|
||||
Thread t = new Thread(c);
|
||||
t.start();
|
||||
}
|
||||
System.err.println("Threads initialized");
|
||||
}
|
||||
|
||||
/** Remove tasks from failed threads. Update done status.
|
||||
* @throws InternalError
|
||||
*/
|
||||
private void checkTasksStatus() throws InternalError {
|
||||
List<ClientDownloadPartUDP> sockListCpy = new ArrayList<>(sockList);
|
||||
for(ClientDownloadPartUDP c: sockListCpy) {
|
||||
if (c.hasFailed() == true) {
|
||||
sockList.remove(c);
|
||||
offsetsPending.removeAll(c.getFailed());
|
||||
offsetsToAsk.addAll(c.getFailed());
|
||||
}
|
||||
try {
|
||||
offsetsPending.removeAll(c.getDone());
|
||||
} catch (InterruptedException e) {
|
||||
throw new InternalError();
|
||||
}
|
||||
}
|
||||
System.err.println("Task check status: " + offsetsToAsk.size() + " to asks, " + offsetsPending.size() + " pending");
|
||||
if (offsetsToAsk.isEmpty() && offsetsPending.isEmpty()) {
|
||||
stop = true;
|
||||
}
|
||||
if (sockList.size() == 0) {
|
||||
System.err.println("No thread working");
|
||||
throw new InternalError();
|
||||
}
|
||||
}
|
||||
|
||||
/** Assign tasks randomly to threads.
|
||||
* @throws InternalError
|
||||
*/
|
||||
private void assignTasks() throws InternalError {
|
||||
Random rand = new Random();
|
||||
for(long offset : offsetsToAsk) {
|
||||
try {
|
||||
sockList.get(rand.nextInt(sockList.size())).assignTask(offset);
|
||||
offsetsPending.add(offset);
|
||||
System.err.println("Assigned task "+ offset);
|
||||
} catch(InterruptedException e) {
|
||||
throw new InternalError();
|
||||
}
|
||||
}
|
||||
offsetsToAsk.removeAll(offsetsPending);
|
||||
}
|
||||
|
||||
/** Stop threads */
|
||||
private void stopTasks() {
|
||||
for(ClientDownloadPartUDP c : sockList) {
|
||||
try {
|
||||
c.setStop();
|
||||
} catch (InterruptedException e) {}
|
||||
}
|
||||
}
|
||||
|
||||
/** Get hashsum from server.
|
||||
* @param hostItem server to ask hash
|
||||
* @return hash512sum
|
||||
* @throws InternalError
|
||||
*/
|
||||
private byte[] getHashSum512(HostItem hostItem) throws InternalError {
|
||||
byte[] hash;
|
||||
HashAlgorithm[] hashesAlgo = new HashAlgorithm[1];
|
||||
hashesAlgo[0] = HashAlgorithm.SHA512;
|
||||
ProtocolP2PPacketUDP d = new ProtocolP2PPacketUDP((Payload) new HashRequest(filename, hashesAlgo));
|
||||
try {
|
||||
d.sendRequest((Object)hostItem.getUDPSocket());
|
||||
try {
|
||||
Payload pHash = d.receiveResponse().getPayload();
|
||||
assert pHash instanceof HashResponse : "This payload must be instance of HashResponse";
|
||||
if (!(pHash instanceof HashResponse)) {
|
||||
throw new InternalError();
|
||||
} else {
|
||||
hash = ((HashResponse)pHash).getHash(HashAlgorithm.SHA512);
|
||||
}
|
||||
} catch (EmptyDirectory e) {
|
||||
hash = new byte[0];
|
||||
} catch (NotFound e) {
|
||||
hash = new byte[0];
|
||||
// TODO: use more specific errors
|
||||
} catch (EmptyFile e) {
|
||||
throw new InternalError();
|
||||
} catch (ProtocolError e) {
|
||||
throw new InternalError();
|
||||
} catch (InternalRemoteError e) {
|
||||
throw new InternalError();
|
||||
} catch (VersionRemoteError e) {
|
||||
throw new InternalError();
|
||||
} catch (ProtocolRemoteError e) {
|
||||
throw new InternalError();
|
||||
} catch (TransmissionError e) {
|
||||
throw new InternalError();
|
||||
} catch (VersionError e) {
|
||||
throw new InternalError();
|
||||
} catch (SizeError e) {
|
||||
throw new InternalError();
|
||||
}
|
||||
return hash;
|
||||
} catch (IOException e) {
|
||||
throw new InternalError();
|
||||
}
|
||||
}
|
||||
|
||||
/** Removes servers not owning the correct file to download from list.
|
||||
* This is done by comparing hash512sum.
|
||||
* @throws InternalError
|
||||
*/
|
||||
private void purgeList() throws InternalError {
|
||||
List<HostItem> blackList = new ArrayList<HostItem>();
|
||||
boolean first = false;
|
||||
byte[] hashsum;
|
||||
for(HostItem host: hostList) {
|
||||
// already have hashsum from 1st server
|
||||
if (!first) {
|
||||
first = true;
|
||||
continue;
|
||||
}
|
||||
// ask hashsum
|
||||
hashsum = getHashSum512(host);
|
||||
if (!Arrays.equals(hash512, hashsum)) {
|
||||
blackList.add(host);
|
||||
}
|
||||
}
|
||||
// purge list
|
||||
for(HostItem host: blackList) {
|
||||
hostList.remove(host);
|
||||
}
|
||||
System.err.println("Host list purge: done");
|
||||
}
|
||||
|
||||
/** Getter for hash512sum
|
||||
* @return hash512sum
|
||||
*/
|
||||
public byte[] getHashSum512() {
|
||||
return hash512;
|
||||
}
|
||||
|
||||
/** Initialize infos about file to download (size, hash512sum, partslist to dl).
|
||||
* Also download first partfile (to get size).
|
||||
* @throws InternalError
|
||||
*/
|
||||
private void init() throws InternalError {
|
||||
// get size
|
||||
setSize();
|
||||
|
||||
// get hashsum from 1st server in list
|
||||
hash512 = getHashSum512(hostList.get(0));
|
||||
if (hash512.length == 0) {
|
||||
System.err.println("Error: no hash512sum support.");
|
||||
throw new InternalError();
|
||||
}
|
||||
|
||||
// Add tasks
|
||||
if (!stop) {
|
||||
for(long i=MAX_PARTIAL_SIZE; i<size;i+=MAX_PARTIAL_SIZE) {
|
||||
offsetsToAsk.add(Long.valueOf(i));
|
||||
}
|
||||
System.err.println("Adding tasks: done");
|
||||
}
|
||||
}
|
||||
|
||||
/** Set size of file to download. Also download first file part.
|
||||
* @throws InternalError
|
||||
*/
|
||||
private void setSize() throws InternalError {
|
||||
ProtocolP2PPacketUDP d = new ProtocolP2PPacketUDP((Payload) new LoadRequest(filename, 0, MAX_PARTIAL_SIZE));
|
||||
try {
|
||||
d.sendRequest((Object)hostList.get(0).getUDPSocket());
|
||||
try {
|
||||
Payload p = d.receiveResponse().getPayload();
|
||||
assert p instanceof FilePart : "This payload must be instance of FilePart";
|
||||
if (!(p instanceof FilePart)) {
|
||||
System.err.println("Error: cannot get size.");
|
||||
throw new InternalError();
|
||||
} else {
|
||||
FilePart fp = (FilePart)p;
|
||||
if (!fp.getFilename().equals(filename)) {
|
||||
System.err.println("Error: wrong file received: `" + fp.getFilename() + "`");
|
||||
throw new ProtocolError();
|
||||
}
|
||||
if (fp.getOffset() == 0) {
|
||||
try {
|
||||
Files.write(new File(partsSubdir + filename + "_0.part").toPath(), fp.getPartialContent());
|
||||
} catch (IOException e) {
|
||||
System.err.println("Error: cannot write file (" + partsSubdir + filename + "_0.part)");
|
||||
}
|
||||
size = fp.getTotalSize();
|
||||
if (fp.getPartialContent().length == size) {
|
||||
stop = true;
|
||||
}
|
||||
} else {
|
||||
System.err.println("Error: wrong file part received.");
|
||||
throw new InternalError();
|
||||
}
|
||||
}
|
||||
} catch (EmptyDirectory e) {
|
||||
System.err.println("Error: empty directory.");
|
||||
throw new InternalError();
|
||||
} catch (EmptyFile e) {
|
||||
// TODO: use more specific errors
|
||||
throw new InternalError();
|
||||
} catch (ProtocolError e) {
|
||||
throw new InternalError();
|
||||
} catch (InternalRemoteError e) {
|
||||
throw new InternalError();
|
||||
} catch (VersionRemoteError e) {
|
||||
throw new InternalError();
|
||||
} catch (ProtocolRemoteError e) {
|
||||
throw new InternalError();
|
||||
} catch (TransmissionError e) {
|
||||
throw new InternalError();
|
||||
} catch (VersionError e) {
|
||||
throw new InternalError();
|
||||
} catch (SizeError e) {
|
||||
throw new InternalError();
|
||||
} catch (NotFound e) {
|
||||
throw new InternalError();
|
||||
}
|
||||
} catch (IOException e) {
|
||||
throw new InternalError();
|
||||
}
|
||||
}
|
||||
|
||||
/** Success getter.
|
||||
* @return true when file have successfully been reassembled.
|
||||
*/
|
||||
public boolean getSuccess() {
|
||||
return success;
|
||||
}
|
||||
|
||||
private void reassembleFile() {
|
||||
boolean firstPart = true;
|
||||
boolean abort = false;
|
||||
long nextOffset = 0;
|
||||
do {
|
||||
if (firstPart) {
|
||||
System.err.println("Reassembling: First part");
|
||||
try {
|
||||
// create file
|
||||
Files.copy(new File(partsSubdir + filename + "_" + nextOffset + ".part").toPath(), new File(dirStorage + filename).toPath(), StandardCopyOption.REPLACE_EXISTING);
|
||||
nextOffset = (new File(dirStorage + filename)).length();
|
||||
firstPart = false;
|
||||
} catch (IOException e) {
|
||||
System.err.println("Reassembling: aborting on first part");
|
||||
abort = true;
|
||||
}
|
||||
} else if (nextOffset >= size) {
|
||||
success = true;
|
||||
System.err.println("Reassembling: success");
|
||||
} else {
|
||||
// append to file
|
||||
try {
|
||||
Files.write(new File(dirStorage + filename).toPath(), Files.readAllBytes(new File(partsSubdir + filename + "_" + nextOffset + ".part").toPath()), StandardOpenOption.APPEND);
|
||||
nextOffset = (new File(dirStorage + filename)).length();
|
||||
} catch (IOException e) {
|
||||
abort = true;
|
||||
System.err.println("Aborting: bad number " + nextOffset);
|
||||
}
|
||||
}
|
||||
} while((!success) && (!abort));
|
||||
}
|
||||
}
|
||||
Loading…
Reference in New Issue