diff --git a/src/ftp/ClientConnection.java b/src/ftp/ClientConnection.java
deleted file mode 100644
index ccf66feb2aa48040ac918f0348f56fff6bd105b9..0000000000000000000000000000000000000000
--- a/src/ftp/ClientConnection.java
+++ /dev/null
@@ -1,4 +0,0 @@
-package ftp;
-
-public class ClientConnection extends Connection {
-}
diff --git a/src/ftp/Connection.java b/src/ftp/Connection.java
deleted file mode 100644
index a9933b00d478be2b4370bdf30552b8c71d7fd951..0000000000000000000000000000000000000000
--- a/src/ftp/Connection.java
+++ /dev/null
@@ -1,4 +0,0 @@
-package ftp;
-
-public abstract class Connection {
-}
diff --git a/src/ftp/Controller.java b/src/ftp/Controller.java
index 695a828f24e977dcc99e494d712a4ffc1dfbfd3d..2b690a2b8d02f83b57f9f6e811684370706667f5 100644
--- a/src/ftp/Controller.java
+++ b/src/ftp/Controller.java
@@ -2,6 +2,7 @@ package ftp;
import java.io.IOException;
import java.net.InetSocketAddress;
+import java.net.Socket;
import java.nio.ByteBuffer;
import java.nio.channels.*;
import java.util.*;
@@ -13,6 +14,8 @@ public class Controller extends Server {
int r;
int rbPeriod;
+ private ArrayList<DstoreConnection> index;
+
/**
* @desc constructs a controller
@@ -27,9 +30,7 @@ public class Controller extends Server {
this.timeout = timeout;
this.rbPeriod = rbPeriod;
- allocateBufferBytes(256);
-
- openSelector();
+ start();
}
@@ -48,13 +49,21 @@ public class Controller extends Server {
@Override
- protected void handleRequest(String request, SelectionKey key) {
+ protected void handleRequest(String request) {
String args[] = request.split(" ");
switch(args[0]) {
case "JOIN":
- key.attach(new DstoreConnection(new Index(), Integer.parseInt(args[1])));
- sendMessage("LIST",key);
+ new DstoreConnection(new Index(), Integer.parseInt(args[1]));
+
+ Socket dstoreSocket = null;
+ try { dstoreSocket = new Socket("localhost",Integer.parseInt(args[1])); }
+ catch (IOException e) { System.err.println("Error: " + e); };
+
+ send("LIST", dstoreSocket);
+
+ System.out.println(readSocket(dstoreSocket));
+
break;
}
}
diff --git a/src/ftp/Dstore.java b/src/ftp/Dstore.java
index 18735c1e675407e5f42afb2816e6185d755e467a..901a5335cd9ff1efa7087007281d1cd7a60c0741 100644
--- a/src/ftp/Dstore.java
+++ b/src/ftp/Dstore.java
@@ -7,6 +7,7 @@ import ftp.Server;
import java.io.File;
import java.io.IOException;
import java.net.InetSocketAddress;
+import java.net.Socket;
import java.net.SocketException;
import java.nio.ByteBuffer;
import java.nio.channels.SelectionKey;
@@ -21,7 +22,7 @@ public class Dstore extends Server {
int cport;
String file_folder;
- private static SocketChannel toController;
+ private Socket controller;
/**
@@ -37,34 +38,14 @@ public class Dstore extends Server {
this.timeout = timeout;
this.file_folder = file_folder;
+ controller = new Socket("localhost",cport);
- // opening connection to controller
- // open(addr) acts as convenience method for open() and connect()
- // in blocking mode, so will wait for response before progressing
- //
- try {
- toController = SocketChannel.open(new InetSocketAddress(cport));
- toController.configureBlocking(false);
- } catch (IOException e) {
- e.printStackTrace();
- }
-
-
- allocateBufferBytes(256);
+ send("JOIN " + port, controller);
- sendMessage("JOIN " + port, toController);
-
- openSelector(new SocketChannel[] {toController});
+ start();
}
- /*
- buffer.flip(); //resets pos to 0 to read from buffer and sets limit to what was put there
- client.write(buffer);
- buffer.clear(); //empties buffer and clears, ready for writing
- */
-
-
public static void main(String args[]) {
String numberArgs[] = Arrays.copyOf(args, args.length-1);
Stream<String> str = Arrays.stream(numberArgs);
@@ -91,17 +72,19 @@ public class Dstore extends Server {
@Override
- protected void handleRequest(String request, SelectionKey key) {
+ protected void handleRequest(String request) {
String args[] = request.split(" ");
switch(args[0]) {
case "LIST":
File folder = new File("storage");
String[] files = folder.list();
+
String fileNames = Arrays.stream(files)
.reduce("", (file1, file2) -> file1 + " " + file2);
- sendMessage(fileNames, key);
+ send(fileNames, controller);
+
break;
}
}
diff --git a/src/ftp/DstoreConnection.java b/src/ftp/DstoreConnection.java
index 3acf37c83fdd982581ed83a6f69e0c60db29bd49..fbc3f2ec70cd3a84a98050966919ddb29254d47d 100644
--- a/src/ftp/DstoreConnection.java
+++ b/src/ftp/DstoreConnection.java
@@ -1,6 +1,6 @@
package ftp;
-public class DstoreConnection extends Connection {
+public class DstoreConnection {
private Index file_index;
private int port;
diff --git a/src/ftp/Server.java b/src/ftp/Server.java
index 2794745e0ca4bb2469a98506c05b210b9c13143c..8ea0c44c74b3801b8b09334e4815bd6322e19f1b 100644
--- a/src/ftp/Server.java
+++ b/src/ftp/Server.java
@@ -1,250 +1,84 @@
package ftp;
-import java.io.IOException;
-import java.net.InetSocketAddress;
-import java.net.Socket;
-import java.nio.ByteBuffer;
-import java.nio.channels.*;
-import java.util.Arrays;
-import java.util.Iterator;
-import java.util.Set;
+import java.io.*;
+import java.net.*;
public abstract class Server {
protected int port;
protected int timeout;
- protected Selector selector;
- private ByteBuffer buffer;
-
- protected void allocateBufferBytes(int bytes) {
- buffer = ByteBuffer.allocate(bytes); //buffer to read/write
- }
-
-
- /**
- * @desc abstract method which handles server requests based on implmentation
- * @param request request to be handled
- * @param key corresponding key
- */
- protected abstract void handleRequest(String request, SelectionKey key);
-
-
- /**
- * @desc starts the selector and begins the server loop
- * @throws IOException
- */
- protected void openSelector() throws IOException {
- selector = Selector.open();
- ServerSocketChannel serverSocket = ServerSocketChannel.open();
- serverSocket.bind(new InetSocketAddress(port));
- serverSocket.configureBlocking(false);
- serverSocket.register(selector, SelectionKey.OP_ACCEPT);
-
- System.out.println("Selector Started");
-
- while (true) {
- selector.select();
- Set<SelectionKey> selectedKeys = selector.selectedKeys();
- Iterator<SelectionKey> iter = selectedKeys.iterator();
- while (iter.hasNext()) {
-
- SelectionKey key = iter.next();
-
- if (key.isAcceptable()) {
- System.out.println("Server socket ready to accept connection");
- register(selector, serverSocket);
- }
-
- if (key.isConnectable()) {
- System.out.println("Channel is ready to connect to the server");
- }
-
- if (key.isReadable()) {
- System.out.println("Channel has data to be read");
- String request = takeRequest(key);
- handleRequest(request, key);
- }
-
- iter.remove();
- }
- }
- }
-
-
- /**
- * @desc starts the selector and begins the server loop, registers given initial channels
- * @param channels initial channels to be registered with the selector
- * @throws IOException
- */
- protected void openSelector(SocketChannel[] channels) throws IOException{
- selector = Selector.open();
- ServerSocketChannel serverSocket = ServerSocketChannel.open();
- serverSocket.bind(new InetSocketAddress(port));
- serverSocket.configureBlocking(false);
-
- serverSocket.register(selector, SelectionKey.OP_ACCEPT);
- Iterator<SocketChannel> sockIt = Arrays.stream(channels).iterator();
- while (sockIt.hasNext()) {
- SocketChannel channel = sockIt.next();
- channel.register(selector, SelectionKey.OP_READ | SelectionKey.OP_WRITE);
- }
-
- buffer = ByteBuffer.allocate(256); //buffer to read/write
-
- System.out.println("Selector Started");
-
- while (true) {
- selector.select();
- Set<SelectionKey> selectedKeys = selector.selectedKeys();
- Iterator<SelectionKey> iter = selectedKeys.iterator();
- while (iter.hasNext()) {
-
- SelectionKey key = iter.next();
-
- if (key.isAcceptable()) {
- System.out.println("Server socket ready to accept connection");
- register(selector, serverSocket);
- }
-
- if (key.isConnectable()) {
- System.out.println("Channel is ready to connect to the server");
- }
-
- if (key.isReadable()) {
- System.out.println("Channel has data to be read");
- String request = takeRequest(key);
- handleRequest(request, key);
+ protected void start() {
+ try {
+ ServerSocket ss = new ServerSocket(port);
+ while (true) {
+ try {
+ System.out.println("Waiting for Connection...");
+ final Socket client = ss.accept();
+ new Thread(new Runnable() {
+ public void run() {
+ try {
+ System.out.println("Connection Accepted");
+ String request = readSocket(client);
+ System.out.println("Recieved: " + request);
+ handleRequest(request);
+ client.close();
+ } catch (Exception e) {}
+ }
+ }).start();
+ } catch (Exception e) {
+ System.out.println("error " + e);
}
-
- iter.remove();
}
+ } catch (Exception e) {
+ System.out.println("error " + e);
}
}
- /**
- * @desc registers a newly accepted channel with the selector
- * @param selector selector to be registered with
- * @param serverSocket server socket which accepts the connection
- * @throws IOException
- */
- protected void register(Selector selector, ServerSocketChannel serverSocket) throws IOException {
- SocketChannel client = serverSocket.accept();
- System.out.println("Channel accepted");
- client.configureBlocking(false);
- client.register(selector, SelectionKey.OP_READ);
- }
-
-
- /**
- * @desc reads request from buffer
- * @param key key linking to the channel
- * @return returns the request
- * @throws IOException
- */
- protected String takeRequest(SelectionKey key) throws IOException {
- SocketChannel client = (SocketChannel) key.channel();
- client.read(buffer);
- String request = new String(buffer.array()).trim();
- System.out.println("Received: " + request);
- return request;
- }
+ protected abstract void handleRequest(String request);
- /**
- * @desc sends a message using a given key and waits for a response
- * @param msg message to be sent
- * @param key key of corresponding channel to send message through
- * @param buffer buffer to r/w messages
- * @return
- */
- protected String sendMessageResponse(String msg, SelectionKey key, ByteBuffer buffer) {
- buffer = ByteBuffer.wrap(msg.getBytes());
-
- SocketChannel channel = (SocketChannel) key.channel();
-
- String response = null;
+ protected void send(String msg, Socket socket) {
try {
- channel.write(buffer);
- buffer.clear();
- System.out.println("Sent message: " + msg);
-
- channel.read(buffer);
- response = new String(buffer.array()).trim();
- } catch (IOException e) {
- e.printStackTrace();
+ PrintWriter out = new PrintWriter(socket.getOutputStream());
+ out.println(msg);
+ out.flush();
+ System.out.println("Sent: " + msg);
}
-
- return response;
- }
-
-
- /**
- * @desc sends a message using a given channel and waits for a response
- * @param msg message to be sent
- * @param channel channel to send message through
- * @param buffer buffer to r/w messages
- * @return
- */
- protected String sendMessageResponse(String msg, SocketChannel channel, ByteBuffer buffer) {
- buffer = ByteBuffer.wrap(msg.getBytes());
-
- String response = null;
- try {
- channel.write(buffer);
- buffer.clear();
- System.out.println("Sent message: " + msg);
-
- channel.read(buffer);
- response = new String(buffer.array()).trim();
- } catch (IOException e) {
- e.printStackTrace();
+ catch (IOException e) {
+ System.err.println("Error: " + e);
}
-
- return response;
}
- /**
- * @desc sends a message using a given key, does not wait for a response
- * @param msg message to be sent
- * @param key key of corresponding channel to send message through
- * @return
- */
- protected void sendMessage(String msg, SelectionKey key) {
- buffer = ByteBuffer.wrap(msg.getBytes());
-
- SocketChannel channel = (SocketChannel) key.channel();
-
+ protected void send(String msg, String hostname, int port) {
try {
- channel.write(buffer);
- buffer.clear();
- System.out.println("Sent message: " + msg);
- } catch (IOException e) {
- e.printStackTrace();
+ Socket socket = new Socket(hostname, port);
+ PrintWriter out = new PrintWriter(socket.getOutputStream());
+ out.println(msg);
+ out.flush();
+ System.out.println("Sent: " + msg);
+ }
+ catch (IOException e) {
+ System.err.println("Error: " + e);
}
}
- /**
- * @desc sends a message using a given channel, does not wait for a response
- * @param msg message to be sent
- * @param channel channel to send message through
- * @return
- */
- protected void sendMessage(String msg, SocketChannel channel) {
- buffer = ByteBuffer.wrap(msg.getBytes());
+ protected String readSocket(Socket socket) {
+ String request = null;
try {
- channel.write(buffer);
- buffer.clear();
- System.out.println("Sent message: " + msg);
- } catch (IOException e) {
- e.printStackTrace();
+ BufferedReader in = new BufferedReader(new InputStreamReader(socket.getInputStream()));
+ request = in.readLine();
+ }
+ catch (IOException e) {
+ System.err.println("Error: " + e);
}
- }
+ return request;
+ }
-}
+}
\ No newline at end of file
diff --git a/testingWithClient/Client.java b/testingWithClient/Client.java
new file mode 100644
index 0000000000000000000000000000000000000000..b32fb25f42df3677e7483fda83e27d856e8c44e1
--- /dev/null
+++ b/testingWithClient/Client.java
@@ -0,0 +1,81 @@
+package ftp;
+
+import java.io.IOException;
+import java.net.InetSocketAddress;
+import java.nio.ByteBuffer;
+import java.nio.channels.SocketChannel;
+import java.util.Arrays;
+import java.util.List;
+import java.util.Scanner;
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
+
+public class Client {
+
+ int cport;
+ int timeout;
+
+ private static SocketChannel client;
+ private static ByteBuffer buffer;
+ private static Client instance;
+
+
+ /**
+ * @desc constructs a client
+ * @param cport controller port to talk to
+ * @param timeout timeout (ms)
+ */
+ public Client(int cport, int timeout) {
+ this.cport = cport;
+ this.timeout = timeout;
+
+ try {
+ client = SocketChannel.open(new InetSocketAddress(cport));
+ buffer = ByteBuffer.allocate(256);
+ } catch (IOException e) {
+ e.printStackTrace();
+ }
+ }
+
+
+ public String sendMessage(String msg) {
+ buffer = ByteBuffer.wrap(msg.getBytes());
+ String response = null;
+ try {
+ client.write(buffer);
+ buffer.clear();
+ client.read(buffer);
+ response = new String(buffer.array()).trim();
+ buffer.clear();
+ } catch (IOException e) {
+ e.printStackTrace();
+ }
+ return response;
+
+ }
+
+
+ public static void main(String args[]) {
+ Stream<String> str = Arrays.stream(args);
+
+ List<Integer> intArgs = str.map(x -> {return Integer.parseInt(x);})
+ .collect(Collectors.toList());
+
+ instance = new Client(intArgs.get(0),intArgs.get(1));
+
+ Scanner scanner = new Scanner(System.in);
+ String command = "";
+
+ while (!command.equals("QUIT")) {
+
+ System.out.println("Enter Command:");
+ command = scanner.nextLine();
+
+ String response = instance.sendMessage(command);
+
+ System.out.println("Response: " + response);
+
+ }
+ }
+
+}
diff --git a/testingWithClient/ClientMain.java b/testingWithClient/ClientMain.java
new file mode 100644
index 0000000000000000000000000000000000000000..5c530f6f02e669ef4808ad6565f7b16c21583718
--- /dev/null
+++ b/testingWithClient/ClientMain.java
@@ -0,0 +1,85 @@
+import java.io.File;
+import java.io.IOException;
+
+public class ClientMain {
+
+ public static void main(String[] args) {
+
+ int cport = -1;
+ int timeout = -1;
+ try {
+ // parse arguments
+ cport = Integer.parseInt(args[0]);
+ timeout = Integer.parseInt(args[1]);
+ } catch (NumberFormatException e) {
+ System.err.println("Error parsing arguments: " + e.getMessage());
+ System.err.println("Expected: java ClientMain cport timeout");
+ System.exit(-1);
+ }
+
+ File downloadFolder = new File("downloads");
+ if (!downloadFolder.exists())
+ if (!downloadFolder.mkdir()) throw new RuntimeException("Cannot create download folder (folder absolute path: " + downloadFolder.getAbsolutePath() + ")");
+
+ testClient(cport, timeout, downloadFolder);
+
+ // example to launch a number of concurrent clients, each doing the same operations
+ /*for (int i = 0; i < 10; i++) {
+ new Thread() {
+ public void run() {
+ testClient(cport, timeout, downloadFolder);
+ }
+ }.start();
+ }*/
+ }
+
+ public static void testClient(int cport, int timeout, File downloadFolder) {
+ Client client = null;
+
+ try {
+
+ client = new Client(cport, timeout, Logger.LoggingType.ON_FILE_AND_TERMINAL);
+
+ try { client.connect(); } catch(IOException e) { e.printStackTrace(); return; }
+
+ try { list(client); } catch(IOException e) { e.printStackTrace(); }
+
+ try { client.store(new File("Clipboard01.pdf")); } catch(IOException e) { e.printStackTrace(); }
+
+ try { client.store(new File("Clipboard01.pdf")); } catch(IOException e) { e.printStackTrace(); }
+
+ try { client.store(new File("Clipboard01.jpg")); } catch(IOException e) { e.printStackTrace(); }
+
+ String list[] = null;
+ try { list = list(client); } catch(IOException e) { e.printStackTrace(); }
+
+ if (list != null)
+ for (String filename : list)
+ try { client.load(filename, downloadFolder); } catch(IOException e) { e.printStackTrace(); }
+
+ if (list != null)
+ for (String filename : list)
+ try { client.remove(filename); } catch(IOException e) { e.printStackTrace(); }
+ try { client.remove(list[0]); } catch(IOException e) { e.printStackTrace(); }
+
+ try { list(client); } catch(IOException e) { e.printStackTrace(); }
+
+ } finally {
+ if (client != null)
+ try { client.disconnect(); } catch(Exception e) { e.printStackTrace(); }
+ }
+ }
+
+ public static String[] list(Client client) throws IOException, NotEnoughDstoresException {
+ System.out.println("Retrieving list of files...");
+ String list[] = client.list();
+
+ System.out.println("Ok, " + list.length + " files:");
+ int i = 0;
+ for (String filename : list)
+ System.out.println("[" + i++ + "] " + filename);
+
+ return list;
+ }
+
+}
diff --git a/testingWithClient/Controller.java b/testingWithClient/Controller.java
new file mode 100644
index 0000000000000000000000000000000000000000..04da24d427b1aa300731ba8c58131761a6d31a1e
--- /dev/null
+++ b/testingWithClient/Controller.java
@@ -0,0 +1,68 @@
+package ftp;
+
+import java.io.IOException;
+import java.net.InetSocketAddress;
+import java.net.Socket;
+import java.nio.ByteBuffer;
+import java.nio.channels.*;
+import java.util.*;
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
+
+public class Controller extends Server {
+
+ int r;
+ int rbPeriod;
+
+ private ArrayList<DstoreConnection> index;
+
+
+ /**
+ * @desc constructs a controller
+ * @param cport to listen on
+ * @param r replication factor
+ * @param timeout timeout (ms)
+ * @param rbPeriod rebalance period (ms)
+ */
+ public Controller(int cport, int r, int timeout, int rbPeriod) throws IOException {
+ this.port = cport;
+ this.r = r;
+ this.timeout = timeout;
+ this.rbPeriod = rbPeriod;
+
+ start();
+ }
+
+
+ public static void main(String args[]) {
+ Stream<String> str = Arrays.stream(args);
+
+ List<Integer> intArgs = str.map(x -> {return Integer.parseInt(x);})
+ .collect(Collectors.toList());
+
+ try {
+ Controller ctrl = new Controller(intArgs.get(0), intArgs.get(1), intArgs.get(2), intArgs.get(3));
+ } catch (IOException e) {
+ System.out.println("IOException " + e.getMessage());
+ }
+ }
+
+
+ @Override
+ protected void handleRequest(String request, Socket socket) {
+ String args[] = request.split(" ");
+
+ switch(args[0]) {
+ case "JOIN":
+ new DstoreConnection(new Index(), Integer.parseInt(args[1]));
+
+ try { send("LIST",socket); }
+ catch (Exception e) {
+ System.err.println("Error: " + e);
+ }
+
+ break;
+ }
+ }
+
+}
\ No newline at end of file
diff --git a/testingWithClient/Dstore.java b/testingWithClient/Dstore.java
new file mode 100644
index 0000000000000000000000000000000000000000..9c031e372a53840af15356303d41aa1a34c99272
--- /dev/null
+++ b/testingWithClient/Dstore.java
@@ -0,0 +1,98 @@
+package ftp;
+
+import ftp.DstoreConnection;
+import ftp.Index;
+import ftp.Server;
+
+import java.io.File;
+import java.io.IOException;
+import java.net.InetSocketAddress;
+import java.net.Socket;
+import java.net.SocketException;
+import java.nio.ByteBuffer;
+import java.nio.channels.SelectionKey;
+import java.nio.channels.SocketChannel;
+import java.util.Arrays;
+import java.util.List;
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
+
+public class Dstore extends Server {
+
+ int cport;
+ String file_folder;
+
+ private static SocketChannel toController;
+
+
+ /**
+ * @desc constructs a client
+ * @param port port to listen on
+ * @param cport controller port to talk to
+ * @param timeout timeout (ms)
+ * @param file_folder where to store data locally
+ */
+ public Dstore(int port, int cport, int timeout, String file_folder) throws IOException{
+ this.port = port;
+ this.cport = cport;
+ this.timeout = timeout;
+ this.file_folder = file_folder;
+
+ Socket ctrlSocket = new Socket("localhost",cport);
+
+ try {send("JOIN " + port, ctrlSocket);}
+ catch (Exception e) {
+ System.err.println("Error: " + e);
+ }
+
+ start();
+ }
+
+
+ public static void main(String args[]) {
+ String numberArgs[] = Arrays.copyOf(args, args.length-1);
+ Stream<String> str = Arrays.stream(numberArgs);
+
+ List<Integer> intArgs = str.map(x -> {return Integer.parseInt(x);})
+ .collect(Collectors.toList());
+
+ try {
+ Dstore dstore = new Dstore(intArgs.get(0), intArgs.get(1), intArgs.get(2), args[3]);
+ } catch (IOException e) {
+ System.out.println("IOException " + e.getMessage());
+ }
+ }
+
+
+// /**
+// * @desc lists the files of the datastore
+// * @return
+// */
+// private File[] list() {
+// File folder = new File("./storage");
+// return folder.listFiles();
+// }
+
+
+ @Override
+ protected void handleRequest(String request, Socket socket) {
+ String args[] = request.split(" ");
+
+ switch(args[0]) {
+ case "LIST":
+ File folder = new File("storage");
+ String[] files = folder.list();
+
+ String fileNames = Arrays.stream(files)
+ .reduce("", (file1, file2) -> file1 + " " + file2);
+
+ try {send(fileNames, socket);}
+ catch (Exception e) {
+ System.err.println("Error: " + e);
+ }
+
+ break;
+ }
+ }
+
+}
diff --git a/testingWithClient/DstoreConnection.java b/testingWithClient/DstoreConnection.java
new file mode 100644
index 0000000000000000000000000000000000000000..fbc3f2ec70cd3a84a98050966919ddb29254d47d
--- /dev/null
+++ b/testingWithClient/DstoreConnection.java
@@ -0,0 +1,14 @@
+package ftp;
+
+public class DstoreConnection {
+
+ private Index file_index;
+ private int port;
+
+
+ public DstoreConnection(Index file_index, int port) {
+ this.file_index = file_index;
+ this.port = port;
+ }
+
+}
diff --git a/testingWithClient/DstoreFile.java b/testingWithClient/DstoreFile.java
new file mode 100644
index 0000000000000000000000000000000000000000..2d79a776368e3761320119a5774360630d782a95
--- /dev/null
+++ b/testingWithClient/DstoreFile.java
@@ -0,0 +1,11 @@
+package ftp;
+
+public class DstoreFile {
+ private String filename;
+ private int filesize;
+
+ public DstoreFile(String filename, int filesize) {
+ this.filename = filename;
+ this.filesize = filesize;
+ }
+}
diff --git a/testingWithClient/Index.java b/testingWithClient/Index.java
new file mode 100644
index 0000000000000000000000000000000000000000..7537564a4da24e10e2a66825b11c396c964ed67c
--- /dev/null
+++ b/testingWithClient/Index.java
@@ -0,0 +1,26 @@
+package ftp;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class Index {
+
+ private ArrayList<DstoreFile> files = new ArrayList<DstoreFile>();
+
+
+ public Index() {}
+
+ public Index(List<DstoreFile> files) {
+ this.files = new ArrayList<DstoreFile>(files);
+ }
+
+
+ public void addFile(String filename, int filesize) {
+ files.add(new DstoreFile(filename,filesize));
+ }
+
+ public ArrayList<DstoreFile> getIndex() {
+ return files;
+ }
+
+}
diff --git a/testingWithClient/Server.java b/testingWithClient/Server.java
new file mode 100644
index 0000000000000000000000000000000000000000..aa93c5a8311e049b9ad1286e7a58142ce1261a48
--- /dev/null
+++ b/testingWithClient/Server.java
@@ -0,0 +1,49 @@
+package ftp;
+
+import java.io.*;
+import java.net.*;
+
+public abstract class Server {
+
+ protected int port;
+ protected int timeout;
+
+
+ protected void start() {
+ try {
+ ServerSocket ss = new ServerSocket(port);
+ while (true) {
+ try {
+ final Socket client = ss.accept();
+ new Thread(new Runnable() {
+ public void run() {
+ try {
+ BufferedReader in = new BufferedReader(new InputStreamReader(client.getInputStream()));
+ String request = in.readLine();
+ System.out.println("Recieved: " + request);
+ handleRequest(request, client);
+ client.close();
+ } catch (Exception e) {}
+ }
+ }).start();
+ } catch (Exception e) {
+ System.out.println("error " + e);
+ }
+ }
+ } catch (Exception e) {
+ System.out.println("error " + e);
+ }
+ }
+
+
+ protected abstract void handleRequest(String request, Socket socket);
+
+
+ protected void send(String msg, Socket socket) throws Exception {
+ PrintWriter out = new PrintWriter(socket.getOutputStream());
+ out.println(msg);
+ out.flush();
+ System.out.println("Sent: " + msg);
+ }
+
+}
\ No newline at end of file
diff --git a/testingWithClient/client-1.0.1.jar b/testingWithClient/client-1.0.1.jar
new file mode 100644
index 0000000000000000000000000000000000000000..4502bd2181f7d90077ecb50b7c616e435d098ce3
Binary files /dev/null and b/testingWithClient/client-1.0.1.jar differ