/ - Diff - OpenData vlastní téma (KIV) - Tři Mušketýři - Redmine

« Předchozí | Další »

Revize 8800fb76

Přidáno uživatelem Eliška Mourycová před více než 3 roky(ů)

ID 8800fb76416bb860e3388d63bc2b1c4f9f998b11
Rodič bf95cbdd
Potomek 9cc42e60

Refactor, cleanup + usage of logging class instead of 'Console.WriteLine's.

     using System.Threading;
     using System.Web;
     using System.Security.Cryptography.X509Certificates;
     using log4net;
     namespace ServerApp.Connection
+    {
     	/// <summary>
     	/// Class taking care of receiving the client side requests and sending back responses
     	/// </summary>
     	public class ConnectionListenerAsync
+    	{
     		// logger class instance
     		private static readonly ILog logger = LogManager.GetLogger(typeof(ConnectionListenerAsync));
     		// the port to listen on
     		private readonly int PORT;
     		// the predictor class instance
     		private IPredictionController predictionController;
     		public ConnectionListenerAsync(int port, IPredictionController predictionController)
-...
     			this.predictionController = predictionController;
+    		}
     		/// <summary>
     		/// Starts asynchronously waiting for requests. Handles them when they come.
     		/// </summary>
     		public void StartListening()
+    		{
     			string ip = GetLocalIPAddress();
     			Console.WriteLine("ip : " + ip);
     			//Console.WriteLine("ip : " + ip);
     			HttpListener listener = new HttpListener();
                 listener.Prefixes.Add($"https://*:{PORT}/");
                 //listener.Prefixes.Add($"http://*:{PORT}/");
-...
                 listener.Start();
     			Console.WriteLine("Listening...");
     			//Console.WriteLine("Listening...");
     			logger.Info("Started listening at ip: " + ip + ", port: " + PORT);
     			var result = listener.BeginGetContext(ListenerCallback, listener);
-...
     		private void HandleRequest(HttpListenerContext context)
+    		{
     			Console.WriteLine("Handling request.");
     			//Console.WriteLine("Handling request.");
     			logger.Debug("Handling request.");
     			// Obtain a request object.
     			HttpListenerRequest request = context.Request;
     			// Obtain a response object.
-...
     			// Construct a response.
     			if (context.Request.HttpMethod == "GET") // when client says download
+    			{
     				Console.WriteLine("received GET request");
     				logger.Info("received GET request");
     				string text;
     				using (var reader = new StreamReader(context.Request.InputStream, context.Request.ContentEncoding))
-...
+    			}
     			else if (context.Request.HttpMethod == "POST") // when client says upload
+    			{
     				Console.WriteLine("received POST request");
     				logger.Info("received POST request");
     				string text;
     				using (var reader = new StreamReader(context.Request.InputStream, context.Request.ContentEncoding))
     					text = reader.ReadToEnd();
-...
+    			}
     			else
+    			{
     				Console.WriteLine("received request other than GET or POST");
     				logger.Warn("received request other than GET or POST");
+    			}
-...
     			System.IO.Stream output = response.OutputStream;
     			if (!string.IsNullOrEmpty(responseString))
+    			{
     				Console.WriteLine("Response is not null or empty, sending it to the client.");
     				logger.Debug("Response is not null or empty, sending it to the client.");
     				byte[] buffer = System.Text.Encoding.UTF8.GetBytes(responseString);
     				// Get a response stream and write the response to it.
-...
+    			}
     			else
+    			{
     				Console.WriteLine("Response was null or empty, not sending anything.");
     				logger.Debug("Response was null or empty, not sending anything.");
+    			}
-...
     			//output.Close();
     			response.Close();
     			Console.WriteLine("At the end of HandleRequest");
     			logger.Debug("At the end of HandleRequest");
+    		}
     		private void ListenerCallback(IAsyncResult result)
+    		{
     			Console.WriteLine("in ListenerCallback");
     			logger.Debug("in ListenerCallback");
     			HttpListener listener = (HttpListener)result.AsyncState;
     			// Call EndGetContext to complete the asynchronous operation.
-...
     			// Construct a response.
     			if (context.Request.HttpMethod == "GET") // when client says download
+    			{
     				Console.WriteLine("received GET request");
     				logger.Info("received GET request");
     				string text;
     				using (var reader = new StreamReader(context.Request.InputStream, context.Request.ContentEncoding))
-...
+    			}
     			else if (context.Request.HttpMethod == "POST") // when client says upload
+    			{
     				Console.WriteLine("received POST request");
     				logger.Info("received POST request");
     				string text;
     				using (var reader = new StreamReader(context.Request.InputStream, context.Request.ContentEncoding))
     					text = reader.ReadToEnd();
-...
+    			}
     			else
+    			{
     				Console.WriteLine("received request other than GET or POST");
     				logger.Warn("received request other than GET or POST");
+    			}
     			System.IO.Stream output = response.OutputStream;
     			if (!string.IsNullOrEmpty(responseString))
+    			{
     				Console.WriteLine("Response is not null or empty, sending it to the client.");
     				logger.Debug("Response is not null or empty, sending it to the client.");
     				byte[] buffer = System.Text.Encoding.UTF8.GetBytes(responseString);
     				// Get a response stream and write the response to it.
-...
+    			}
     			else
+    			{
     				Console.WriteLine("Response was null or empty, not sending anything.");
     				logger.Debug("Response was null or empty, not sending anything.");
+    			}
-...
     			output.Close();
     			response.Close();
     			Console.WriteLine("At the end of ListenerCallback");
     			logger.Debug("At the end of ListenerCallback");
+    		}
-...
     			//return xml;
     			Console.WriteLine("Constructing a response for GET request.");
     			Console.WriteLine("Request string: ");
     			Console.WriteLine(requestString);
     			logger.Info("Constructing a response for GET request.");
     			logger.Info("Request string: ");
     			logger.Info(requestString);
     			// prepare the type:
     			Request newRequest = new Request();
     			//Request newRequest = new Request();
     			Request requestDeserialized = null;
     			try
+    			{
     				Console.WriteLine("Trying to deserialize xml request.");
     				logger.Info("Trying to deserialize xml request.");
     				requestDeserialized = XmlCommunication.Deserialize<Request>(requestString);
+    			}
     			catch
+    			{
     				Console.WriteLine("wrong format of request!");
     				logger.Warn("Wrong format of request!");
     				// don't bother to send anything:
     				return string.Empty;
-...
     			// get the prediction from the model:
     			Console.WriteLine("Getting the prediction from the predictor.");
     			Console.WriteLine("Deserialized request is null? : " + requestDeserialized == null);
     			logger.Info("Getting the prediction from the predictor.");
     			logger.Debug("Deserialized request is null? : " + requestDeserialized == null);
     			Response responsePrediction = predictionController.Predict(requestDeserialized);
     			string constructedXml = XmlCommunication.Serialize(responsePrediction);
     			Console.WriteLine("Constructed response:");
     			Console.WriteLine(constructedXml);
     			logger.Info("Constructed response:");
     			logger.Info(constructedXml);
     			// build the xml from the prediction: - TODO mbe an exception can happen here as well? - it shouldnt
     			return constructedXml;//XmlCommunication.Serialize(responsePrediction);
-...
     		private string ConstructPOSTResponse(string requestString)
+    		{
     			Console.WriteLine("Constructing a response for POST request.");
     			Console.WriteLine("Request string: ");
     			Console.WriteLine(requestString);
     			logger.Info("Constructing a response for POST request.");
     			logger.Info("Request string: ");
     			logger.Info(requestString);
     			// prepare the type:
     			Request newRequest = new Request();
     			//Request newRequest = new Request();
     			Request requestDeserialized = null;
     			try
+    			{
     				Console.WriteLine("Trying to deserialize xml request.");
     				logger.Info("Trying to deserialize xml request.");
     				requestDeserialized = XmlCommunication.Deserialize<Request>(requestString);
+    			}
     			catch
+    			{
     				Console.WriteLine("wrong format of request!");
     				logger.Warn("wrong format of request!");
     				// don't bother to send anything:
     				return string.Empty;
-...
     			// get the prediction from the model:
     			Console.WriteLine("Getting the prediction from the predictor.");
     			Console.WriteLine("Deserialized request is null? : " + requestDeserialized == null);
     			logger.Info("Getting the prediction from the predictor.");
     			logger.Debug("Deserialized request is null? : " + requestDeserialized == null);
     			Response responsePrediction = predictionController.Predict(requestDeserialized);
     			string constructedXml = XmlCommunication.Serialize(responsePrediction);
     			Console.WriteLine("Constructed response:");
     			Console.WriteLine(constructedXml);
     			logger.Info("Constructed response:");
     			logger.Info(constructedXml);
     			// build the xml from the prediction: - TODO mbe an exception can happen here as well? - it shouldnt
     			return constructedXml;//XmlCommunication.Serialize(responsePrediction);
-...
+    		}
+    	}
     		// TODO clean this up --->
     		// -----------------------------------------------------------------------------
     		public class ConnectionListener
+    		{
     		private readonly int PORT;
     		private IPredictionController predictionController;
     		public ConnectionListener(int port, IPredictionController predictionController)
+    		{
     			this.PORT = port;
     			this.predictionController = predictionController;
+    		}
     		public void StartListening()
+    		{
     			string ip = GetLocalIPAddress();
     			Console.WriteLine("ip : " + ip);
     			HttpListener server = new HttpListener();
     			//server.Prefixes.Add($"https://{ip}:{PORT}/");
     			server.Prefixes.Add($"http://localhost:{PORT}/");
     			server.Start();
     			Console.WriteLine("Listening...");
     			while (true)
+    			{
     				Console.WriteLine("Waiting for a client request...");
     				//ThreadPool.QueueUserWorkItem(Process, server.GetContext());
     				HttpListenerContext context = server.GetContext();
     				if (context.Request.HttpMethod == "GET") // when client says download
+    				{
     					Console.WriteLine("received GET request");
     					HttpListenerResponse response = context.Response;
     					response.AddHeader("Access-Control-Allow-Credentials", "true");
     					response.AddHeader("Access-Control-Expose-Headers", "ETag");
     					response.AddHeader("Access-Control-Allow-Headers", "Accept, X-Access-Token, X-Application-Name, X-Request-Sent-Time");
     					response.AddHeader("Access-Control-Allow-Methods", "GET, POST, OPTIONS");
     					response.AddHeader("Access-Control-Allow-Origin", "*");
     					//string page = Directory.GetCurrentDirectory() + context.Request.Url.LocalPath;
     					// if (page == string.Empty)
     					//     page = "test.txt";
     					//
     					// TextReader tr = new StreamReader(page);
     					// string msg = tr.ReadToEnd();
     					int rand = new Random().Next(1, 10);
     					string msg = "This is a response from the server :) " + rand;
     					Response xmlResp = Response.Randomize();
     					var xml = XmlCommunication.Serialize(xmlResp);
     					//Console.WriteLine(xml);
     					msg = xml;
     					byte[] buffer = Encoding.UTF8.GetBytes(msg);
     					response.ContentLength64 = buffer.Length;
     					Stream st = response.OutputStream;
     					st.Write(buffer, 0, buffer.Length);
     					context.Response.Close();
+    				}
     				else if (context.Request.HttpMethod == "POST") // when client says upload
+    				{
     					Console.WriteLine("received POST request");
     					string text;
     					using (var reader = new StreamReader(context.Request.InputStream, context.Request.ContentEncoding))
     						text = reader.ReadToEnd();
     					Console.WriteLine("Received request:");
     					string requestXML = HttpUtility.UrlDecode(text);
     					Console.WriteLine(requestXML);
     					// prepare the type:
     					Request newRequest = new Request();
     					Request requestDeserialized = null;
     					try
+    					{
     						requestDeserialized = XmlCommunication.Deserialize<Request>(requestXML);
+    					}
     					catch
+    					{
     						Console.WriteLine("wrong format of request!");
     						// don't bother to send anything:
     						context.Response.Close();
     						continue;
+    					}
     					// response headers:
     					HttpListenerResponse response = context.Response;
     					response.AddHeader("Access-Control-Allow-Credentials", "true");
     					response.AddHeader("Access-Control-Expose-Headers", "ETag");
     					response.AddHeader("Access-Control-Allow-Headers", "Accept, X-Access-Token, X-Application-Name, X-Request-Sent-Time");
     					response.AddHeader("Access-Control-Allow-Methods", "GET, POST, OPTIONS");
     					response.AddHeader("Access-Control-Allow-Origin", "*");
     					// get the prediction from the model:
     					Response responsePrediction = predictionController.Predict(requestDeserialized);
     					int rand = new Random().Next(1, 10);
     					string msg = "OK " + rand;
     					// build the xml from the prediction: - TODO mbe an exception can happen here as well? - it shouldnt
     					msg = XmlCommunication.Serialize(responsePrediction);
     					// send the response:
     					byte[] buffer = Encoding.UTF8.GetBytes(msg);
     					response.ContentLength64 = buffer.Length;
     					Stream st = response.OutputStream;
     					st.Write(buffer, 0, buffer.Length);
     					// close
     					context.Response.Close(); // ?? Works better with this, if this line is absent, the client gets 'stuck' after approximately 6 messages
+    				}
     				else
+    				{
     					Console.WriteLine("received request other than GET or POST");
     					Console.WriteLine("method: " + context.Request.HttpMethod);
     					Console.WriteLine("headers: " + context.Request.Headers);
     					Console.WriteLine("whole request?: " + context.Request);
     					Console.WriteLine("user: " + context.User);
     					//HttpListenerResponse response = context.Response;
     					//response.AddHeader("Access-Control-Allow-Credentials", "true");
     					//response.AddHeader("Access-Control-Expose-Headers", "ETag");
     					//response.AddHeader("Access-Control-Allow-Headers", "Accept, X-Access-Token, X-Application-Name, X-Request-Sent-Time, Origin, Content-Type, X-Auth-Token");
     					//response.AddHeader("Access-Control-Allow-Methods", "GET, POST, OPTIONS");
     					//response.AddHeader("Access-Control-Allow-Origin", "*");
     					//string msg = "Preflight check? ";
     					//byte[] buffer = Encoding.UTF8.GetBytes(msg);
     					//response.ContentLength64 = buffer.Length;
     					//Stream st = response.OutputStream;
     					//st.Write(buffer, 0, buffer.Length);
     					//context.Response.Close(); // ??
+    				}
+    			}
+    		}
     		private string GetLocalIPAddress()
+    		{
     			var host = Dns.GetHostEntry(Dns.GetHostName());
     			foreach (var ip in host.AddressList)
+    			{
     				if (ip.AddressFamily == AddressFamily.InterNetwork)
+    				{
     					return ip.ToString();
+    				}
+    			}
     			throw new Exception("No network adapters with an IPv4 address in the system!");
+    		}
+    	}
     	// ---------------------------------------------------------------------------
     	class ClientService
+    	{
     		public static readonly int MAX_IDS = 1000000; // ??
     		public static int IDs = 0;
     		public int UniqueID;
     		public Request ClientRequest;
     		public Response ClientResponse;
+        }
         public class ConnectionListenerQueue
+        {
             private readonly int PORT;
             private ConcurrentDictionary<int, ClientService> readyRequests;
             private ConcurrentQueue<ClientService> waitingRequests;
             public ConnectionListenerQueue(int port)
+            {
                 this.PORT = port;
+            }
     		private void RequestHandler()
+    		{
     			while (true)
+    			{
     				if (!waitingRequests.IsEmpty)
+    				{
     					Console.WriteLine("handling a request for 10s...");
     					ClientService nextService;
     					bool deqResultOk = waitingRequests.TryDequeue(out nextService);
     					// nextService has ID and request filled out
     					Thread.Sleep(10000);
     					Console.WriteLine("finished building response, adding it to the dictionary...");
     					//ClientService service = new ClientService();
     					//service.UniqueID = GetNextID();
     					//service.ClientRequest = Request.Randomize();
     					nextService.ClientResponse = Response.Randomize();
     					bool resultOk = readyRequests.TryAdd(nextService.UniqueID, nextService);
     					if (!resultOk)
+    					{
     						Console.WriteLine("ID " + nextService.UniqueID + " is being used!");
     						// do nothing? - keep it in the queue and let the client try later perhaps?
+    					}
     					else
+    					{
     						// added to dictionary
     						// -> remove it from the queue
+    					}
+    				}
     				else
+    				{
     					Thread.Sleep(100); // ??
+    				}
+    			}
+    		}
     		private int GetNextID()
+    		{
     			int id = (ClientService.IDs++) % ClientService.MAX_IDS; // we presume that after a million requests, the first ids are free again, if not, tough luck
     			return id;
+    		}
             public void StartListening()
+            {
                 string ip = GetLocalIPAddress();
                 Console.WriteLine("ip : " + ip);
                 HttpListener server = new HttpListener();
                 //server.Prefixes.Add($"https://{ip}:{PORT}/");
                 server.Prefixes.Add($"http://localhost:{PORT}/");
                 server.Start();
                 Console.WriteLine("Listening...");
     			waitingRequests = new ConcurrentQueue<ClientService>();
     			readyRequests = new ConcurrentDictionary<int, ClientService>();
     			Thread requestHandlerThread = new Thread(RequestHandler);
     			requestHandlerThread.Start();
     			while (true)
+                {
                     Console.WriteLine("Waiting for a client request...");
     				//Console.ReadLine();
     				HttpListenerContext context = server.GetContext();
     				//Thread.Sleep(10000);
     				//IAsyncResult result = server.BeginGetContext(new AsyncCallback(ListenerCallback), server);
     				//Console.WriteLine("Waiting for request to be processed asyncronously.");
     				//result.AsyncWaitHandle.WaitOne();
     				//Console.WriteLine("Request processed asyncronously.");
     				if (context.Request.HttpMethod == "GET") // when client says download
+    				{
     					Console.WriteLine("received GET request");
     					HttpListenerResponse response = context.Response;
     					response.AddHeader("Access-Control-Allow-Credentials", "true");
     					response.AddHeader("Access-Control-Expose-Headers", "ETag");
     					response.AddHeader("Access-Control-Allow-Headers", "Accept, X-Access-Token, X-Application-Name, X-Request-Sent-Time");
     					response.AddHeader("Access-Control-Allow-Methods", "GET, POST, OPTIONS");
     					response.AddHeader("Access-Control-Allow-Origin", "*");
     					//string page = Directory.GetCurrentDirectory() + context.Request.Url.LocalPath;
     					// if (page == string.Empty)
     					//     page = "test.txt";
     					//
     					// TextReader tr = new StreamReader(page);
     					// string msg = tr.ReadToEnd();
     					int rand = new Random().Next(1, 10);
     					string msg = "This is a response from the server :) " + rand;
     					Response xmlResp = Response.Randomize();
     					var xml = XmlCommunication.Serialize(xmlResp);
     					//Console.WriteLine(xml);
     					msg = xml;
     					byte[] buffer = Encoding.UTF8.GetBytes(msg);
     					response.ContentLength64 = buffer.Length;
     					Stream st = response.OutputStream;
     					st.Write(buffer, 0, buffer.Length);
     					context.Response.Close();
+    				}
     				else if (context.Request.HttpMethod == "POST") // when client says upload
+    				{
     					Console.WriteLine("received POST request");
     					string text;
     					using (var reader = new StreamReader(context.Request.InputStream, context.Request.ContentEncoding))
     						text = reader.ReadToEnd();
     					Console.WriteLine("Received request:");
     					string requestXML = HttpUtility.UrlDecode(text);
     					Console.WriteLine(requestXML);
     					Request newRequest = new Request();
     					Request requestDeserialized = XmlCommunication.Deserialize<Request>(requestXML);
     					ClientService newService = new ClientService();
     					newService.UniqueID = GetNextID();
     					newService.ClientRequest = requestDeserialized;
     					// save the request to the queue
     					waitingRequests.Enqueue(newService);
     					// SEND THE ID: - TODO xml format also
     					HttpListenerResponse response = context.Response;
     					response.AddHeader("Access-Control-Allow-Credentials", "true");
     					response.AddHeader("Access-Control-Expose-Headers", "ETag");
     					response.AddHeader("Access-Control-Allow-Headers", "Accept, X-Access-Token, X-Application-Name, X-Request-Sent-Time");
     					response.AddHeader("Access-Control-Allow-Methods", "GET, POST, OPTIONS");
     					response.AddHeader("Access-Control-Allow-Origin", "*");
     					int rand = new Random().Next(1, 10);
     					string msg = "" + newService.UniqueID;
     					byte[] buffer = Encoding.UTF8.GetBytes(msg);
     					response.ContentLength64 = buffer.Length;
     					Stream st = response.OutputStream;
     					st.Write(buffer, 0, buffer.Length);
     					context.Response.Close(); // ?? Works better with this, if this line is absent, the client gets 'stuck' after approximately 6 messages
+    				}
     				else
+    				{
     					Console.WriteLine("received request other than GET or POST");
     					Console.WriteLine("method: " + context.Request.HttpMethod);
     					Console.WriteLine("headers: " + context.Request.Headers);
     					Console.WriteLine("whole request?: " + context.Request);
     					Console.WriteLine("user: " + context.User);
     					//HttpListenerResponse response = context.Response;
     					//response.AddHeader("Access-Control-Allow-Credentials", "true");
     					//response.AddHeader("Access-Control-Expose-Headers", "ETag");
     					//response.AddHeader("Access-Control-Allow-Headers", "Accept, X-Access-Token, X-Application-Name, X-Request-Sent-Time, Origin, Content-Type, X-Auth-Token");
     					//response.AddHeader("Access-Control-Allow-Methods", "GET, POST, OPTIONS");
     					//response.AddHeader("Access-Control-Allow-Origin", "*");
     					//string msg = "Preflight check? ";
     					//byte[] buffer = Encoding.UTF8.GetBytes(msg);
     					//response.ContentLength64 = buffer.Length;
     					//Stream st = response.OutputStream;
     					//st.Write(buffer, 0, buffer.Length);
     					//context.Response.Close(); // ??
+    				}
+    			}
+            }
     		private void ListenerCallback(IAsyncResult result)
+    		{
     			HttpListener listener = (HttpListener)result.AsyncState;
     			// Call EndGetContext to complete the asynchronous operation.
     			HttpListenerContext context = listener.EndGetContext(result);
     			Console.WriteLine("callbacking...");
     			Thread.Sleep(10000);
     			if (context.Request.HttpMethod == "GET") // when client says download
+    			{
     				Console.WriteLine("received GET request");
     				HttpListenerResponse response = context.Response;
     				response.AddHeader("Access-Control-Allow-Credentials", "true");
     				response.AddHeader("Access-Control-Expose-Headers", "ETag");
     				response.AddHeader("Access-Control-Allow-Headers", "Accept, X-Access-Token, X-Application-Name, X-Request-Sent-Time");
     				response.AddHeader("Access-Control-Allow-Methods", "GET, POST, OPTIONS");
     				response.AddHeader("Access-Control-Allow-Origin", "*");
     				//string page = Directory.GetCurrentDirectory() + context.Request.Url.LocalPath;
     				// if (page == string.Empty)
     				//     page = "test.txt";
     				//
     				// TextReader tr = new StreamReader(page);
     				// string msg = tr.ReadToEnd();
     				int rand = new Random().Next(1, 10);
     				string msg = "This is a response from the server :) " + rand;
     				Response xmlResp = Response.Randomize();
     				var xml = XmlCommunication.Serialize(xmlResp);
     				//Console.WriteLine(xml);
     				msg = xml;
     				byte[] buffer = Encoding.UTF8.GetBytes(msg);
     				response.ContentLength64 = buffer.Length;
     				Stream st = response.OutputStream;
     				st.Write(buffer, 0, buffer.Length);
     				context.Response.Close();
+    			}
     			else if (context.Request.HttpMethod == "POST") // when client says upload
+    			{
     				Console.WriteLine("received POST request");
     				string text;
     				using (var reader = new StreamReader(context.Request.InputStream, context.Request.ContentEncoding))
     					text = reader.ReadToEnd();
     				Console.WriteLine("Received request:");
     				Console.WriteLine(HttpUtility.UrlDecode(text));
     				HttpListenerResponse response = context.Response;
     				response.AddHeader("Access-Control-Allow-Credentials", "true");
     				response.AddHeader("Access-Control-Expose-Headers", "ETag");
     				response.AddHeader("Access-Control-Allow-Headers", "Accept, X-Access-Token, X-Application-Name, X-Request-Sent-Time");
     				response.AddHeader("Access-Control-Allow-Methods", "GET, POST, OPTIONS");
     				response.AddHeader("Access-Control-Allow-Origin", "*");
     				int rand = new Random().Next(1, 10);
     				string msg = "OK " + rand;
     				byte[] buffer = Encoding.UTF8.GetBytes(msg);
     				response.ContentLength64 = buffer.Length;
     				Stream st = response.OutputStream;
     				st.Write(buffer, 0, buffer.Length);
     				context.Response.Close(); // ?? Works better with this, if this line is absent, the client gets 'stuck' after approximately 6 messages
+    			}
     			else
+    			{
     				Console.WriteLine("received request other than GET or POST");
     				Console.WriteLine("method: " + context.Request.HttpMethod);
     				Console.WriteLine("headers: " + context.Request.Headers);
     				Console.WriteLine("whole request?: " + context.Request);
     				Console.WriteLine("user: " + context.User);
     				//HttpListenerResponse response = context.Response;
     				//response.AddHeader("Access-Control-Allow-Credentials", "true");
     				//response.AddHeader("Access-Control-Expose-Headers", "ETag");
     				//response.AddHeader("Access-Control-Allow-Headers", "Accept, X-Access-Token, X-Application-Name, X-Request-Sent-Time, Origin, Content-Type, X-Auth-Token");
     				//response.AddHeader("Access-Control-Allow-Methods", "GET, POST, OPTIONS");
     				//response.AddHeader("Access-Control-Allow-Origin", "*");
     				//string msg = "Preflight check? ";
     				//byte[] buffer = Encoding.UTF8.GetBytes(msg);
     				//response.ContentLength64 = buffer.Length;
     				//Stream st = response.OutputStream;
     				//st.Write(buffer, 0, buffer.Length);
     				//context.Response.Close(); // ??
+    			}
     			//HttpListenerRequest request = context.Request;
     			//// Obtain a response object.
     			//HttpListenerResponse response = context.Response;
     			//// Construct a response.
     			//string responseString = "<HTML><BODY> Hello world!</BODY></HTML>";
     			//byte[] buffer = System.Text.Encoding.UTF8.GetBytes(responseString);
     			//// Get a response stream and write the response to it.
     			//response.ContentLength64 = buffer.Length;
     			//System.IO.Stream output = response.OutputStream;
     			//output.Write(buffer, 0, buffer.Length);
     			//// You must close the output stream.
     			//output.Close();
+    		}
     		private string GetLocalIPAddress()
+            {
                 var host = Dns.GetHostEntry(Dns.GetHostName());
                 foreach (var ip in host.AddressList)
+                {
                     if (ip.AddressFamily == AddressFamily.InterNetwork)
+                    {
                         return ip.ToString();
+                    }
+                }
                 throw new Exception("No network adapters with an IPv4 address in the system!");
+            }
+        }
+    }

     // Author: Eliska Mourycova
     //
     using log4net;
     using System;
     using System.Collections.Generic;
     using System.IO;
-...
     		private List<string> variablesInsertions;
     		private List<char> nameTurns;
     		// logger class instance
     		private static readonly ILog logger = LogManager.GetLogger(typeof(DataDownloader));
     		public DataDownloader(string rootDataDir, string website, string namingConvention, string weatherPredSite) // todo: take naming conventons specifiaction into account
+    		{
     			// initialize all needed variables:
-...
     			catch(Exception e)
+    			{
     				// this shouldn't happen
     				Console.WriteLine("Weather prediction download failed!");
     				//Console.WriteLine("Weather prediction download failed!");
     				logger.Error("Weather prediction download failed!");
     				return null;
+    			}
-...
     			else
     				AddToVariables(currVar);
     			Console.WriteLine();
     			//Console.WriteLine();
+    		}
     		// Adds to name parts
-...
     			for (int i = 0; i < files.Length; i++)
+    			{
     				string currFileName = Path.GetFileName(files[i]);
     				Console.WriteLine("curr file: " + currFileName);
     				//Console.WriteLine("curr file: " + currFileName);
     				string[] splits = currFileName.Split(new char[] { '-', '.' });
     				int month = int.Parse(splits[0]);

     			inputThread.Start();
     			// connection test
     			//ConnectionTest(controller, config);
     			ConnectionTest(controller, config);
     			Console.ReadLine();
+            }

Také k dispozici: Unified diff

Projekt

Obecné

Profil

ASWI - Pokročilé softwarové inženýrství » ASWI 2021 » OpenData vlastní téma (KIV) - Tři Mušketýři

Revize 8800fb76

Přidáno uživatelem Eliška Mourycová před více než 3 roky(ů)