SmartClientControl.cs

using System;
using System.Data;
using System.Threading;


namespace GPRSWeb.SmartDeviceClient
{

//      /// <summary>
//      /// Processes Client Requests and manages client components
//      /// </summary>
//      public class SmartClientControl {
//              internal MessageLogger msgLog;
//
//              Thread processingThread;
//
//              
//              public SmartClientControl(MessageLogger log) {
//                      this.msgLog = log;
//                      try {
//                              log.Log("Initialising GRPSWeb Smart Client Library (Version {0}, Build {1})", System.Reflection.Assembly.GetExecutingAssembly().GetName().Version.ToString(2), System.Reflection.Assembly.GetExecutingAssembly().GetName().Version.Build);
//                      } catch (ApplicationException appEx) {
//                              throw new ApplicationException("Unable to create Client Control object\r\n" + appEx.ToString());
//                      }
//              }
//
//              /// <summary>
//              /// Called when protocol stack is reset, in case client needs to react to this information.
//              /// Currently it simply calles the reset connection handler in server stub, 
//              /// which calls the reset handler in the protocol stack
//              /// </summary>
//              public void ResetConnection() {
//                      msgLog.LogError("Connection Rest");
//                      serverStub.ResetConnection();
//              }
//
//              /// <summary>
//              /// Client's main processing loop. Called to run in own thread.
//              /// </summary>
//              protected void Run() {
//                      ClientHTTPRequestQueueObject currentReqQObj; 
//                      Connection client;
//                      try {
//                              while(true) {
//                                      // dequeue request
//                                      currentReqQObj = (ClientHTTPRequestQueueObject)userRequests.DequeueBlocking();
//
//                                      // Assign to client the connection we want to send the results to
//                                      client = currentReqQObj.connection;
//
//                                      // check to see if request can be serviced by cache
//                                      try {
//                                              if (clientCacheManager.CanService(currentReqQObj) && !currentReqQObj.HasPragmaNoCacheSet) { /*DISABLE CACHE*/
//                                                      clientCacheManager.ServiceReq(currentReqQObj, client); /*DISABLE CACHE*/
//                                              } else { // service from upstream /*DISABLE CACHE*/
//                                                      if (currentReqQObj.HasPragmaNoCacheSet) {
//                                                              myConsole.WriteLine("- Pragma: no-cache is set in request for {0}", currentReqQObj.URI);
//                                                      }
//                                                      serverStub.ServiceReq(currentReqQObj, client);
//                                              }/*DISABLE CACHE*/      
//                                      } catch (CacheNotFoundException ex) {
//                                              myConsole.WriteLine("*** "+ ex.ToString() + " ***");
//                                              myConsole.WriteLine("- Issuing regular request");
//                                              serverStub.ServiceReq(currentReqQObj, client);
//                                      }
//                              }
//                      } catch (ThreadAbortException) {
//                              myConsole.WriteLine("[Caught Thread Abort Exception: Shutting down Request Queue processor]");
//                      } catch (Exception ex) {
//                              myConsole.Error.WriteLine("*** Unhandled error in client library. Shutting Down ***\n{0}", ex);
//                              Stop();
//                      }
//              }
// 
//              public void Start() {
//                      this.processingThread = new Thread(new ThreadStart(run));
//                      serverStub.Start();
//                      processingThread.Start();
//                      connectionManager.Start();
//                      CacheIndexMessage ciMsg = clientCacheManager.GetCacheIndexMessage();/*DISABLE CACHE*/                   
//                      ciMsg.Destination = settings.ServerID;/*DISABLE CACHE*/                 
//                      serverStub.SendCacheIndexMessage(ciMsg);/*DISABLE CACHE*/                       
//              }
//
//              public void Stop() {
//                      myConsole.WriteLine("+++ Stopping Client Control library +++");
//                      if (processingThread != null && processingThread.IsAlive) {
//                              processingThread.Abort();
//                      }
//                      // stop child processes
//                      connectionManager.Stop();
//                      clientCacheManager.Stop();
//                      serverStub.Stop();
//                      // wait for termination of client control thread
//                      if (processingThread != null && processingThread.IsAlive) {
//                              processingThread.Join();
//                      }
//                      myConsole.WriteLine("+++ Client Control library Stopped +++");
//              }
//
//              public void Join() {
//                      processingThread.Join();
//              }
//      } 

        /*************************************************************************/


//      class ClientHTTPRequestQueueObject : HTTPRequestQueueObject {
//              public Connection connection;
//              public ClientHTTPRequestQueueObject(System.Net.Sockets.NetworkStream s) : base(s) {}
//              public ClientHTTPRequestQueueObject(HTTPRequest req) : base(req) {}
//      }

//      /*************************************************************************/
//      /// <summary>
//      /// Logs client activity
//      /// </summary>
//      public class Logger {
//              System.IO.StreamWriter textOut;
//              bool started;
//              ClientSettings settings;
//
//              /// <summary>
//              /// Default constructor. If logging enabled, starts logging.
//              /// </summary>
//              /// <param name="settings"></param>
//              public Logger(ClientSettings settings) {
//                      this.settings = settings;
//                      started = false;
//                      if (settings.LogRequests) { 
//                              Start(); 
//                      }
//              }
//
//              /// <summary>
//              /// Logs a given client request
//              /// </summary>
//              /// <param name="requestUri">URI of the client request</param>
//              /// <param name="startTime">time request received</param>
//              /// <param name="endTime">time request was completely serviced</param>
//              public void Log(Uri requestUri, DateTime startTime, DateTime endTime) {
//                      try {
//                              if (started) {
//                                      TimeSpan delta = endTime - startTime;
//                                      textOut.WriteLine("{0}\t{1}\t{2}\t{3}", requestUri.ToString(), delta.ToString(), startTime.ToString(), endTime.ToString()); 
//                                      textOut.Flush();
//                              }
//                      } catch (Exception ex) {
//                              myConsole.Error.WriteLine("*** Error Writing to Client Log: ***\n{0}", ex);
//                      }
//              }
//
//              /// <summary>
//              /// Begins logging of client-processed requests
//              /// </summary>
//              public void Start() {
//                      try {
//                              if (!started) {
//                                      textOut = new StreamWriter("usage.log", true); 
//                                      textOut.WriteLine("Logging started {0}", DateTime.Now.ToString());
//                                      started = true;
//                              } 
//                      } catch (Exception ex) {
//                              myConsole.Error.WriteLine("*** Error Starting Client Log: ***\n{0}", ex);
//                      }
//              }
//
//              /// <summary>
//              /// Ends logging of client-processed requests
//              /// </summary>
//              public void Stop() {
//                      try {
//                              if (started) {
//                                      textOut.WriteLine("Logging stopped {0}", DateTime.Now.ToString());
//                                      textOut.WriteLine();
//                                      textOut.Close();
//                              }
//                      } catch (Exception ex) {
//                              myConsole.Error.WriteLine("*** Error Closing Client Log: ***\n{0}", ex);
//                      }
//              }
//      }
}

---