Changeset 2740


Ignore:
Timestamp:
06/29/12 11:24:55 (2 years ago)
Author:
lowjoel
Message:

Remove the old RemoteExecutor? classes. We are having IPC with just remoting now.

File:
1 edited

Legend:

Unmodified
Added
Removed
  • branches/eraser6/EraserService/Eraser.Manager/RemoteExecutor.cs

    r2738 r2740  
    2323using System; 
    2424using System.Text; 
    25 using System.IO; 
    26 using System.IO.Pipes; 
    27 using System.Threading; 
    2825using System.Collections.Generic; 
    2926 
     
    3128using System.Runtime.Remoting.Channels; 
    3229using System.Runtime.Remoting.Channels.Ipc; 
    33 using System.Runtime.Serialization; 
    34 using System.Runtime.Serialization.Formatters.Binary; 
    3530using System.Security.Principal; 
    36 using System.Security.AccessControl; 
     31//using System.Security.AccessControl; 
    3732 
    3833namespace Eraser.Manager 
    3934{ 
    40     /// <summary> 
    41     /// Represents a request to the RemoteExecutorServer instance 
    42     /// </summary> 
    43     [Serializable] 
    44     internal class RemoteExecutorRequest 
    45     { 
    46         /// <summary> 
    47         /// Constructor. 
    48         /// </summary> 
    49         /// <param name="func">The function this command is wanting to execute.</param> 
    50         /// <param name="data">The parameters for the command, serialised using a 
    51         /// BinaryFormatter</param> 
    52         public RemoteExecutorRequest(RemoteExecutorFunction func, params object[] data) 
    53         { 
    54             Func = func; 
    55             Data = data; 
    56         } 
    57  
    58         /// <summary> 
    59         /// The function that this request is meant to call. 
    60         /// </summary> 
    61         public RemoteExecutorFunction Func { get; set; } 
    62  
    63         /// <summary> 
    64         /// The parameters associated with the function call. 
    65         /// </summary> 
    66         public object[] Data { get; private set; } 
    67     }; 
    68  
    69     /// <summary> 
    70     /// List of supported functions 
    71     /// </summary> 
    72     public enum RemoteExecutorFunction 
    73     { 
    74         QueueTask, 
    75         ScheduleTask, 
    76         UnqueueTask, 
    77  
    78         AddTask, 
    79         DeleteTask, 
    80         //UpdateTask, 
    81         GetTaskCount, 
    82         GetTask 
    83     } 
    84  
    8535    /// <summary> 
    8636    /// The RemoteExecutorServer class is the server half required for remote execution 
     
    192142            } 
    193143 
    194             // Create an instance of the remote object. 
    195             DirectExecutor server = (DirectExecutor)Activator.GetObject(typeof(DirectExecutor), 
    196                 "ipc://localhost:9090/" + RemoteExecutorServer.ServerName); 
    197             ExecutorTasksCollection tasks = server.Tasks; 
    198             int x = tasks.Count; 
     144            Run(); 
    199145        } 
    200146 
    201147        protected override void Dispose(bool disposing) 
    202148        { 
    203             if (client == null) 
     149            Client = null; 
     150            base.Dispose(disposing); 
     151        } 
     152 
     153        public override void Run() 
     154        { 
     155            //This function should be idempotent since our constructor will call us. 
     156            if (Client != null) 
    204157                return; 
    205158 
    206             if (disposing) 
    207             { 
    208                 client.Close(); 
    209             } 
    210  
    211             client = null; 
    212             base.Dispose(disposing); 
    213         } 
    214  
    215         public override void Run() 
    216         { 
    217159            try 
    218160            { 
    219                 client.Connect(0); 
    220             } 
    221             catch (TimeoutException) 
    222             { 
    223             } 
    224         } 
    225  
    226         /// <summary> 
    227         /// Sends a request to the executor server. 
    228         /// </summary> 
    229         /// <typeparam name="ReturnType">The expected return type of the request.</typeparam> 
    230         /// <param name="function">The requested operation.</param> 
    231         /// <param name="args">The arguments for the operation.</param> 
    232         /// <returns>The return result from the object as if it were executed locally.</returns> 
    233         internal ReturnType SendRequest<ReturnType>(RemoteExecutorFunction function, params object[] args) 
    234         { 
    235             //Connect to the server 
    236             object result = null; 
    237  
    238             using (MemoryStream mStream = new MemoryStream()) 
    239             { 
    240                 //Serialise the request 
    241                 new BinaryFormatter().Serialize(mStream, new RemoteExecutorRequest(function, args)); 
    242  
    243                 //Write the request to the pipe 
    244                 byte[] buffer = mStream.ToArray(); 
    245                 client.Write(buffer, 0, buffer.Length); 
    246  
    247                 //Read the response from the pipe 
    248                 mStream.Position = 0; 
    249                 buffer = new byte[65536]; 
    250                 client.ReadMode = PipeTransmissionMode.Message; 
    251                 do 
    252                 { 
    253                     int lastRead = client.Read(buffer, 0, buffer.Length); 
    254                     mStream.Write(buffer, 0, lastRead); 
    255                 } 
    256                 while (!client.IsMessageComplete); 
    257  
    258                 //Check if the server says there is a response. If so, read it. 
    259                 if (BitConverter.ToInt32(mStream.ToArray(), 0) == 1) 
    260                 { 
    261                     mStream.Position = 0; 
    262                     do 
    263                     { 
    264                         int lastRead = client.Read(buffer, 0, buffer.Length); 
    265                         mStream.Write(buffer, 0, lastRead); 
    266                     } 
    267                     while (!client.IsMessageComplete); 
    268  
    269                     //Deserialise the response 
    270                     mStream.Position = 0; 
    271                     if (mStream.Length > 0) 
    272                         result = new BinaryFormatter().Deserialize(mStream); 
    273                 } 
    274             } 
    275  
    276             return (ReturnType)result; 
     161                //Create an instance of the remote object. 
     162                DirectExecutor client = (DirectExecutor)Activator.GetObject(typeof(DirectExecutor), 
     163                    "ipc://localhost:9090/" + RemoteExecutorServer.ServerName); 
     164 
     165                //Try to connect to the server instance. 
     166                //TODO: is there a better way? 
     167                int x = client.Tasks.Count; 
     168                Client = client; 
     169                IsConnected = true; 
     170            } 
     171            catch (RemotingException) 
     172            { 
     173            } 
    277174        } 
    278175 
    279176        public override void QueueTask(Task task) 
    280177        { 
    281             SendRequest<object>(RemoteExecutorFunction.QueueTask, task); 
     178            Client.QueueTask(task); 
    282179        } 
    283180 
    284181        public override void ScheduleTask(Task task) 
    285182        { 
    286             SendRequest<object>(RemoteExecutorFunction.ScheduleTask, task); 
     183            Client.ScheduleTask(task); 
    287184        } 
    288185 
    289186        public override void UnqueueTask(Task task) 
    290187        { 
    291             SendRequest<object>(RemoteExecutorFunction.UnqueueTask, task); 
     188            Client.UnqueueTask(task); 
    292189        } 
    293190 
    294191        public override void QueueRestartTasks() 
    295192        { 
    296             throw new NotImplementedException(); 
     193            Client.QueueRestartTasks(); 
    297194        } 
    298195 
    299196        internal override bool IsTaskQueued(Task task) 
    300197        { 
    301             throw new NotImplementedException(); 
     198            return Client.IsTaskQueued(task); 
    302199        } 
    303200 
     
    306203            get 
    307204            { 
    308                 return tasks; 
     205                return Client.Tasks; 
    309206            } 
    310207        } 
     
    313210        /// Checks whether the executor instance has connected to a server. 
    314211        /// </summary> 
    315         public bool IsConnected  
    316         { 
    317             get { return client.IsConnected; } 
    318         } 
    319  
    320         /// <summary> 
    321         /// The list of tasks belonging to this executor instance. 
    322         /// </summary> 
    323         private RemoteExecutorClientTasksCollection tasks; 
    324  
    325         /// <summary> 
    326         /// The named pipe used to connect to another running instance of Eraser. 
    327         /// </summary> 
    328         private NamedPipeClientStream client; 
    329  
    330         private class RemoteExecutorClientTasksCollection : ExecutorTasksCollection 
    331         { 
    332             /// <summary> 
    333             /// Constructor. 
    334             /// </summary> 
    335             /// <param name="executor">The <see cref="RemoteExecutor"/> object owning 
    336             /// this list.</param> 
    337             public RemoteExecutorClientTasksCollection(RemoteExecutorClient executor) 
    338                 : base(executor) 
    339             { 
    340             } 
    341  
    342             /// <summary> 
    343             /// Sends a request to the executor server. 
    344             /// </summary> 
    345             /// <typeparam name="ReturnType">The expected return type of the request.</typeparam> 
    346             /// <param name="function">The requested operation.</param> 
    347             /// <param name="args">The arguments for the operation.</param> 
    348             /// <returns>The return result from the object as if it were executed locally.</returns> 
    349             private ReturnType SendRequest<ReturnType>(RemoteExecutorFunction function, params object[] args) 
    350             { 
    351                 RemoteExecutorClient client = (RemoteExecutorClient)Owner; 
    352                 return client.SendRequest<ReturnType>(function, args); 
    353             } 
    354  
    355             #region IList<Task> Members 
    356             public override int IndexOf(Task item) 
    357             { 
    358                 throw new NotSupportedException(); 
    359             } 
    360  
    361             public override void Insert(int index, Task item) 
    362             { 
    363                 throw new NotSupportedException(); 
    364             } 
    365  
    366             public override void RemoveAt(int index) 
    367             { 
    368                 throw new NotSupportedException(); 
    369             } 
    370  
    371             public override Task this[int index] 
    372             { 
    373                 get 
    374                 { 
    375                     return SendRequest<Task>(RemoteExecutorFunction.GetTask, index); 
    376                 } 
    377                 set 
    378                 { 
    379                     throw new NotSupportedException(); 
    380                 } 
    381             } 
    382             #endregion 
    383  
    384             #region ICollection<Task> Members 
    385             public override void Add(Task item) 
    386             { 
    387                 item.Executor = Owner; 
    388                 SendRequest<object>(RemoteExecutorFunction.AddTask, item); 
    389  
    390                 //Call all the event handlers who registered to be notified of tasks 
    391                 //being added. 
    392                 Owner.OnTaskAdded(new TaskEventArgs(item)); 
    393             } 
    394  
    395             public override void Clear() 
    396             { 
    397                 throw new NotSupportedException(); 
    398             } 
    399  
    400             public override bool Contains(Task item) 
    401             { 
    402                 throw new NotSupportedException(); 
    403             } 
    404  
    405             public override void CopyTo(Task[] array, int arrayIndex) 
    406             { 
    407                 throw new NotSupportedException(); 
    408             } 
    409  
    410             public override int Count 
    411             { 
    412                 get { return SendRequest<int>(RemoteExecutorFunction.GetTaskCount); } 
    413             } 
    414  
    415             public override bool Remove(Task item) 
    416             { 
    417                 item.Cancel(); 
    418                 item.Executor = null; 
    419                 SendRequest<object>(RemoteExecutorFunction.DeleteTask, item); 
    420  
    421                 //Call all event handlers registered to be notified of task deletions. 
    422                 Owner.OnTaskDeleted(new TaskEventArgs(item)); 
    423                 return true; 
    424             } 
    425             #endregion 
    426  
    427             #region IEnumerable<Task> Members 
    428             public override IEnumerator<Task> GetEnumerator() 
    429             { 
    430                 throw new NotSupportedException(); 
    431             } 
    432             #endregion 
    433  
    434             public override void SaveToStream(Stream stream) 
    435             { 
    436                 throw new NotSupportedException(); 
    437             } 
    438  
    439             public override void LoadFromStream(Stream stream) 
    440             { 
    441                 throw new NotSupportedException(); 
    442             } 
    443         } 
     212        public bool IsConnected 
     213        { 
     214            get; 
     215            private set; 
     216        } 
     217 
     218        /// <summary> 
     219        /// The DirectExecutor proxy object used for calls to the server. 
     220        /// </summary> 
     221        private DirectExecutor Client; 
    444222    } 
    445223} 
Note: See TracChangeset for help on using the changeset viewer.