public void WhenEmptyFileListSent_ShouldBeReceivedAsEmptyFileList() { using(ServerInstance server = new ServerInstance(_settings)) { server.Connect(); using(ClientInstance client = new ClientInstance(_settings)) { client.Connect(); } } }
public ServerForm() { InitializeComponent(); _settings = new AppSettings(); //Default values _settings.Port = 1234; _settings.ServerAddress = IPAddress.Parse("127.0.0.1"); _settings.ServerIsRemote = false; _instance = new ServerInstance(_settings); _instance.ConnectionMade += new EventHandler(_instance_ConnectionMade); _instance.ConnectionTerminated += new EventHandler(_instance_ConnectionTerminated); LoadControls(); LoadMenu(); SetupForConnection(); }
public void WhenClientConnectsToServer_AddsFiles_ClientShouldFireFilesUpdateEvent() { using (ServerInstance server = new ServerInstance(_settings)) { server.Connect(); using (ClientInstance client = new ClientInstance(_settings)) { client.FileListUpdateReceived += new EventHandler<FileListModificationEventArgs>(client_FileListUpdated); client.Connect(); client.AddFiles(_existingFiles); DateTime then = DateTime.Now; while (!_fileListUpdateReceived && (DateTime.Now - then).TotalSeconds < 1) ; Assert.IsTrue(_fileListUpdateReceived); } } }
public void WhenFileIsRequestedFromClient_FileExists_FileInitiatedEventShouldFire() { bool fileListUpdateReceived = false; bool fullFileListReceived = false; bool fileTransferInitiatedEventReceived = false; _fileListUpdateCallback = new Action(delegate() { fileListUpdateReceived = true; }); _fullFileListReceivedCallback = new Action(delegate() { fullFileListReceived = true; }); _fileTransferInitiatedCallback = new Action(delegate() { fileTransferInitiatedEventReceived = true; }); using (ServerInstance server = new ServerInstance(_settings)) { server.Connect(); using (ClientInstance clientOwning = new ClientInstance(_settings, "Owning Client")) { clientOwning.FileListUpdateReceived += new EventHandler<FileListModificationEventArgs>(client_FileListUpdateReceived); clientOwning.Connect(); clientOwning.AddFiles(_existingFiles); using (ClientInstance clientRequesting = new ClientInstance(_settings, "Requesting Client")) { clientRequesting.FullFileListReceived += new EventHandler<FileListEventArgs>(client_FullFileListReceived); clientRequesting.FileTransferInitiated += new EventHandler<FileTransferEventArgs>(client_FileTransferInitiated); clientRequesting.Connect(); DateTime then = DateTime.Now; while (!fullFileListReceived && (DateTime.Now - then).TotalSeconds < 1) ; Assert.IsTrue(fullFileListReceived); clientRequesting.RequestFile(_existingFiles[1]); then = DateTime.Now; while (!fileTransferInitiatedEventReceived && (DateTime.Now - then).TotalSeconds < 60) ; Assert.IsTrue(fileTransferInitiatedEventReceived); } } } }
public LoggingControl(ServerInstance server, AppSettings settings) : this() { Settings = settings; Server = server; }
public static void Main(string[] args) { AppSettings settings = new AppSettings(); settings.ClientConnectionTimeout = 10000; if (!LoadSettings(settings, args)) { Console.WriteLine("Bad or no parameters given"); Console.WriteLine("Usage: Knock -a[ipaddress] -p[port]"); return; } _localClient = new ClientInstance(settings); _localClient.LostConnection += new EventHandler<ObviousCode.Interlace.BitTunnelLibrary.Events.ExceptionEventArgs>(_localClient_LostConnection); _localClient.ConnectionMade += new EventHandler(_localClient_ConnectionMade); _localClient.ConnectionTerminated += new EventHandler(_localClient_ConnectionTerminated); Console.Write ("Starting Server ... "); _server = new ServerInstance(settings); _server.ConnectionMade += new EventHandler(_server_ConnectionMade); _server.ConnectionTerminated += new EventHandler(_server_ConnectionTerminated); _server.LostConnection += new EventHandler<ObviousCode.Interlace.BitTunnelLibrary.Events.ExceptionEventArgs>(_server_LostConnection); _server.Connect(); Console.WriteLine(); Console.WriteLine ("Server started"); Console.WriteLine(); LoadCommands(); MountedFileCache.Cache.Client = _localClient; MountedFileCache.Cache.Server = _server; MountedFileCache.Cache.PromptRequested += new EventHandler(Cache_PromptRequested); try { Console.Write ("Preparing local client ... "); if (!_localClient.Connect()) { Console.WriteLine("Unable to connect ..."); Console.WriteLine("Stopping ..."); Console.WriteLine("Bye"); Console.ReadLine(); return; } } catch (Exception e) { Console.WriteLine ("Unable to prepare locale client: {0}", e.Message); Console.ReadLine(); Console.WriteLine("Bye"); return; } _currentPath = "/"; Console.WriteLine(); Console.WriteLine("Welcome. Type \"quit\" to exit"); Console.WriteLine(); string line = ""; Console.Write(Cursor); while(true) { if (_forceQuit) break; line = Console.ReadLine(); if (line == string.Empty) { Console.Write(Cursor); continue; } if (line == "quit") { ConsoleKeyInfo response; do { Console.WriteLine(); Console.Write("Quit? (Y/N)"); response = Console.ReadKey(); } while (response.Key != ConsoleKey.Y && response.Key != ConsoleKey.N); if (response.Key == ConsoleKey.Y) { break; } else { Console.WriteLine(); Console.Write(Cursor); continue; } } try { ParseCommand(line); } catch (Exception e) { Console.WriteLine ("System Error: {0}", e.Message); } Console.Write(Cursor); } _server.Dispose(); _localClient.Dispose(); Console.WriteLine("Bye"); }
public void WhenFilesAddedLocally_AndSomeRemovedLocally_OnlyRemovedFilesShouldBeRemovedFromLocalFiles() { using (ServerInstance server = new ServerInstance(_settings)) { server.Connect(); using (ClientInstance client = new ClientInstance(_settings)) { client.Connect(); client.AddFiles(_existingFiles); client.RemoveFiles(new FileDescriptor[]{_existingFiles[0], _existingFiles[2]} ); Assert.AreEqual(1, client.LocalFiles.UniqueFileCount); Assert.AreEqual(1, client.LocalFiles.FileInstanceCount); Assert.IsTrue(client.LocalFiles.Contains(_existingFiles[1])); } } }
public void WhenFirstClientConnectsToServer_AddsFiles_SecondClientAddsSameFiles_FirstClientRemovesOneFile_ClientsShouldHaveOneInstanceOfAllFiles() { using(ServerInstance server = new ServerInstance(_settings)) { server.Connect(); using(ClientInstance client = new ClientInstance(_settings, "Client 1")) { client.Connect(); client.FileListUpdateReceived+=new EventHandler<FileListModificationEventArgs>(client_FileListUpdated); client.AddFiles(_existingFiles); DateTime then = DateTime.Now; while (!_fileListUpdateReceived && (DateTime.Now - then).TotalSeconds < 1) ; Assert.IsTrue(_fileListUpdateReceived); client.FileListUpdateReceived -= new EventHandler<FileListModificationEventArgs>(client_FileListUpdated); _fileListUpdateReceived = false; using (ClientInstance client2 = new ClientInstance(_settings, "Client 2")) { client2.Connect(); client2.FileListUpdateReceived += new EventHandler<FileListModificationEventArgs>(client_FileListUpdated); client2.AddFiles(_existingFiles); then = DateTime.Now; while (!_fileListUpdateReceived && (DateTime.Now - then).TotalSeconds < 1) ; Assert.IsTrue(_fileListUpdateReceived); _fileListUpdateReceived = false; client.RemoveFiles( new FileDescriptor[] { _existingFiles[1] } ); then = DateTime.Now; while (!_fileListUpdateReceived && (DateTime.Now - then).TotalSeconds < 1) ; Assert.IsTrue(_fileListUpdateReceived); Assert.AreEqual(3, client2.AvailableFiles.UniqueFileCount); Assert.AreEqual(3, client2.AvailableFiles.FileInstanceCount); Assert.AreEqual(1, client2.AvailableFiles.CountOf(FileDescriptor.Create(_existingFile1))); Assert.AreEqual(1, client2.AvailableFiles.CountOf(FileDescriptor.Create(_existingFile2))); Assert.AreEqual(1, client2.AvailableFiles.CountOf(FileDescriptor.Create(_existingFile3))); //These should have been set by now, as client2 is sent file updates after client, however if race conditions still exist //add a second event handler for the file received on the first client and a second boolean to check Assert.AreEqual(3, client.AvailableFiles.UniqueFileCount); Assert.AreEqual(3, client.AvailableFiles.FileInstanceCount); Assert.AreEqual(1, client.AvailableFiles.CountOf(FileDescriptor.Create(_existingFile1))); Assert.AreEqual(1, client.AvailableFiles.CountOf(FileDescriptor.Create(_existingFile2))); Assert.AreEqual(1, client.AvailableFiles.CountOf(FileDescriptor.Create(_existingFile3))); } } } }
public void WhenFileOwnedByTwoClients_ClientTwoRefusesRequest_FileShouldBeAvailableFromClientOne() { //Test intended to show that order of client connection not contributing factor in download rather that testing which client file was retrieved from bool fileListUpdateReceived = false; bool requestedFileAvailable = false; bool fileRequestResponseReceived = false; string expectedHash = _existingFiles[1].Hash; bool allowRequest = true; _fileRequestReceivedCallback = new Action<FileRequestEventArgs>(delegate(FileRequestEventArgs e) { if (e.File.Hash == expectedHash) { e.Allow = allowRequest; allowRequest = !allowRequest; } }); _fileListUpdateCallback = new Action(delegate() { fileListUpdateReceived = true; }); _fileRequestResponseCallback = new Action<FileRequestResponseEventArgs>(delegate(FileRequestResponseEventArgs e) { if (e.File.Hash == expectedHash) { if (!requestedFileAvailable) { requestedFileAvailable = e.Response == FileRequestMode.Available; } fileRequestResponseReceived = true; } }); using (ServerInstance server = new ServerInstance(_settings)) { server.Connect(); using (ClientInstance client1 = new ClientInstance(_settings, "Client 1")) { client1.FileListUpdateReceived += new EventHandler<FileListModificationEventArgs>(client_FileListUpdateReceived); client1.FileRequestReceived += new EventHandler<FileRequestEventArgs>(event_FileRequestReceived); client1.Connect(); client1.AddFiles(_existingFiles); DateTime then = DateTime.Now; while (!fileListUpdateReceived && (DateTime.Now - then).TotalSeconds < 1) ; Assert.IsTrue(fileListUpdateReceived); fileListUpdateReceived = false; using (ClientInstance client2 = new ClientInstance(_settings, "Client 2")) { client2.FileListUpdateReceived += new EventHandler<FileListModificationEventArgs>(client_FileListUpdateReceived); client2.FileRequestReceived += new EventHandler<FileRequestEventArgs>(event_FileRequestReceived); client2.Connect(); client2.AddFiles(_existingFiles); then = DateTime.Now; while (!fileListUpdateReceived && (DateTime.Now - then).TotalSeconds < 1) ; Assert.IsTrue(fileListUpdateReceived); fileListUpdateReceived = false; using (ClientInstance client3 = new ClientInstance(_settings, "Client 3")) { client3.FileRequestResponseReceived += new EventHandler<FileRequestResponseEventArgs>(client_FileRequestResponseReceived); client3.Connect(); client3.RequestFile(_existingFiles[1]); then = DateTime.Now; while (!fileRequestResponseReceived && (DateTime.Now - then).TotalSeconds < 1) ; Assert.IsTrue(fileRequestResponseReceived); Assert.IsTrue(requestedFileAvailable); } } } } }
public void WhenFileIsRequested_FileProgressTransferEventsShouldFire() { int progressCalls = 0; bool fullFileListReceived = false; bool fileListUpdateReceived = false; bool fileTransferCompleted = false; string expectedHash = _existingFiles[2].Hash; int backup = _settings.FileChunkSize; _settings.FileChunkSize = 1024; _transferProgressCallback = new Action(delegate() { progressCalls++; } ); _fullFileListReceivedCallback = new Action(delegate() { fullFileListReceived = true; }); _fileListUpdateCallback = new Action(delegate() { fileListUpdateReceived = true; }); _fileTransferCompletedCallback = new Action<FileTransferCompletedEventArgs>(delegate(FileTransferCompletedEventArgs e) { if (e.Hash == expectedHash) { fileTransferCompleted = true; } }); using (ServerInstance server = new ServerInstance(_settings)) { server.Connect(); using (ClientInstance owningClient = new ClientInstance(_settings, "Owning")) { owningClient.FileListUpdateReceived +=new EventHandler<FileListModificationEventArgs>(client_FileListUpdateReceived); owningClient.Connect(); owningClient.AddFiles(_existingFiles); DateTime then = DateTime.Now; while (!fileListUpdateReceived && (DateTime.Now - then).TotalSeconds < 60) ; Assert.IsTrue(fileListUpdateReceived); using (ClientInstance requestingClient = new ClientInstance(_settings, "Requesting")) { progressCalls = 0; fullFileListReceived = false; requestingClient.FullFileListReceived += new EventHandler<FileListEventArgs>(client_FullFileListReceived); requestingClient.FileTransferProgressed += new EventHandler<FileTransferEventArgs>(client_FileTransferProgressed); requestingClient.FileTransferCompleted +=new EventHandler<FileTransferCompletedEventArgs>(client_FileTransferCompleted); requestingClient.Connect(); then = DateTime.Now; while (!fullFileListReceived && (DateTime.Now - then).TotalSeconds < 60) ; Assert.IsTrue(fullFileListReceived); then = DateTime.Now; requestingClient.RequestFile(_existingFiles[2]); while (!fileTransferCompleted && (DateTime.Now - then).TotalMinutes < 10) ; Assert.IsTrue(fileTransferCompleted); Assert.AreEqual(Math.Ceiling((double)FILESIZE / _settings.FileChunkSize), progressCalls); } } } _settings.FileChunkSize = backup; }
public void WhenSecondClientTriesToRemoveFirstClientFiles_ShouldHaveNoEffect() { using (ServerInstance server = new ServerInstance(_settings)) { server.Connect(); using (ClientInstance client = new ClientInstance(_settings, "Test Client 1")) { client.FileListUpdateReceived += new EventHandler<FileListModificationEventArgs>(client_FileListUpdated); client.Connect(); client.AddFiles(_existingFiles); DateTime then = DateTime.Now; while (!_fileListUpdateReceived && (DateTime.Now - then).TotalSeconds < 1) ; Assert.IsTrue(_fileListUpdateReceived); Assert.AreEqual(3, client.AvailableFiles.UniqueFileCount); _fileListUpdateReceived = false; client.FileListUpdateReceived -= new EventHandler<FileListModificationEventArgs>(client_FileListUpdated); using (ClientInstance client2 = new ClientInstance(_settings, "Test Client 2")) { client2.FullFileListReceived +=new EventHandler<FileListEventArgs>(client_FullFileListReceived); client2.FileListUpdateReceived +=new EventHandler<FileListModificationEventArgs>(client_FileListUpdated); client2.Connect(); then = DateTime.Now; while (!_fileListReceived && (DateTime.Now - then).TotalSeconds < 1) ; Assert.IsTrue(_fileListReceived); Assert.AreEqual(3, client2.AvailableFiles.UniqueFileCount); _fileListReceived = false; client2.RemoveFiles(_existingFiles); then = DateTime.Now; while (!_fileListUpdateReceived && (DateTime.Now - then).TotalSeconds < 1) ; Assert.IsTrue(_fileListUpdateReceived); Assert.AreEqual(3, client2.AvailableFiles.UniqueFileCount); Assert.IsTrue(client2.AvailableFiles.Contains(_existingFiles)); } } } }
public void WhenSecondClientConnectsToServer_SecondClientAddsFile_FirstClientFilesShouldReflectServerFiles() { using (ServerInstance server = new ServerInstance(_settings)) { server.Connect(); using (ClientInstance client = new ClientInstance(_settings)) { client.FileListUpdateReceived += new EventHandler<FileListModificationEventArgs>(client_FileListUpdated); client.Connect(); using(ClientInstance client2 = new ClientInstance(_settings)) { client2.Connect(); client2.AddFiles(_existingFiles); DateTime then = DateTime.Now; while (!_fileListUpdateReceived && (DateTime.Now - then).TotalSeconds < 1) ; Assert.IsTrue(_fileListUpdateReceived); Assert.IsTrue(client.AvailableFiles.Contains(_existingFiles)); } } } }
public void WhenSecondClientConnectsToServerWithFiles_SecondClientAddsSomeOfTheSameFiles_FirstClientFilesShouldBeASingleInstanceOfAllThree() { using(ServerInstance server = new ServerInstance(_settings)) { server.Connect(); using(ClientInstance client = new ClientInstance(_settings)) { client.FileListUpdateReceived +=new EventHandler<FileListModificationEventArgs>(client_FileListUpdated); client.Connect(); client.AddFiles(_existingFiles); DateTime then = DateTime.Now; while (!_fileListUpdateReceived && (DateTime.Now - then).TotalSeconds < 1) ; Assert.IsTrue(_fileListUpdateReceived); Assert.AreEqual(3, client.AvailableFiles.UniqueFileCount); Assert.AreEqual(3, client.AvailableFiles.FileInstanceCount); Assert.IsTrue(client.AvailableFiles.Contains(_existingFiles)); _fileListUpdateReceived = false; using (ClientInstance client2 = new ClientInstance(_settings)) { client2.Connect(); client2.AddFiles(new FileDescriptor[] { FileDescriptor.Create(_existingFile1), FileDescriptor.Create(_existingFile3)} ); then = DateTime.Now; while (!_fileListUpdateReceived && (DateTime.Now - then).TotalSeconds < 1) ; Assert.IsTrue(_fileListUpdateReceived); Assert.AreEqual(3, client.AvailableFiles.UniqueFileCount); Assert.AreEqual(3, client.AvailableFiles.FileInstanceCount); Assert.IsTrue(client.AvailableFiles.Contains(_existingFiles)); Assert.AreEqual(1, client.AvailableFiles.CountOf(FileDescriptor.Create(_existingFile1).Hash)); Assert.AreEqual(1, client.AvailableFiles.CountOf(FileDescriptor.Create(_existingFile2))); Assert.AreEqual(1, client.AvailableFiles.CountOf(FileDescriptor.Create(_existingFile3))); } } } }
public void WhenSecondClientConnectsToServerWithFiles_ClientFileCountShouldReflectFirstClientFiles() { using (ServerInstance server = new ServerInstance(_settings)) { server.Connect(); using (ClientInstance client1 = new ClientInstance(_settings)) { client1.FullFileListReceived += new EventHandler<FileListEventArgs>(client_FullFileListReceived); client1.Connect(); client1.AddFiles(_existingFiles); DateTime start = DateTime.Now; while (!_fileListReceived && (DateTime.Now - start).TotalMilliseconds < 1000) ; _fileListReceived = false; using (ClientInstance client2 = new ClientInstance(_settings)) { client2.FullFileListReceived += new EventHandler<FileListEventArgs>(client_FullFileListReceived); client2.Connect(); while (!_fileListReceived && (DateTime.Now - start).TotalMilliseconds < 1000) ; Assert.IsTrue(_fileListReceived); Assert.IsTrue(client2.AvailableFiles.Contains(_existingFiles)); Assert.IsTrue(client2.AvailableFiles.Contains(client1.AvailableFiles.GetCurrentUniqueFileList().ToArray())); } } } }
public void WhenOnlyClientConnectsToServer_ClientsFilesShouldBeEmpty() { using (ServerInstance server = new ServerInstance(_settings)) { server.Connect(); using (ClientInstance client = new ClientInstance(_settings)) { client.FullFileListReceived += new EventHandler<FileListEventArgs>(client_FullFileListReceived); client.Connect(); DateTime start = DateTime.Now; //Give it a second for the file list to be retrieved from server while (!_fileListReceived && (DateTime.Now - start).TotalMilliseconds < 1000) ; Assert.IsTrue(_fileListReceived); Assert.AreEqual(0, client.AvailableFiles.GetCurrentUniqueFileList().Count()); } } }
public void WhenFirstClientConnectsToServer_FileListReceivedEventShouldFire() { using (ServerInstance server = new ServerInstance(_settings)) { server.Connect(); using (ClientInstance client = new ClientInstance(_settings)) { client.FullFileListReceived += new EventHandler<FileListEventArgs>(client_FullFileListReceived); client.Connect(); DateTime start = DateTime.Now; //Give it a second for the file list to be retrieved from server while (!_fileListReceived && (DateTime.Now - start).TotalMilliseconds < 1000) ; Assert.IsTrue(_fileListReceived); } } }
public void WhenFileIsRequestedFromClient_FileExists_RequestingClientConnectsSecond_FileShouldBeServedInFull() { bool fileListUpdateReceived = false; bool fullFileListReceived = false; bool requestedFileReceived = false; FileInfo requestedFile = null; _fullFileListReceivedCallback = new Action(delegate() { fullFileListReceived = true; }); _fileListUpdateCallback = new Action(delegate() { fileListUpdateReceived = true; }); _fileTransferCompletedCallback = new Action<FileTransferCompletedEventArgs>(delegate(FileTransferCompletedEventArgs args) { requestedFile = new FileInfo(args.Location); requestedFileReceived = true; }); using (ServerInstance server = new ServerInstance(_settings)) { server.Connect(); using (ClientInstance clientOwning = new ClientInstance(_settings, "Owning Client")) { clientOwning.FileListUpdateReceived += new EventHandler<FileListModificationEventArgs>(client_FileListUpdateReceived); clientOwning.Connect(); clientOwning.AddFiles(_existingFiles); using (ClientInstance clientRequesting = new ClientInstance(_settings, "Requesting Client")) { clientRequesting.FullFileListReceived += new EventHandler<FileListEventArgs>(client_FullFileListReceived); clientRequesting.FileTransferCompleted += new EventHandler<FileTransferCompletedEventArgs>(client_FileTransferCompleted); clientRequesting.Connect(); DateTime then = DateTime.Now; while (!fullFileListReceived && (DateTime.Now - then).TotalSeconds < 1) ; Assert.IsTrue(fullFileListReceived); clientRequesting.RequestFile(_existingFiles[1]); then = DateTime.Now; while (!requestedFileReceived && (DateTime.Now - then).TotalMinutes < 10) ; Assert.IsTrue(fileListUpdateReceived); Assert.IsTrue(requestedFileReceived); Assert.IsNotNull(requestedFile); Assert.IsTrue(FilesIsEqualToRequestedFile(_existingFiles[1], requestedFile)); } } } }
public void WhenFileIsRequestedFromClient_ServerBlocksRequest_FailResponseIsReceived() { bool fileListUpdateReceived = false; bool fileRequestResponseReceived = false; bool fileRequestFailed = false; string expectedHash = _existingFiles[0].Hash; _fileListUpdateCallback = new Action(delegate() { fileListUpdateReceived = true; }); _fileRequestReceivedCallback = new Action<FileRequestEventArgs>(delegate(FileRequestEventArgs e) { if (e.File.Hash == expectedHash) { e.Allow = false; } }); _fileRequestResponseCallback = new Action<FileRequestResponseEventArgs>(delegate(FileRequestResponseEventArgs e) { if (e.File.Hash == expectedHash) { if (e.Response == FileRequestMode.NotAvailable) { fileRequestFailed = true; fileRequestResponseReceived = true; } } }); using (ServerInstance server = new ServerInstance(_settings)) { server.Connect(); server.FileRequested += new EventHandler<FileRequestEventArgs>(event_FileRequestReceived); using (ClientInstance client = new ClientInstance(_settings)) { fileListUpdateReceived = false; client.Connect(); client.FileListUpdateReceived += new EventHandler<FileListModificationEventArgs>(client_FileListUpdateReceived); client.AddFiles(_existingFiles); DateTime then = DateTime.Now; while (!fileListUpdateReceived && (DateTime.Now - then).TotalSeconds < 1) ; Assert.IsTrue(fileListUpdateReceived); using (ClientInstance client2 = new ClientInstance(_settings, "Client2")) { client2.FileRequestResponseReceived +=new EventHandler<FileRequestResponseEventArgs>(client_FileRequestResponseReceived); client2.Connect(); client2.RequestFile(_existingFiles[0]); then = DateTime.Now; while (!fileRequestFailed && (DateTime.Now - then).TotalSeconds < 1) ; Assert.IsTrue(fileRequestResponseReceived); Assert.IsTrue(fileRequestFailed); } } } }
public void WhenFileModificationMessages_ModeRemoved_AreSentByClient_TheyShouldBeFullyReceivedByServer() { _serverMessage = null; FileDescriptor[] descriptors = null; string originId = "Not Set"; using (ServerInstance server = new ServerInstance(_settings)) { server.MessageReceived += new EventHandler<ObviousCode.Interlace.BitTunnelLibrary.Events.MessageEventArgs>(server_MessageReceived); server.Connect(); while (!server.IsConnected) ; using (ClientInstance client = new ClientInstance(_settings)) { client.Connect(); originId = client.ConnectionDetails.InstanceId; descriptors = new List<FileDescriptor>() { FileDescriptor.Create(_existingFile1, true), FileDescriptor.Create(_existingFile2, true), FileDescriptor.Create(_existingFile3, true) }.ToArray(); _serverModificationMessage = null; client.RemoveFiles(descriptors); DateTime then = DateTime.Now; while (_serverModificationMessage == null && (DateTime.Now - then).TotalSeconds < 1) ; Assert.IsNotNull(_serverModificationMessage); Assert.AreEqual(descriptors[0].FileFullName, _serverModificationMessage.Modifications[0].FileFullName); Assert.AreEqual(descriptors[1].FileFullName, _serverModificationMessage.Modifications[1].FileFullName); Assert.AreEqual(descriptors[2].FileFullName, _serverModificationMessage.Modifications[2].FileFullName); //Assert.AreEqual(descriptors[0].FileId, _serverModificationMessage.Modifications[0].FileId); //Assert.AreEqual(descriptors[1].FileId, _serverModificationMessage.Modifications[1].FileId); //Assert.AreEqual(descriptors[2].FileId, _serverModificationMessage.Modifications[2].FileId); Assert.AreEqual(originId, _serverModificationMessage.Modifications[0].OriginId); Assert.AreEqual(originId, _serverModificationMessage.Modifications[1].OriginId); Assert.AreEqual(originId, _serverModificationMessage.Modifications[2].OriginId); Assert.AreEqual(FileModificationMode.Remove, _serverModificationMessage.Modifications[0].Mode); Assert.AreEqual(FileModificationMode.Remove, _serverModificationMessage.Modifications[1].Mode); Assert.AreEqual(FileModificationMode.Remove, _serverModificationMessage.Modifications[2].Mode); } } }
public void WhenFileIsRequestedFromClientThatContainsFile_FileShouldBeServedInstantlyWithoutCallingServer() { bool fileListUpdateReceived = false; bool fileRequestReceived = false; FileInfo requestedFile = null; string expectedHash = _existingFiles[2].Hash; _fileRequestReceivedCallback = new Action<FileRequestEventArgs>(delegate(FileRequestEventArgs e) { fileRequestReceived = true; }); _fileTransferCompletedCallback = new Action<FileTransferCompletedEventArgs>(delegate (FileTransferCompletedEventArgs e) { if (expectedHash == e.Hash) { requestedFile = new FileInfo(e.Location); } } ); _fileListUpdateCallback = new Action(delegate() { fileListUpdateReceived = true; } ); using (ServerInstance server = new ServerInstance(_settings)) { server.FileRequested += new EventHandler<FileRequestEventArgs>(event_FileRequestReceived); server.Connect(); using (ClientInstance client = new ClientInstance(_settings)) { client.FileTransferCompleted +=new EventHandler<FileTransferCompletedEventArgs>(client_FileTransferCompleted); client.FileListUpdateReceived +=new EventHandler<FileListModificationEventArgs>(client_FileListUpdateReceived); client.Connect(); client.AddFiles(_existingFiles); DateTime then = DateTime.Now; while (!fileListUpdateReceived && (DateTime.Now - then).TotalSeconds < 1) ; Assert.IsTrue(fileListUpdateReceived); client.RequestFile(_existingFiles[2]); then = DateTime.Now; while (requestedFile == null && (DateTime.Now - then).TotalSeconds < 1) ; Assert.IsNotNull(requestedFile); Assert.IsFalse(fileRequestReceived); Assert.AreEqual(_existingFiles[2].FileFullName, requestedFile.FullName); FilesIsEqualToRequestedFile(_existingFiles[2], requestedFile); } } }
public void WhenFirstClientConnectsToServer_SendsNew_Existing_Files_SecondClientConnects_SecondClientShouldReceiveCorrectFileListMessage() { using (ServerInstance server = new ServerInstance(_settings)) { server.Connect(); using (ClientInstance client = new ClientInstance(_settings, "Test Client 1")) { _clientMessage = null; client.MessageReceived += new EventHandler<MessageEventArgs>(client_MessageReceived); client.Connect(); DateTime start = DateTime.Now; while ((_clientMessage == null || _clientMessage.Key != MessageKeys.FileList) && (DateTime.Now - start).TotalMilliseconds < 1000) ; Assert.IsNotNull(_clientMessage); Assert.AreEqual(MessageKeys.FileList, _clientMessage.Key); Assert.AreEqual(0, (_clientMessage as FileListMessage).FileList.Count); client.MessageReceived -= new EventHandler<MessageEventArgs>(client_MessageReceived); _clientMessage = null; using (ClientInstance client2 = new ClientInstance(_settings, "Test Client 2")) { client.MessageReceived += new EventHandler<MessageEventArgs>(client_MessageReceived); client2.Connect(); FileDescriptor[] descriptors = new List<FileDescriptor>() { FileDescriptor.Create(_existingFile1.FullName, true), FileDescriptor.Create(_existingFile2.FullName, true), FileDescriptor.Create(_existingFile3.FullName, true) }.ToArray(); client2.AddFiles(descriptors); start = DateTime.Now; //Wait a second for the network activity while ((_clientMessage == null || _clientMessage.Key != MessageKeys.FileListModifications) && (DateTime.Now - start).TotalMilliseconds < 1000) ; Assert.IsNotNull(_clientMessage as FileModificationMessage); Assert.AreEqual(MessageKeys.FileListModifications, _clientMessage.Key); Assert.AreEqual(3, (_clientMessage as FileModificationMessage).Modifications.Count); //Side effect of both being on same server? Assert.IsTrue((_clientMessage as FileModificationMessage).Modifications[0].Exists); Assert.IsTrue((_clientMessage as FileModificationMessage).Modifications[1].Exists); Assert.IsTrue((_clientMessage as FileModificationMessage).Modifications[2].Exists); Assert.AreEqual(_existingFile1.FullName, (_clientMessage as FileModificationMessage).Modifications[0].FileFullName); Assert.AreEqual(_existingFile2.FullName, (_clientMessage as FileModificationMessage).Modifications[1].FileFullName); Assert.AreEqual(_existingFile3.FullName, (_clientMessage as FileModificationMessage).Modifications[2].FileFullName); //Assert.AreEqual(descriptors[0].FileId, (_clientMessage as FileModificationMessage).Modifications[0].FileId); //Assert.AreEqual(descriptors[1].FileId, (_clientMessage as FileModificationMessage).Modifications[1].FileId); //Assert.AreEqual(descriptors[2].FileId, (_clientMessage as FileModificationMessage).Modifications[2].FileId); Assert.AreEqual(descriptors[0].Hash, (_clientMessage as FileModificationMessage).Modifications[0].Hash); Assert.AreEqual(descriptors[1].Hash, (_clientMessage as FileModificationMessage).Modifications[1].Hash); Assert.AreEqual(descriptors[2].Hash, (_clientMessage as FileModificationMessage).Modifications[2].Hash); Assert.AreEqual(FileModificationMode.New, (_clientMessage as FileModificationMessage).Modifications[0].Mode); Assert.AreEqual(FileModificationMode.New, (_clientMessage as FileModificationMessage).Modifications[1].Mode); Assert.AreEqual(FileModificationMode.New, (_clientMessage as FileModificationMessage).Modifications[2].Mode); Assert.AreEqual(descriptors[0].OriginId, (_clientMessage as FileModificationMessage).Modifications[0].OriginId); Assert.AreEqual(descriptors[1].OriginId, (_clientMessage as FileModificationMessage).Modifications[1].OriginId); Assert.AreEqual(descriptors[2].OriginId, (_clientMessage as FileModificationMessage).Modifications[2].OriginId); } } } }
public void WhenFilesAddedLocally_AndRemovedLocally_ShouldBeRemovedFromLocalFiles() { using (ServerInstance server = new ServerInstance(_settings)) { server.Connect(); using (ClientInstance client = new ClientInstance(_settings)) { client.Connect(); client.AddFiles(_existingFiles); client.RemoveFiles(_existingFiles); Assert.AreEqual(0, client.LocalFiles.UniqueFileCount); Assert.AreEqual(0, client.LocalFiles.FileInstanceCount); } } }
public void WhenFilesAddedLocally_Twice_ShouldOnlyBeReflectedOnceInLocalFiles() { using(ServerInstance server = new ServerInstance(_settings)) { server.Connect(); using (ClientInstance client = new ClientInstance(_settings)) { client.Connect(); client.AddFiles(_existingFiles); client.AddFiles(_existingFiles); Assert.AreEqual(3, client.LocalFiles.UniqueFileCount); Assert.AreEqual(3, client.LocalFiles.FileInstanceCount); } } }
public void WhenFirstClientConnectsToServer_ClientReceivesEmptyFileListMessage() { using (ServerInstance server = new ServerInstance(_settings)) { server.Connect(); using (ClientInstance client = new ClientInstance(_settings, "Test Client")) { client.MessageReceived += new EventHandler<MessageEventArgs>(client_MessageReceived); client.Connect(); DateTime start = DateTime.Now; while ((_clientMessage == null || _clientMessage.Key != MessageKeys.FileList) && (DateTime.Now - start).TotalMilliseconds < 1000) ; Assert.IsNotNull(_clientMessage); Assert.AreEqual(MessageKeys.FileList, _clientMessage.Key); Assert.AreEqual(0, (_clientMessage as FileListMessage).FileList.Count); } } }
public AvailableFilesControl(ServerInstance server) : this() { Server = server; }
public void WhenFirstClientConnectsToServer_SendsNew_NonExisting_Files_SecondClientConnects_SecondClientShouldReceiveEmptytFileListMessage() { using (ServerInstance server = new ServerInstance(_settings)) { server.Connect(); using (ClientInstance client = new ClientInstance(_settings, "Test Client 1")) { client.MessageReceived += new EventHandler<MessageEventArgs>(client_MessageReceived); client.Connect(); DateTime start = DateTime.Now; while ((_clientMessage == null || _clientMessage.Key != MessageKeys.FileList) && (DateTime.Now - start).TotalMilliseconds < 1000) ; Assert.IsNotNull(_clientMessage); Assert.AreEqual(MessageKeys.FileList, _clientMessage.Key); Assert.AreEqual(0, (_clientMessage as FileListMessage).FileList.Count); _clientMessage = null; using (ClientInstance client2 = new ClientInstance(_settings, "Test Client 2")) { client2.MessageReceived += new EventHandler<MessageEventArgs>(client_MessageReceived); client2.Connect(); FileDescriptor[] descriptors = new List<FileDescriptor>() { FileDescriptor.Create(@"C:\DoesNotExist.txt", true), FileDescriptor.Create(@"C:\CompletelyFake.txt", true), FileDescriptor.Create(@"C:\PureHumbug.txt", true) }.ToArray(); client.AddFiles(descriptors); start = DateTime.Now; while ((_clientMessage == null || _clientMessage.Key != MessageKeys.FileListModifications) && (DateTime.Now - start).TotalMilliseconds < 1000) ; Assert.IsNotNull(_clientMessage as FileModificationMessage); Assert.AreEqual(MessageKeys.FileListModifications, _clientMessage.Key); Assert.AreEqual(0, (_clientMessage as FileModificationMessage).Modifications.Count); _clientMessage = null; client2.MessageReceived -= new EventHandler<MessageEventArgs>(client_MessageReceived); client.MessageReceived += new EventHandler<MessageEventArgs>(client_MessageReceived); descriptors = new List<FileDescriptor>() { FileDescriptor.Create(@"C:\DoesNotExist.txt", true), FileDescriptor.Create(@"C:\CompletelyFake.txt", true), FileDescriptor.Create(@"C:\PureHumbug.txt", true) }.ToArray(); client.AddFiles(descriptors); start = DateTime.Now; while ((_clientMessage == null || _clientMessage.Key != MessageKeys.FileListModifications) && (DateTime.Now - start).TotalMilliseconds < 1000) ; Assert.IsNotNull(_clientMessage as FileModificationMessage); Assert.AreEqual(MessageKeys.FileListModifications, _clientMessage.Key); Assert.AreEqual(0, (_clientMessage as FileModificationMessage).Modifications.Count); } } } }
public SettingsControl(ServerInstance server, AppSettings settings) : this() { Settings = settings; _settings.SelectedObject = Settings; }