private static void Server_FileInfoReceive(ESocket socket, JObject Message, NetworkFile file)
{
if (!Directory.Exists("files"))
{
Directory.CreateDirectory("files");
}
string name;
do
{
name = DateTime.Now.ToString("yyyy-MM-dd") + file.FileName.GetHashCode() + new Random().Next(0, 1000000);
}while (File.Exists("files/" + name));
file.Success += delegate(NetworkFile files)
{
// Mysql에 등록. 알려줌
MysqlNode node = new MysqlNode(private_data.mysqlOption, "INSERT INTO file(name,size,path,owner,date) VALUES (?name,?size,?path,?owner,?date)");
node["name"] = files.FileName;
node["size"] = files.FileSize;
node["path"] = "files/" + name;
node["owner"] = User.Items[socket].ID;
node["date"] = DateTime.Now;
long no = node.ExecuteInsertQuery();
User.Items[socket].AddFileItem((int)no);
};
file.Accept("files/" + name);
}
public async Task TestFileCaching()
{
// Set nickname
relay0.UpdateFile(relay0.OwnId, new Dictionary <string, string> {
{ "nickname", "old :c" }
});
await relay0.ConnectToNodeAsync(1);
await Task.Delay(100);
// Get PlayerData file from node 0 on node 1:
NetworkFile file = null;
relay1.GetFile(relay0.OwnId, (s, f) => file = f);
await Task.Delay(100);
Assert.AreEqual("old :c", file.Entries["nickname"]);
// Modify PlayerData file at node 0:
relay0.UpdateFile(relay0.OwnId, new Dictionary <string, string> {
{ "nickname", "new!" }
});
// Get PlayerData file again (should be taken from cache):
file = null;
relay1.GetFile(relay0.OwnId, (s, f) => file = f);
await Task.Delay(100);
Assert.AreEqual("old :c", file.Entries["nickname"]);
}
private void FileLoaded(object sender, NetworkFile file)
{
Invoke(new MethodInvoker(() =>
{
listViewLeaders.BeginUpdate();
listViewLeaders.Items.Clear();
}));
int place = 1;
foreach (var entry in file.Entries.OrderByDescending(pair => Convert.ToDouble(pair.Value, CultureInfo.InvariantCulture)))
{
string authorGuid = entry.Key;
string score = entry.Value;
var listViewItem = new ListViewItem(new[] { place++.ToString(), authorGuid, score });
if (authorGuid == relay.OwnId.ToString())
{
listViewItem.BackColor = Color.Aquamarine;
}
Invoke(new MethodInvoker(() => { listViewLeaders.Items.Add(listViewItem); }));
}
Invoke(new MethodInvoker(() =>
{
listViewLeaders.EndUpdate();
labelStatus.Text = "Ready";
}));
}
private void OnFileRecieved(object sender, NetworkFile networkFile)
{
Invoke(new MethodInvoker(() =>
{
listViewGames.BeginUpdate();
listViewGames.Items.Clear();
}));
foreach (var entry in networkFile.Entries)
{
string message = entry.Value;
string authorGuid = entry.Key;
if (message == "")
{
continue;
}
var listViewItem = new ListViewItem(new[] { message, authorGuid, GetPlayerLevel(new Guid(authorGuid)) });
if (authorGuid == relay.OwnId.ToString())
{
listViewItem.BackColor = Color.Aquamarine;
}
Invoke(new MethodInvoker(() => { listViewGames.Items.Add(listViewItem); }));
}
Invoke(new MethodInvoker(() =>
{
listViewGames.EndUpdate();
labelStatus.Text = "Ready";
}));
}
private void Client_FileInfoReceive(ESocket socket, JObject Message, NetworkFile file)
{
if (FileInfoReceive != null)
{
FileInfoReceive(socket, Message, file);
}
}
public Message(byte[] data, MessageType type, string username, NetworkFile file)
{
this.Data = data;
this.Type = type;
Username = username;
File = file;
}
public async Task TestGetMergedMatchmaking()
{
await relay0.ConnectToNodeAsync(1);
await relay0.ConnectToNodeAsync(2);
var entries = new Dictionary <string, string> {
{ "field1", "value1" }
};
relay0.UpdateFile(matchmakingFileId, entries);
entries = new Dictionary <string, string> {
{ "field2", "value2" }
};
relay1.UpdateFile(matchmakingFileId, entries);
await Task.Delay(5000); // Wait for cached files to invalidate
// Get file on node 2, it should ask other node, and it should ask remaning node for it and merge:
NetworkFile file = null;
relay2.GetFile(matchmakingFileId, (s, f) => { file = f; });
await Task.Delay(100);
Assert.AreEqual(FileType.Matchmaking, file.FileType);
Assert.AreEqual("value1", file.Entries["field1"]);
Assert.AreEqual("value2", file.Entries["field2"]);
}
public async Task TestGetOfflinePlayerFile()
{
await relay0.ConnectToNodeAsync(1);
await relay0.ConnectToNodeAsync(2);
await Task.Delay(100);
// Get file from node 0 on node 1:
relay1.GetFile(relay0.OwnId, (s, f) => { Console.WriteLine(); });
await Task.Delay(100);
// Disable node 0:
relay0.Dispose();
await Task.Delay(100);
// Get file from node 0 on node 2:
NetworkFile file = null;
relay2.GetFile(relay0.OwnId, (s, f) => file = f);
await Task.Delay(100);
Assert.AreEqual(relay0.OwnId, file.Id);
Assert.AreEqual(FileType.PlayerData, file.FileType);
}
private static void Server_FileInfoReceive(ESocket socket, JObject Message, NetworkFile file)
{
file.Process += delegate(NetworkFile file56)
{
Console.WriteLine("받은 바이트" + ((double)file56.FinishByte / (double)file56.FileSize));
};
file.Accept("./다운.png");
}
public void SendFile(JObject message, NetworkFile file)
{
JObject jObject = new JObject();
jObject["type"] = -1;
jObject["message"] = message;
jObject["file"] = file.Information;
Send(jObject);
}
private static void Server_FileInfoReceive(ESocket socket, JObject Message, NetworkFile file)
{
string name = FileSystem.GetRandomName(file.FileName);
file.Success += delegate(NetworkFile files)
{
// Mysql에 등록. 알려줌
long no = FileSystem.FileQuery(name, file.FileName, User.Items[socket]);
User.Items[socket].AddFileItem((int)no);
};
file.Accept(name);
}
public static dynamic ToJson(NetworkFile file)
{
return(new
{
id = file.ID,
fileName = file.Name,
fileFormat = file.FileFormat,
creationDate = file.CreationDate.ToBinary(),
fileSize = file.FileSize,
description = file.Description
});
}
public void ExportNetworkFile(string outputFilename)
{
var links = _dbClient.GetLinks();
Console.WriteLine("Count links: " + links.Count);
var nodes = _dbClient.GetNodes();
Console.WriteLine("Count nodes: " + nodes.Count);
NetworkFile.Write(outputFilename, nodes, links);
}
private static NetworkFile MergeMatchmakingFiles(NetworkFile highPriority, NetworkFile lowPriority)
{
var lowPriorityStripped = lowPriority.Entries
.Where(kvp => !highPriority.Entries.ContainsKey(kvp.Key));
var entries = highPriority.Entries
.Concat(lowPriorityStripped)
.ToImmutableDictionary(kvp => kvp.Key, kvp => kvp.Value);
return(new NetworkFile(highPriority.Id, highPriority.Owner,
highPriority.RecievedFromOrigin, highPriority.FileType,
entries));
}
internal Task StartDownload(Connection connection, NetworkFile file)
{
this.file = file;
this.Title = file.Name;
fileName_Textblock.Text = file.Name;
connection.FileTransferProgressChanged += FileTransferProgressChanged;
progressBar_Pb.Maximum = file.FileSize;
return(Task.Run(async() =>
{
await connection.ReceiveFileAsync(Settings.Default.DownloadPath + file.Name, file.FileSize);
}));
}
private void Server_FileInfoReceive(ESocket socket, JObject Message, NetworkFile file)
{
// 파일에 대해 진행바 딜리게이트 연결
SocketFile.NewFile(file);
if ((bool)Message["open"]) // 내가 파일 오픈을 요청했는지 여부가 담겨있다.
{
// 성공적으로 파일을 받았을 경우 실행되는 이벤트
file.Success += delegate(NetworkFile files)
{
System.Diagnostics.Process.Start(files.Path);
};
}
file.Accept((string)Message["path"]);
}
private async void DownloadButtonClick(object sender, RoutedEventArgs e)
{
Connection connection = new Connection();
await connection.Connect(Settings.Default.ServerIP, Settings.Default.ServerPort);
DownloadWindow window = sender as DownloadWindow;
NetworkFile file = window.File;
// Moet uiteindelijk in een apart download window worden gemaakt
await connection.SendPacket(new FileDownloadRequest(file.ID));
connection.FileTransferProgressChanged += (o, ev) =>
{
};
await connection.ReceiveFileAsync(file.Name, file.FileSize);
}
public void Set(NetworkFile file)
{
this.file = file;
Items.Add(file, this);
if (file.upload)
{
file_name.text = file.FileName;
state.text = "업로드중";
}
else
{
string[] temp = file.Path.Split('\\');
file_name.text = temp[temp.Length - 1];
state.text = "다운로드중";
}
}
public async Task TestGetOwnFile()
{
await relay0.ConnectToNodeAsync(1);
await Task.Delay(100);
// Get file from node 0 on node 1:
NetworkFile file = null;
relay1.GetFile(relay0.OwnId, (s, f) => file = f);
await Task.Delay(100);
Assert.AreEqual(relay0.OwnId, file.Id);
Assert.AreEqual(FileType.PlayerData, file.FileType);
}
private string GetPlayerLevel(Guid playerId)
{
NetworkFile file = relay.GetFileLocalOrNull(playerId, false, true);
if (file == null)
{
return("N/A");
}
if (!file.Entries.TryGetValue("Level", out string level))
{
return("N/A");
}
return(level);
}
private static void Server_FileInfoReceive(ESocket socket, JObject Message, NetworkFile file)
{
Console.WriteLine(Message.ToString());
file.Accept("./U" + file.FileName);
if (file.FileName == "3.png")
{
file.End += delegate(NetworkFile file5)
{
Console.WriteLine("3번 파일 전송 끝");
NServerFile newfile = new NServerFile(socket, "./U7.png");
newfile.Process += delegate(NetworkFile file56)
{
Console.WriteLine("받은 바이트" + ((double)newfile.FinishByte / (double)newfile.FileSize));
};
socket.SendFile(Message, newfile);
};
}
}
public static void NewFile(NetworkFile file)
{
file.Start += delegate(NetworkFile thisfile)
{
UnityMainThreadDispatcher.Instance().Enqueue(delegate() {
SocketFile newobject = Instantiate(Preset.objects.SocketFile, Preset.objects.SocketFileGrid.transform);
newobject.Set(thisfile);
Preset.objects.SocketFileGrid.repositionNow = true;
});
};
file.End += delegate(NetworkFile thisfile)
{
UnityMainThreadDispatcher.Instance().Enqueue(delegate() {
DestroyImmediate(SocketFile.Items[thisfile].gameObject);
Preset.objects.SocketFileGrid.repositionNow = true;
});
};
}
public void TestMergeLeaderboards()
{
var a = new Dictionary <string, string>
{
{ "player1", "42.5" },
{ "player5", "11.2" }
};
var b = new Dictionary <string, string>
{
{ "player2", "18.3" },
{ "player5", "35" }
};
NetworkFile fileA = new NetworkFile(DhtUtils.GenerateFileId(), Guid.Empty, a.ToImmutableDictionary());
NetworkFile fileB = new NetworkFile(DhtUtils.GenerateFileId(), Guid.Empty, b.ToImmutableDictionary());
//FilesMerger.MergeFiles();
}
public static NetworkFile MergeFiles(NetworkFile a, NetworkFile b)
{
if (b == null)
{
return(a);
}
if (a == null)
{
return(b);
}
if (a.Id != b.Id)
{
throw new FrameworkException("Merging files with different ids");
}
if (a.FileType != b.FileType)
{
return(NewerFile(a, b));
}
switch (a.FileType)
{
case FileType.PlayerData:
case FileType.Custom:
return(NewerFile(a, b));
case FileType.Leaderboard:
return(MergeLeaderboardsFiles(a, b));
case FileType.Matchmaking:
if (a.RecievedFromOrigin > b.RecievedFromOrigin)
{
return(MergeMatchmakingFiles(a, b));
}
else
{
return(MergeMatchmakingFiles(b, a));
}
default:
throw new ArgumentOutOfRangeException();
}
}
private static NetworkFile MergeLeaderboardsFiles(NetworkFile highPriority, NetworkFile lowPriority)
{
var result = new Dictionary <string, string>(highPriority.Entries);
foreach (var entry in lowPriority.Entries)
{
if (result.ContainsKey(entry.Key))
{
double oldVal = Convert.ToDouble(result[entry.Key], CultureInfo.InvariantCulture);
double newVal = Convert.ToDouble(entry.Value, CultureInfo.InvariantCulture);
result[entry.Key] = Math.Max(oldVal, newVal).ToString(CultureInfo.InvariantCulture);
}
else
{
result.Add(entry.Key, entry.Value);
}
}
return(new NetworkFile(highPriority.Id, highPriority.Owner,
highPriority.RecievedFromOrigin, highPriority.FileType,
result.ToImmutableDictionary()));
}
public async Task TestGetOwnFileForwarded()
{
// So, that 1 and 2 had no way to connect
factory1.NatSimulation = true;
factory2.NatSimulation = true;
await relay1.ConnectToNodeAsync(0);
await relay2.ConnectToNodeAsync(0);
await Task.Delay(100);
// Get file from node 2 on node 1:
NetworkFile file = null;
relay1.GetFile(relay2.OwnId, (s, f) => file = f);
await Task.Delay(100);
Assert.AreEqual(relay2.OwnId, file.Id);
Assert.AreEqual(FileType.PlayerData, file.FileType);
}
public async Task TestGetUpdatedFile()
{
// Create file:
var entries = new Dictionary <string, string> {
{ "field", "value" }
};
Guid fileId = relay0.CreateNewFile(entries);
// Connect nodes:
await relay1.ConnectToNodeAsync(0);
await Task.Delay(100);
// Get file from node 0 on node 1:
NetworkFile file = null;
relay1.GetFile(fileId, (s, f) => file = f);
await Task.Delay(100);
Assert.AreEqual(fileId, file.Id);
Assert.AreEqual("value", file.Entries["field"]);
// Update file on node 0:
entries = new Dictionary <string, string> {
{ "field", "new value" }
};
relay0.UpdateFile(fileId, entries);
// Get file again:
file = null;
relay1.GetFile(fileId, (s, f) => file = f);
await Task.Delay(100);
Assert.AreEqual(fileId, file.Id);
Assert.AreEqual("new value", file.Entries["field"]);
}
/// <summary>
/// Handelt een bestand info aanvraag af.
/// </summary>
/// <param name="request"></param>
private void HandleFileInfoRequest(FileInfoRequest request, StateObject state)
{
string path = Settings.Default.FileFolder + request.ID;
string fileWithExtension = NetworkUtils.GetAssociatedFile(Settings.Default.FileFolder, request.ID);
bool exists = File.Exists(fileWithExtension);
FileInfoResponse response = new FileInfoResponse();
if (exists)
{
string text = File.ReadAllText(path + ".json");
dynamic json = JsonConvert.DeserializeObject(text);
NetworkFile file = Util.NetworkUtils.FromJson(json);
FileInfo fi = new FileInfo(fileWithExtension);
file.FileSize = fi.Length;
file.CreationDate = fi.CreationTimeUtc;
response = new FileInfoResponse(file);
}
//state.Client.Socket.BeginReceive(state.Buffer, 0, StateObject.BufferSize, 0, ReceiveMessageCallback, state);
SendPacket(state.Client, response, SendCallback, FollowUpTask.RECEIVE_MSG);
}
public async Task TestGetNotExistingFile()
{
await relay1.ConnectToNodeAsync(0);
await relay1.ConnectToNodeAsync(2);
await Task.Delay(100);
// Get not existing file on node 1:
NetworkFile file = null;
bool callbackCalled = false;
relay1.GetFile(DhtUtils.GenerateFileId(), (s, f) =>
{
file = f;
callbackCalled = true;
});
await Task.Delay(100);
Assert.IsNull(file);
Assert.IsTrue(callbackCalled);
}
public static NetworkFile NewerFile(NetworkFile a, NetworkFile b)
{
return(a.RecievedFromOrigin > b.RecievedFromOrigin ? a : b);
}
