public void setParentNode()
{
Task.Run(() => {
Skynet.Base.Skynet sender = new Skynet.Base.Skynet();
Node mNode = new Node(new List<NodeId>(), mSkynet);
Task.Run(async () => {
// create a node
Node parentNode = new Node(new List<NodeId>(), sender);
long timeStamp = Skynet.Utils.Utils.UnixTimeNow();
ToxResponse res = await RequestProxy.sendRequest(mSkynet, new ToxRequest
{
uuid = Guid.NewGuid().ToString(),
url = "node/" + mNode.selfNode.uuid + "/parent",
method = "put",
content = JsonConvert.SerializeObject(parentNode.selfNode),
fromNodeId = parentNode.selfNode.uuid,
fromToxId = sender.tox.Id.ToString(),
toNodeId = mNode.selfNode.uuid,
toToxId = mSkynet.tox.Id.ToString(),
time = timeStamp,
});
NodeResponse mRes = JsonConvert.DeserializeObject<NodeResponse>(res.content);
Console.WriteLine("value: " + mRes.value);
Assert.AreEqual(mRes.statusCode, NodeResponseCode.OK);
Assert.AreEqual(timeStamp, mRes.time);
Assert.AreEqual(timeStamp, mNode.parentModifiedTime);
}).GetAwaiter().GetResult();
});
}
public void setParentNode()
{
Task.Run(() => {
Skynet.Base.Skynet sender = new Skynet.Base.Skynet();
Node mNode = new Node(new List <NodeId>(), mSkynet);
Task.Run(async() => {
// create a node
Node parentNode = new Node(new List <NodeId>(), sender);
long timeStamp = Skynet.Utils.Utils.UnixTimeNow();
ToxResponse res = await RequestProxy.sendRequest(mSkynet, new ToxRequest
{
uuid = Guid.NewGuid().ToString(),
url = "node/" + mNode.selfNode.uuid + "/parent",
method = "put",
content = JsonConvert.SerializeObject(parentNode.selfNode),
fromNodeId = parentNode.selfNode.uuid,
fromToxId = sender.tox.Id.ToString(),
toNodeId = mNode.selfNode.uuid,
toToxId = mSkynet.tox.Id.ToString(),
time = timeStamp,
});
NodeResponse mRes = JsonConvert.DeserializeObject <NodeResponse>(res.content);
Console.WriteLine("value: " + mRes.value);
Assert.AreEqual(mRes.statusCode, NodeResponseCode.OK);
Assert.AreEqual(timeStamp, mRes.time);
Assert.AreEqual(timeStamp, mNode.parentModifiedTime);
}).GetAwaiter().GetResult();
});
}
static void Main(string[] args)
{
Base.Skynet mSkynet = new Base.Skynet();
Base.Skynet mSkynet2 = new Base.Skynet();
Node node1 = new Node(mSkynet);
Node node3 = new Node(mSkynet);
Node node2 = new Node(mSkynet2);
Task.Run(async() =>
{
// add node1 to node2's childnodes
NodeResponse res = await node1.sendRequest(node2.selfNode,
JsonConvert.SerializeObject(node1.selfNode), "post",
"node/" + node2.selfNode.uuid + "/childNodes", Utils.Utils.UnixTimeNow());
NodeResponse setParentRes = await node1.sendRequest(node1.selfNode,
JsonConvert.SerializeObject(node2.selfNode), "put",
"node/" + node1.selfNode.uuid + "/parent", Utils.Utils.UnixTimeNow());
NodeResponse addChildToNode3 = await node2.sendRequest(node3.selfNode,
JsonConvert.SerializeObject(node2.selfNode), "post",
"node/" + node3.selfNode.uuid + "/childNodes", Utils.Utils.UnixTimeNow());
NodeResponse setParentNode2 = await node2.sendRequest(node2.selfNode,
JsonConvert.SerializeObject(node3.selfNode), "put",
"node/" + node2.selfNode.uuid + "/parent", Utils.Utils.UnixTimeNow());
// stop mskynet2
mSkynet2.stop();
Console.ReadLine();
}).GetAwaiter().GetResult();
}
public void autoSetGrandParnetsTest()
{
Skynet.Base.Skynet mSkynet = new Skynet.Base.Skynet();
Node node1 = new Node(mSkynet);
Node node2 = new Node(mSkynet);
Node node3 = new Node(mSkynet);
Task.Run(async () => {
bool isConnect2 = await node2.joinNetByTargetParents(new List<NodeId> { node1.selfNode });
bool isConnect3 = await node3.joinNetByTargetParents(new List<NodeId> { node2.selfNode });
Assert.AreEqual(node1.childNodes.FirstOrDefault().uuid, node2.selfNode.uuid);
Assert.AreEqual(node2.childNodes.FirstOrDefault().uuid, node3.selfNode.uuid);
Assert.AreEqual(node3.parent.uuid, node2.selfNode.uuid);
Assert.AreEqual(node2.parent.uuid, node1.selfNode.uuid);
Assert.AreEqual(node3.grandParents.uuid, node1.selfNode.uuid);
}).GetAwaiter().GetResult();
}
public void autoSetGrandParnetsTest()
{
Skynet.Base.Skynet mSkynet = new Skynet.Base.Skynet();
Node node1 = new Node(mSkynet);
Node node2 = new Node(mSkynet);
Node node3 = new Node(mSkynet);
Task.Run(async() => {
bool isConnect2 = await node2.joinNetByTargetParents(new List <NodeId> {
node1.selfNode
});
bool isConnect3 = await node3.joinNetByTargetParents(new List <NodeId> {
node2.selfNode
});
Assert.AreEqual(node1.childNodes.FirstOrDefault().uuid, node2.selfNode.uuid);
Assert.AreEqual(node2.childNodes.FirstOrDefault().uuid, node3.selfNode.uuid);
Assert.AreEqual(node3.parent.uuid, node2.selfNode.uuid);
Assert.AreEqual(node2.parent.uuid, node1.selfNode.uuid);
Assert.AreEqual(node3.grandParents.uuid, node1.selfNode.uuid);
}).GetAwaiter().GetResult();
}
public static async Task <ToxResponse> sendRequest(Skynet host, ToxRequest req)
{
// if req is not send to local node
if (host.tox.Id.ToString() != req.toToxId)
{
bool mResStatus = false;
return(await host.sendRequest(new ToxId(req.toToxId), req, out mResStatus));
}
string baseUrl = "http://localhost:" + host.httpPort + "/";
var request = (HttpWebRequest)WebRequest.Create(baseUrl + "api/" + req.url);
request.Headers.Add("Uuid", req.uuid);
request.Headers.Add("From-Node-Id", req.fromNodeId);
request.Headers.Add("From-Tox-Id", req.fromToxId);
request.Headers.Add("To-Node-Id", req.toNodeId);
request.Headers.Add("To-Tox-Id", req.toToxId);
request.Headers.Add("Skynet-Time", req.time + "");
request.Method = req.method.ToUpper();
request.ContentType = "application/json";
List <string> allowedMethods = new List <string> {
"POST", "PUT", "PATCH"
};
if (allowedMethods.Any(x => x == req.method.ToUpper()))
{
// only the above methods are allowed to add body data
using (var streamWriter = new StreamWriter(request.GetRequestStream()))
{
streamWriter.Write(req.content);
}
}
var response = await request.GetResponseAsync();
var responseString = new StreamReader(response.GetResponseStream()).ReadToEnd();
return(req.createResponse(responseString));
}
public GrandParentsControllerTest()
{
mSkynet = new Skynet.Base.Skynet();
baseUrl = "http://localhost:" + mSkynet.httpPort + "/api/";
}
public ParentNodeControllerTest()
{
mSkynet = new Skynet.Base.Skynet();
baseUrl = baseUrl = "http://localhost:" + mSkynet.httpPort + "/";
}
public ParentNodeControllerTest()
{
mSkynet = new Skynet.Base.Skynet();
baseUrl = baseUrl = "http://localhost:" + mSkynet.httpPort + "/";
}
static void Main(string[] args)
{
if (args.Length != 4 && args.Length != 0)
{
Console.WriteLine("usage: SharpLink [local_port] [target_tox_id] [target_ip] [target_port]");
return;
}
Skynet.Base.Skynet mSkynet = null;
if (args.Length == 0)
{
// log to file
Utils.setLogFile("server.log");
}
else
{
// log to file
Utils.setLogFile("client.log");
}
// Save tox data for server
if (args.Length == 0 && File.Exists("tox.dat"))
{
mSkynet = new Skynet.Base.Skynet("tox.dat");
}
else if (args.Length == 0 && !File.Exists("tox.dat"))
{
mSkynet = new Skynet.Base.Skynet();
mSkynet.Save("tox.dat");
}
else
{
mSkynet = new Skynet.Base.Skynet();
}
if (args.Length == 4)
{
string localPort = args [0];
string targetToxId = args [1];
string targetIP = args [2];
int targetPort = Convert.ToInt32(args [3]);
// create local socket server
IPAddress ip = IPAddress.Parse("0.0.0.0");
var serverSocket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
serverSocket.Bind(new IPEndPoint(ip, Convert.ToInt32(localPort)));
serverSocket.Listen(1000);
Task.Factory.StartNew(() => {
while (true)
{
Utils.LogUtils("Event: Waiting socket");
List <byte> tempData = new List <byte> ();
Socket clientSocket = serverSocket.Accept();
Task.Factory.StartNew(() => {
bool closeFlag = false;
LinkClient mlink = null;
string tempConnectId = Guid.NewGuid().ToString();
Task.Factory.StartNew(() => {
while (true)
{
byte[] buf = new byte[1024 * 512];
try {
int size = 0;
if (clientSocket != null && clientSocket.Connected)
{
size = clientSocket.Receive(buf);
}
else
{
break;
}
if (mlink == null)
{
tempData.AddRange(buf.Take(size));
}
if (size == 0)
{
// socket closed
if (mlink != null)
{
mlink.CloseRemote();
}
if (!closeFlag && clientSocket.Connected)
{
closeFlag = true;
clientSocket.Shutdown(SocketShutdown.Both);
clientSocket.Close();
if (mlink != null)
{
Utils.LogUtils("Event: Close Connection, ClientId: " + mlink.clientId + ", ConnectId: " + tempConnectId);
}
else
{
Utils.LogUtils("Event: Close Connection, ClinetId: null" + ", ConnectId: " + tempConnectId);
}
}
break;
}
if (mlink != null)
{
var res = mlink.Send(buf, size);
if (!res && !closeFlag && clientSocket.Connected)
{
closeFlag = true;
clientSocket.Shutdown(SocketShutdown.Both);
clientSocket.Close();
Utils.LogUtils("Event: Tox send message failed, ClientId: " + mlink.clientId + ", ConnectId: " + tempConnectId);
Utils.LogUtils("Event: Close Connection, ClientId: " + mlink.clientId + ", ConnectId: " + tempConnectId);
break;
}
}
} catch (Exception e) {
Utils.LogUtils("Event: ERROR " + e.Message);
Utils.LogUtils(e.StackTrace);
if (mlink != null)
{
mlink.CloseRemote();
}
if (!closeFlag && clientSocket.Connected)
{
closeFlag = true;
clientSocket.Shutdown(SocketShutdown.Both);
clientSocket.Close();
if (mlink != null)
{
Utils.LogUtils("Event: Close Connection, ClientId: " + mlink.clientId + ", ConnectId: " + tempConnectId);
}
else
{
Utils.LogUtils("Event: Close Connection, ClinetId: null" + ", ConnectId: " + tempConnectId);
}
}
break;
}
}
}, TaskCreationOptions.LongRunning).ForgetOrThrow();
mlink = LinkClient.Connect(mSkynet, targetToxId, IPAddress.Parse(targetIP), Convert.ToInt32(targetPort),
// message handler
(msg) => {
try {
if (clientSocket != null && clientSocket.Connected)
{
clientSocket.Send(msg, SocketFlags.None);
}
} catch (Exception e) {
Utils.LogUtils("ERROR " + e.Message);
Utils.LogUtils(e.StackTrace);
mlink.CloseRemote();
if (!closeFlag && clientSocket.Connected)
{
closeFlag = true;
clientSocket.Shutdown(SocketShutdown.Both);
clientSocket.Close();
Utils.LogUtils("Event: Close Connection, ClientId: " + mlink.clientId + ", ConnectId: " + tempConnectId);
}
}
},
// close handler
() => {
if (!closeFlag && clientSocket.Connected)
{
closeFlag = true;
clientSocket.Shutdown(SocketShutdown.Both);
clientSocket.Close();
Utils.LogUtils("Event: Close Connection, ClientId: " + mlink.clientId + ", ConnectId: " + tempConnectId);
}
}
);
if (mlink == null)
{
// connected failed
Utils.LogUtils("Event: Connected failed, ClientId: null" + ", ConnectId: " + tempConnectId);
if (!closeFlag && clientSocket.Connected)
{
closeFlag = true;
clientSocket.Shutdown(SocketShutdown.Both);
clientSocket.Close();
Utils.LogUtils("Event: Close Connection, ClientId: null" + ", ConnectId: " + tempConnectId);
}
return;
}
if (tempData.Count != 0)
{
mlink.Send(tempData.ToArray(), tempData.Count);
}
// check if socket has closed
if (closeFlag)
{
// socket has closed
Utils.LogUtils("Event: Close Remote, ClientId: " + mlink.clientId + ", ConnectId: " + tempConnectId);
mlink.CloseRemote();
}
}).ForgetOrThrow();
}
}, TaskCreationOptions.LongRunning).ForgetOrThrow();
}
mSkynet.addNewReqListener((req) => {
// handle
if (req.toNodeId == "" && req.url == "/connect")
{
Utils.LogUtils("Event: Task Connect to " + req.fromNodeId + ", MessageId: " + req.uuid);
Task.Run(() => {
// connect to server received, create sockets
Utils.LogUtils("Event: Task Started Connect to " + req.fromNodeId);
try {
string reqStr = Encoding.UTF8.GetString(req.content);
string ipstr = reqStr.Split('\n') [0];
string port = reqStr.Split('\n') [1];
Utils.LogUtils("Event: Connect to " + ipstr + " " + port + " " + req.fromNodeId);
IPAddress targetIp = IPAddress.Parse(ipstr);
Socket mClientSocket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
bool closeFlag = false;
mClientSocket.Connect(new IPEndPoint(targetIp, Convert.ToInt32(port)));
Utils.LogUtils("Event: Connect to " + ipstr + " " + port + " Success " + req.fromNodeId);
var mlink = LinkClient.Connect(mSkynet, req.fromToxId, req.fromNodeId);
req.toNodeId = mlink.clientId;
Utils.LogUtils("Event: Connect to " + ipstr + " " + port + " Success " + req.fromNodeId + " , mLinkID: " + mlink.clientId);
mlink.OnMessage((msg) => {
try {
Utils.LogUtils("Event: Start Write Message, mLinkID: " + mlink.clientId);
if (mClientSocket != null && mClientSocket.Connected)
{
mClientSocket.Send(msg, SocketFlags.None);
}
Utils.LogUtils("Event: Write Message Success, mLinkID: " + mlink.clientId);
} catch (Exception e) {
Utils.LogUtils("Event: ERROR " + e.Message);
Utils.LogUtils(e.StackTrace);
mlink.CloseRemote();
if (!closeFlag && mClientSocket.Connected)
{
closeFlag = true;
mClientSocket.Shutdown(SocketShutdown.Both);
mClientSocket.Close();
Utils.LogUtils("Event: Close Socket" + ipstr + " " + port + " mLinkID " + mlink.clientId);
}
}
});
mlink.OnClose(() => {
if (!closeFlag && mClientSocket.Connected)
{
closeFlag = true;
mClientSocket.Shutdown(SocketShutdown.Both);
mClientSocket.Close();
Utils.LogUtils("Event: Close Socket" + ipstr + " " + port + " mLinkID " + mlink.clientId);
}
});
// send response after all handler has been set
mSkynet.sendResponse(req.createResponse(Encoding.UTF8.GetBytes("OK")), new ToxId(req.fromToxId));
Task.Factory.StartNew(() => {
while (true)
{
byte[] buf = new byte[1024 * 512];
try {
Utils.LogUtils("Event: Start Read Data, Clientid: " + mlink.clientId);
int size = 0;
if (mClientSocket != null && mClientSocket.Connected)
{
size = mClientSocket.Receive(buf);
}
else
{
Utils.LogUtils("Event: Socket already closed" + ipstr + " " + port + " mLinkID " + mlink.clientId);
break;
}
if (size == 0)
{
if (!closeFlag && mClientSocket.Connected)
{
Utils.LogUtils("Event: Close Connection, Clientid: " + mlink.clientId);
closeFlag = true;
mClientSocket.Shutdown(SocketShutdown.Both);
mClientSocket.Close();
}
mlink.CloseRemote();
break;
}
else
{
Utils.LogUtils("Event: Read Data " + size + ", Clientid: " + mlink.clientId);
}
var res = mlink.Send(buf, size);
if (!res)
{
// send failed
if (!closeFlag && mClientSocket.Connected)
{
closeFlag = true;
mClientSocket.Shutdown(SocketShutdown.Both);
mClientSocket.Close();
Utils.LogUtils("Event: Tox send message failed, Clientid: " + mlink.clientId);
break;
}
}
} catch (Exception e) {
/*if (e.ErrorCode != 10004) // this is not an error
* {
* Console.WriteLine("Time: " + Utils.UnixTimeNow() + " Event: ERROR " + e.Message);
* Console.WriteLine(e.StackTrace);
* }*/
Utils.LogUtils("Event: ERROR " + e.Message);
Utils.LogUtils(e.StackTrace);
mlink.CloseRemote();
if (!closeFlag && mClientSocket.Connected)
{
closeFlag = true;
mClientSocket.Shutdown(SocketShutdown.Both);
mClientSocket.Close();
Utils.LogUtils("Event: Close Connection, ClientId: " + mlink.clientId);
}
break;
}
}
}, TaskCreationOptions.LongRunning).ForgetOrThrow();
Utils.LogUtils("Event: Connect to " + ipstr + " " + port + " All Success " + req.fromNodeId + ", mLinkID: " + mlink.clientId);
} catch (Exception e) {
Utils.LogUtils("Event: ERROR " + e.Message);
Utils.LogUtils(e.StackTrace);
// connected failed
string reqStr = Encoding.UTF8.GetString(req.content);
string ipstr = reqStr.Split('\n') [0];
string port = reqStr.Split('\n') [1];
Utils.LogUtils("Event: Connect to " + ipstr + " " + port + " failed");
var response = req.createResponse(Encoding.UTF8.GetBytes("failed"));
mSkynet.sendResponse(response, new ToxId(response.toToxId));
}
}).ForgetOrThrow();
}
else if (req.toNodeId == "" && req.url == "/handshake")
{
var response = req.createResponse(Encoding.UTF8.GetBytes("OK"));
Utils.LogUtils("Event: HandShake from " + response.toToxId + ", MessageID: " + req.uuid);
Utils.LogUtils("Event: Send HandShake response " + response.uuid + ", ToxId: " + response.toToxId);
mSkynet.sendResponse(response, new ToxId(response.toToxId));
}
});
while (true)
{
Thread.Sleep(10);
}
}
public GrandParentsControllerTest()
{
mSkynet = new Skynet.Base.Skynet();
baseUrl = "http://localhost:" + mSkynet.httpPort + "/api/";
}
