public int Deregister(string fileName, FileEndPoint peer)
{
// TODO: Deregister on REST Server.
try
{
if (!_endPointsByFile.ContainsKey(fileName))
{
return(0); // nothing to delete.
}
_endPointsByFile.TryGetValue(fileName, out var peers);
if (peers?.Contains(peer) == false)
{
return(0); // nothing to delete.
}
peers?.Remove(peer);
if (peers?.Count == 0)
{
_endPointsByFile.Remove(fileName);
}
return(1); // 1 = successfully removed
}
catch (Exception e)
{
Console.WriteLine(e);
return(-1); // -1 = error
}
}
public int Register(string fileName, FileEndPoint peer)
{
try
{
if (_endPointsByFile.ContainsKey(fileName))
{
_endPointsByFile.TryGetValue(fileName, out var peers);
if (peers?.Contains(peer) == false)
{
return(0); // peer with that file already exists.
}
peers?.Add(peer);
return(1); // 1 = successfully added
}
_endPointsByFile.Add(fileName, new List <FileEndPoint> {
peer
});
return(1); // 1 = successfully added
}
catch (Exception e)
{
Console.WriteLine(e);
return(-1); // -1 = error
}
}
public static async Task ServerStartup(List <string> filesOnServer, FileEndPoint peer)
{
foreach (var filePath in filesOnServer)
{
await RegisterFileAsync(Path.GetFileName(filePath), peer);
}
}
public static async Task <string> RegisterFileAsync(string fileName, FileEndPoint peer)
{
using HttpClient client = new HttpClient();
string peerJson = JsonSerializer.Serialize(peer);
StringContent content = new StringContent(peerJson, Encoding.UTF8, "application/json");
HttpResponseMessage response = await client.PostAsync(RegistryBaseUrl + fileName, content);
return(response.IsSuccessStatusCode ? "Registration succeeded" : "Registration failed");
}
public void RegisterTest()
{
// Arrange
string fileName = "aNewFileForTesting";
FileEndPoint peer = new FileEndPoint(IPAddress.Loopback.ToString(), 9998);
// Act
int expectedResult = 1;
int actualResult = _manager.Register(fileName, peer);
Assert.AreEqual(expectedResult, actualResult);
}
private void HandleClient(TcpClient tempSocket, FileEndPoint thisPeer)
{
using NetworkStream ns = tempSocket.GetStream();
StreamWriter sw = new StreamWriter(ns)
{
AutoFlush = true
};
StreamReader sr = new StreamReader(ns);
try
{
sw.WriteLine("Commands: GetFile, UploadFile, List");
ClientRequest clientRequest = (ClientRequest)Enum.Parse(typeof(ClientRequest), sr.ReadLine());
switch (clientRequest)
{
case ClientRequest.GetFile:
sw.WriteLine("Enter name of the file you want to retrieve:");
string fileName = sr.ReadLine();
string file = FileManagement.GetFile(fileName, _filesOnServer);
sw.WriteLine($"{file}");
SimpleLog.LogMessage($"GetFile({fileName}) requested");
break;
case ClientRequest.UploadFile:
string newFileName = sr.ReadLine();
// TODO: Maybe add file creation here...
// FileManagement.CreateFile(fileName) or something :thinking:
_filesOnServer.Add(newFileName); // only adds the name of the file, since there is no file.
Task.Run(() => RegistryCommunication.RegisterFileAsync(newFileName, thisPeer));
SimpleLog.LogMessage("Uploaded new file to registry (simulated)");
break;
case ClientRequest.List:
_filesOnServer.ForEach(x => sw.WriteLine(Path.GetFileName(x)));
SimpleLog.LogMessage("List requested");
break;
default:
sw.WriteLine("Request not understood by server");
break;
}
SimpleLog.LogMessage("Client disconnected");
}
catch (Exception e)
{
sw.WriteLine("Request failed.");
Console.WriteLine($"Error thrown. Message: {e.Message}");
HandleClient(tempSocket, thisPeer);
}
}
public static async Task <string> DeregisterFile(string fileName, FileEndPoint peer)
{
// TODO: Try out DeregisterFile. Does it work?
using HttpClient client = new HttpClient();
string peerJson = JsonSerializer.Serialize(peer);
StringContent content = new StringContent(peerJson, Encoding.UTF8, "application/json");
HttpResponseMessage response = await client.PutAsync(RegistryBaseUrl + fileName, content);
return(response.IsSuccessStatusCode ? "Deregister succeeded" : "Deregister failed");
}
public void DeregisterTest()
{
// Arrange
string fileName = "testFile";
FileEndPoint peer = new FileEndPoint("126.5.235.50", 4340);
// Act
int expectedResult = 1;
int actualResult = _manager.Deregister(fileName, peer);
Assert.AreEqual(expectedResult, actualResult);
}
public int Post(String filename, [FromBody] FileEndPoint value)
{
int res = -1;
if (!register.Keys.Contains(filename))
{
register.Add(filename, new HashSet <FileEndPoint>());
}
var fileset = register[filename];
res = fileset.Add(value) ? 1 : 0;
return(res);
}
private static void InsertIntoDictionary(Dictionary <string, List <FileEndPoint> > _data, string filename,
FileEndPoint fep)
{
if (_data.ContainsKey(filename))
{
List <FileEndPoint> listOfFep = _data[filename];
listOfFep.Add(fep);
}
else
{
List <FileEndPoint> listOfFep = new List <FileEndPoint>();
listOfFep.Add(fep);
_data.Add(filename, listOfFep);
}
}
public void Download(String filename, FileEndPoint ep, String outFileName)
{
TcpClient client = new TcpClient(ep.IpAddress, ep.Port);
StreamWriter sw = new StreamWriter(client.GetStream());
sw.WriteLine("GET " + filename);
sw.Flush();
NetworkStream fromStream = client.GetStream();
FileStream toStream = File.Create(Configurations.FileClientPath + outFileName);
fromStream.CopyTo(toStream);
toStream?.Close();
client?.Close();
}
public static void UpdateEndPoints()
{
if (Config.Current.EnableCollectorLogging)
{
CollectorEndPoint = CollectorEndPoint ?? new LoggerEndPoint.Collector();
EndPoints.Add(CollectorEndPoint);
}
else if (CollectorEndPoint != null)
{
EndPoints.Remove(CollectorEndPoint);
}
if (Config.Current.EnableFileLogging && !Config.Current.IsInDesignMode)
{
try {
FileEndPoint = new LoggerEndPoint.File(new StreamWriter(File.Open(Config.Current.LogFilePath, FileMode.Append, FileAccess.Write)));
EndPoints.Add(FileEndPoint);
}
catch (IOException e) {
Fail(string.Format(Resources.System_LogFileCannotBeOpened, e.GetType().Name, e.Message), Resources.Tag_System);
Fail(e.StackTrace, Resources.Tag_System);
}
}
else if (FileEndPoint != null)
{
EndPoints.Remove(FileEndPoint);
FileEndPoint.Close();
FileEndPoint = null;
}
if (Config.Current.IsInDesignMode)
{
Debug(Resources.System_LoggingSessionStarted, Resources.Tag_System);
Note(Resources.System_LoggingSessionStarted, Resources.Tag_System);
Info(Resources.System_LoggingSessionStarted, Resources.Tag_System);
Warn(Resources.System_LoggingSessionStarted, Resources.Tag_System);
Fail(Resources.System_LoggingSessionStarted, Resources.Tag_System);
}
else
{
Info(Resources.System_LoggingSessionStarted, Resources.Tag_System);
}
}
public void Start(int portNo)
{
TcpListener server = new TcpListener(IPAddress.Loopback, portNo);
DirectoryInfo dirInfo = new DirectoryInfo(@"F:\visual_studio_projects\repos\3_semester\PeerToPeerWithCentralServer\TCPPeerServer");
_filesOnServer = FileManagement.GetAllFilesOnServer($"{dirInfo}\\PeerServerFiles\\{portNo}");
string serverIPAddress = server.LocalEndpoint.ToString().Split(":").First();
FileEndPoint thisPeer = new FileEndPoint(serverIPAddress, portNo);
Task.Run(() => RegistryCommunication.ServerStartup(_filesOnServer, thisPeer));
server.Start();
SimpleLog.LogMessage("Server ready", portNo);
while (true)
{
TcpClient tempSocket = server.AcceptTcpClient();
SimpleLog.LogMessage("Client connected", portNo);
Task.Run(() => HandleClient(tempSocket, thisPeer));
}
}
public int Put(String filename, [FromBody] FileEndPoint value)
{
int res = -1;
if (!register.ContainsKey(filename))
{
return(0); // do not exists
}
var fileset = register[filename];
res = fileset.Remove(value) ? 1 : 0;
if (fileset.Count == 0)
{
// no more entries for this filename
register.Remove(filename);
}
return(res);
}
private static void FindFile(PeerConsoleMenu menu)
{
Random rand = new Random(DateTime.Now.Millisecond);
Console.Write("Type filename: ");
string fileName = Console.ReadLine();
Console.WriteLine("Trying to locate file...");
List <FileEndPoint> endPoints = menu.LookupFile(fileName).Result;
if (endPoints.Count == 0)
{
Console.WriteLine(fileName + " could not be found");
}
else
{
Console.WriteLine("File found, connecting to peer...");
FileEndPoint fileEndPoint = endPoints[rand.Next(0, endPoints.Count)];
Console.WriteLine("Peer data: " + fileEndPoint.IpAddress + ":" + fileEndPoint.Port);
TcpClient client = new TcpClient();
client.Connect(fileEndPoint.IpAddress, fileEndPoint.Port);
NetworkStream stream = client.GetStream();
StreamWriter sw = new StreamWriter(stream);
StreamReader sr = new StreamReader(stream);
sw.WriteLine(fileName);
sw.Flush();
string mockup = sr.ReadLine();
Console.WriteLine("Answer from peer: ");
Console.WriteLine("Mockup: " + mockup);
}
Continue();
}
private static void InsertIntoDictionary(Dictionary <string, List <FileEndPoint> > dic, string filename, FileEndPoint fep)
{
if (dic.ContainsKey(filename))
{
List <FileEndPoint> ListOfFeps = dic[filename];
ListOfFeps.Add(fep);
}
else
{
List <FileEndPoint> ListOfFeps = new List <FileEndPoint>();
ListOfFeps.Add(fep);
dic.Add(filename, ListOfFeps);
}
}
public int Deregister(string fileName, [FromBody] FileEndPoint peer)
{
return(_manager.Deregister(fileName, peer));
}
