public SharedFilesControl(ClientInstance client)
{
InitializeComponent();
Client = client;
_helper = new ListViewHelper(_sharedFilesView, ListViewHelper.ComparisonKey.Hash);
_watchers = new List<FileSystemWatcher>();
}
public AvailableFilesClientControl(ClientInstance client)
{
InitializeComponent();
_helper = new ListViewHelper(_availableFilesView, ListViewHelper.ComparisonKey.Hash);
Client = client;
Client.ConnectionMade += new EventHandler(Client_ConnectionMade);
Client.ConnectionTerminated += new EventHandler(Client_ConnectionTerminated);
Client.LostConnection += new EventHandler<ObviousCode.Interlace.BitTunnelLibrary.Events.ExceptionEventArgs>(Client_LostConnection);
}
public AvailableFile(ClientInstance client, FileDescriptor descriptor)
: base(descriptor)
{
_state = FileState.Available;
_client = client;
_percent = 0d;
_client.FileRequestResponseReceived += new EventHandler<ObviousCode.Interlace.BitTunnelLibrary.Events.FileRequestResponseEventArgs>(_client_FileRequestResponseReceived);
_client.FileTransferProgressed += new EventHandler<ObviousCode.Interlace.BitTunnelLibrary.Events.FileTransferEventArgs>(_client_FileTransferProgressed);
_client.FileTransferCompleted += new EventHandler<ObviousCode.Interlace.BitTunnelLibrary.Events.FileTransferCompletedEventArgs>(_client_FileTransferCompleted);
_client.FileTransferFailed += new EventHandler<ObviousCode.Interlace.BitTunnelLibrary.Events.FileDescriptorEventArgs>(_client_FileTransferFailed);
}
public void WhenEmptyFileListSent_ShouldBeReceivedAsEmptyFileList()
{
using(ServerInstance server = new ServerInstance(_settings))
{
server.Connect();
using(ClientInstance client = new ClientInstance(_settings))
{
client.Connect();
}
}
}
public LoggingControl(ClientInstance client)
: this()
{
Client = client;
client.FileListUpdateReceived += new EventHandler<ObviousCode.Interlace.BitTunnelLibrary.Events.FileListModificationEventArgs>(client_FileListUpdateReceived);
client.FileRequestReceived += new EventHandler<ObviousCode.Interlace.BitTunnelLibrary.Events.FileRequestEventArgs>(client_FileRequestReceived);
client.FileRequestResponseReceived += new EventHandler<ObviousCode.Interlace.BitTunnelLibrary.Events.FileRequestResponseEventArgs>(client_FileRequestResponseReceived);
client.FileTransferCompleted += new EventHandler<ObviousCode.Interlace.BitTunnelLibrary.Events.FileTransferCompletedEventArgs>(client_FileTransferCompleted);
client.FileTransferFailed += new EventHandler<ObviousCode.Interlace.BitTunnelLibrary.Events.FileDescriptorEventArgs>(client_FileTransferFailed);
client.FileTransferInitiated += new EventHandler<ObviousCode.Interlace.BitTunnelLibrary.Events.FileTransferEventArgs>(client_FileTransferInitiated);
client.FileTransferProgressed += new EventHandler<ObviousCode.Interlace.BitTunnelLibrary.Events.FileTransferEventArgs>(client_FileTransferProgressed);
client.FullFileListReceived += new EventHandler<ObviousCode.Interlace.BitTunnelLibrary.Events.FileListEventArgs>(client_FullFileListReceived);
client.ConnectionMade += new EventHandler(client_ConnectionMade);
client.ConnectionTerminated += new EventHandler(client_ConnectionTerminated);
client.LostConnection += new EventHandler<ObviousCode.Interlace.BitTunnelLibrary.Events.ExceptionEventArgs>(client_LostConnection);
client.MessageReceived += new EventHandler<ObviousCode.Interlace.BitTunnelLibrary.Events.MessageEventArgs>(client_MessageReceived);
}
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 BitTunnelForm()
{
InitializeComponent();
_settings = new AppSettings();
//Default values
_settings.Port = 1234;
_settings.ServerAddress = IPAddress.Parse("127.0.0.1");
_settings.ServerIsRemote = false;
_client = new ClientInstance(_settings);
_client.ConnectionMade += new EventHandler(_client_ConnectionMade);
_client.ConnectionTerminated += new EventHandler(_client_ConnectionTerminated);
_client.LostConnection += new EventHandler<ExceptionEventArgs>(_client_LostConnection);
AddInfoTabControls();
AddMainTabControls();
LoadInfoTabs();
LoadMainTabs();
SetupForConnection();
}
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 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_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 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_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 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 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 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 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 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 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_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 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 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_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 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 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 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);
}
}
}
