public static void Send(WraperHeader header, TcpClient client) { byte[] byteArray = ByteArrayUtils.ToByteArray(header); Log.Information("Sending {0} bytes!", byteArray.Length); client.GetStream().Write(BitConverter.GetBytes(byteArray.Length), 0, sizeof(int)); client.GetStream().Write(byteArray, 0, byteArray.Length); }
public static void RegisterToMaster() { if (StorageProvider.GetInstance().GetTokenAsSlave() != "") { return; } RegisterHeader rh = new RegisterHeader { Ip = ConfigReader.GetInstance().Config.PredefinedIP, Port = ConfigReader.GetInstance().Config.Port }; WraperHeader wraperHeader = new WraperHeader { Data = ByteArrayUtils.ToByteArray(rh), Type = HeaderTypes.RegisterHeader }; TcpClient client = new TcpClient(ConfigReader.GetInstance().Config.Ip, ConfigReader.GetInstance().Config.MastersPort); Sender.Send(wraperHeader, client); new Reciever().ProcessClient(client); }
/// <summary> /// "Factory" method that creates the right request based on the <see cref="WraperHeader.type"/> /// </summary> /// <param name="wh"><see cref="WraperHeader"/> header with all the information</param> /// <returns><see cref="Request"/> with all the information inside</returns> internal static Request Factory(WraperHeader wh) { switch (wh.Type) { case HeaderTypes.ClientHelloHeader: return(new RequestWithHeader <ClientHelloHeader>(wh.Data)); case HeaderTypes.ServerHelloHeader: return(new RequestWithHeader <ServerHelloHeader>(wh.Data)); case HeaderTypes.JobHeader: return(new RequestWithHeader <JobHeader>(wh.Data)); case HeaderTypes.ServerAvailableHeader: return(new RequestWithHeader <ServerAvailableHeader>(wh.Data)); case HeaderTypes.JobResultHeader: return(new RequestWithHeader <JobResultHeader>(wh.Data)); case HeaderTypes.RegisterHeader: return(new RequestWithHeader <RegisterHeader>(wh.Data)); case HeaderTypes.RegisterResponseHeader: return(new RequestWithHeader <RegisterResponseHeader>(wh.Data)); case HeaderTypes.RequestFinishedOrderHeader: return(new RequestWithHeader <RequestFinishedOrderHeader>(wh.Data)); case HeaderTypes.FinishedOrderHeader: return(new RequestWithHeader <FinishedOrderHeader>(wh.Data)); default: return(new Request(wh.Data)); } }
/// <summary> /// Continuation of <see cref="ProcessClient"/> /// </summary> /// <param name="data">List of bytes read from the connection</param> /// <param name="client">the client that it was read from</param> public void ProcessData(List <byte> data, TcpClient client) { WraperHeader wh = ByteArrayUtils.FromByteArray <WraperHeader>(data.ToArray()); if (!CheckRequest(wh)) { return; } Request req = RequestFactory.Factory(wh); req.Client = client; Runner.Start(req); }
public static void RunAsSlave(RequestWithHeader <ServerAvailableHeader> sah) { ServerAvailableHeader sahresp = new ServerAvailableHeader() { Available = StorageProvider.GetInstance().NumberOfJobsToBeDone() == 0 ? true : false, UniqueToken = StorageProvider.GetInstance().GetTokenAsSlave() }; WraperHeader wraper = new WraperHeader() { Type = HeaderTypes.ServerAvailableHeader, Data = ByteArrayUtils.ToByteArray(sahresp) }; Sender.Send(wraper, sah.Client); }
/// <summary> /// Runs the logic for Client Hello /// </summary> /// <param name="ch"><see cref="ClientHello"/></param> public static void Run(RequestWithHeader <ClientHelloHeader> ch) { #if DEBUG Tuple <string, bool> auth = new Tuple <string, bool>("", true); #else Tuple <string, bool> auth = Authentification.AuthenticateClient(ch.header.ClientIP, ch.header.ClientToken); #endif string sha = ""; bool aproval = false; if (auth.Item2 == true) { aproval = DecideAproval(ch.header); if (aproval == false) { Log.Warning("Order was not approved, fetching already existing sha!"); sha = GetExistingSha(ch.header); auth = new Tuple <string, bool>("Error: Existing order with sha:" + sha, false); } else { sha = CreateSha(ch.header); Log.Information("Order was approved, new sha :{0}", sha); } } if (auth.Item1.Contains("Token:")) { StorageProvider.GetInstance().RegisterClientToken(ch.header.ClientIP, auth.Item1.Split(':')[1]); } // Wrap the ServerHello Header WraperHeader wraper = new WraperHeader { Type = HeaderTypes.ServerHelloHeader, Data = ByteArrayUtils.ToByteArray(CreateServerHelloHeader(aproval, sha, auth.Item1)) }; Sender.Send(wraper, ch.Client); // Wait for the orderpost if (aproval == true) { OrderReciever.ReicieveClientHello(ch, sha); } // If aproval is false, the connection will close }
public static void Run(RequestWithHeader <RequestFinishedOrderHeader> rfo) { #if DEBUG Tuple <string, bool> auth = new Tuple <string, bool>("", true); #else Tuple <string, bool> auth = Authentification.AuthenticateClient(rfo.header.Ip, rfo.header.ClientToken); #endif FinishedOrderHeader foh = new FinishedOrderHeader(); bool sendData = auth.Item2 == true && !StorageProvider.GetInstance().ClientHasOrder(rfo.header.Ip); string orderPath = Path.Combine(ConfigReader.GetInstance().Config.SavePath, rfo.header.Sha); string resultPath = Path.Combine(orderPath, "result"); string zipPath = Path.Combine(orderPath, "result.zip"); if (sendData) { if (!File.Exists(zipPath)) { ZipFile.CreateFromDirectory(resultPath, zipPath); } long size = new FileInfo(zipPath).Length; foh.Size = size; foh.Message = rfo.header.Sha; } else { foh.Size = 0; foh.Message = auth.Item1 == "" ? "You already have an order in progress" : auth.Item1; } WraperHeader wh = new WraperHeader() { Data = ByteArrayUtils.ToByteArray(foh), Type = HeaderTypes.FinishedOrderHeader }; Sender.Send(wh, rfo.Client); if (sendData) { Sender.SendZip(zipPath, rfo.Client.GetStream()); } }
public static void Run(RequestWithHeader <RegisterHeader> rh) { string token = ""; if (StorageProvider.GetInstance().SlaveExists(rh.header.Ip) == "") { token = Guid.NewGuid().ToString(); Slave slave = new Slave(rh.header.Ip, rh.header.Port, 0, token); StorageProvider.GetInstance().RegisterSlave(slave); } RegisterResponseHeader rrh = new RegisterResponseHeader { Token = token }; WraperHeader wh = new WraperHeader() { Data = ByteArrayUtils.ToByteArray(rrh), Type = HeaderTypes.RegisterResponseHeader }; Sender.Send(wh, rh.Client); }
public static void RequestResultFromMaster(string sha) { RequestFinishedOrderHeader rfo = new RequestFinishedOrderHeader() { #if DEBUG ClientToken = "", #else ClientToken = StorageProvider.GetInstance().GetClientsToken(), #endif Ip = ConfigReader.GetInstance().Config.PredefinedIP == "" ? Networking.GetIPAddress() : ConfigReader.GetInstance().Config.PredefinedIP, Sha = sha }; WraperHeader wh = new WraperHeader() { Data = ByteArrayUtils.ToByteArray(rfo), Type = HeaderTypes.RequestFinishedOrderHeader }; TcpClient client = new TcpClient(ConfigReader.GetInstance().Config.Ip, ConfigReader.GetInstance().Config.Port); Sender.Send(wh, client); new Reciever().ProcessClient(client); }
public bool CheckRequest(WraperHeader wh) { return(AllowedRequests.GetType(ConfigReader.GetInstance().Config.Type).Contains(wh.Type)); }