internal void ProcessReceivedData(RemoteDataObject <PSObject> receivedData) { if (receivedData == null) { throw PSTraceSource.NewArgumentNullException("receivedData"); } switch (receivedData.DataType) { case RemotingDataType.PowerShellInput: this.InputReceived.SafeInvoke <RemoteDataEventArgs <object> >(this, new RemoteDataEventArgs <object>(receivedData.Data)); return; case RemotingDataType.PowerShellInputEnd: this.InputEndReceived.SafeInvoke(this, EventArgs.Empty); return; case RemotingDataType.StopPowerShell: this.StopPowerShellReceived.SafeInvoke(this, EventArgs.Empty); return; case RemotingDataType.RemotePowerShellHostResponseData: { RemoteHostResponse data = RemoteHostResponse.Decode(receivedData.Data); this.transportManager.ReportExecutionStatusAsRunning(); this.HostResponseReceived.SafeInvoke <RemoteDataEventArgs <RemoteHostResponse> >(this, new RemoteDataEventArgs <RemoteHostResponse>(data)); return; } } }
/// <summary> /// Process the data received from the powershell on /// the client. /// </summary> /// <param name="receivedData">Data received.</param> internal void ProcessReceivedData(RemoteDataObject <PSObject> receivedData) { if (receivedData == null) { throw PSTraceSource.NewArgumentNullException("receivedData"); } Dbg.Assert(receivedData.TargetInterface == RemotingTargetInterface.PowerShell, "RemotingTargetInterface must be PowerShell"); switch (receivedData.DataType) { case RemotingDataType.StopPowerShell: { Dbg.Assert(StopPowerShellReceived != null, "ServerPowerShellDriver should subscribe to all data structure handler events"); StopPowerShellReceived.SafeInvoke(this, EventArgs.Empty); } break; case RemotingDataType.PowerShellInput: { Dbg.Assert(InputReceived != null, "ServerPowerShellDriver should subscribe to all data structure handler events"); InputReceived.SafeInvoke(this, new RemoteDataEventArgs <object>(receivedData.Data)); } break; case RemotingDataType.PowerShellInputEnd: { Dbg.Assert(InputEndReceived != null, "ServerPowerShellDriver should subscribe to all data structure handler events"); InputEndReceived.SafeInvoke(this, EventArgs.Empty); } break; case RemotingDataType.RemotePowerShellHostResponseData: { Dbg.Assert(HostResponseReceived != null, "ServerPowerShellDriver should subscribe to all data structure handler events"); RemoteHostResponse remoteHostResponse = RemoteHostResponse.Decode(receivedData.Data); // part of host message robustness algo. Now the host response is back, report to transport that // execution status is back to running _transportManager.ReportExecutionStatusAsRunning(); HostResponseReceived.SafeInvoke(this, new RemoteDataEventArgs <RemoteHostResponse>(remoteHostResponse)); } break; } }
internal static RemoteHostResponse Decode(PSObject data) { long propertyValue1 = RemotingDecoder.GetPropertyValue <long>(data, "ci"); RemoteHostMethodId propertyValue2 = RemotingDecoder.GetPropertyValue <RemoteHostMethodId>(data, "mi"); RemoteHostMethodInfo remoteHostMethodInfo = RemoteHostMethodInfo.LookUp(propertyValue2); object returnValue = RemoteHostResponse.DecodeReturnValue(data, remoteHostMethodInfo.ReturnType); Exception exception = RemoteHostResponse.DecodeException(data); return(new RemoteHostResponse(propertyValue1, propertyValue2, returnValue, exception)); }
internal PSObject Encode() { PSObject emptyPsObject = RemotingEncoder.CreateEmptyPSObject(); RemoteHostResponse.EncodeAndAddReturnValue(emptyPsObject, this._returnValue); RemoteHostResponse.EncodeAndAddException(emptyPsObject, this._exception); emptyPsObject.Properties.Add((PSPropertyInfo) new PSNoteProperty("ci", (object)this._callId)); emptyPsObject.Properties.Add((PSPropertyInfo) new PSNoteProperty("mi", (object)this._methodId)); return(emptyPsObject); }
private void ExecuteHostCall(RemoteHostCall hostcall) { if (hostcall.IsVoidMethod) { if (hostcall.IsSetShouldExitOrPopRunspace) { this.shell.ClearRemotePowerShell(); } hostcall.ExecuteVoidMethod(this.hostToUse); } else { RemoteHostResponse hostResponse = hostcall.ExecuteNonVoidMethod(this.hostToUse); this.dataStructureHandler.SendHostResponseToServer(hostResponse); } }
internal void ProcessReceivedData(RemoteDataObject <PSObject> receivedData) { if (receivedData == null) { throw PSTraceSource.NewArgumentNullException("receivedData"); } switch (receivedData.DataType) { case RemotingDataType.SetMaxRunspaces: this.SetMaxRunspacesReceived.SafeInvoke <RemoteDataEventArgs <PSObject> >(this, new RemoteDataEventArgs <PSObject>(receivedData.Data)); return; case RemotingDataType.SetMinRunspaces: this.SetMinRunspacesReceived.SafeInvoke <RemoteDataEventArgs <PSObject> >(this, new RemoteDataEventArgs <PSObject>(receivedData.Data)); return; case RemotingDataType.RunspacePoolOperationResponse: case RemotingDataType.RunspacePoolStateInfo: case RemotingDataType.PSEventArgs: case RemotingDataType.ApplicationPrivateData: break; case RemotingDataType.CreatePowerShell: this.CreateAndInvokePowerShell.SafeInvoke <RemoteDataEventArgs <RemoteDataObject <PSObject> > >(this, new RemoteDataEventArgs <RemoteDataObject <PSObject> >(receivedData)); return; case RemotingDataType.AvailableRunspaces: this.GetAvailableRunspacesReceived.SafeInvoke <RemoteDataEventArgs <PSObject> >(this, new RemoteDataEventArgs <PSObject>(receivedData.Data)); break; case RemotingDataType.GetCommandMetadata: this.GetCommandMetadata.SafeInvoke <RemoteDataEventArgs <RemoteDataObject <PSObject> > >(this, new RemoteDataEventArgs <RemoteDataObject <PSObject> >(receivedData)); return; case RemotingDataType.RemoteRunspaceHostResponseData: { RemoteHostResponse data = RemoteHostResponse.Decode(receivedData.Data); this.transportManager.ReportExecutionStatusAsRunning(); this.HostResponseReceived.SafeInvoke <RemoteDataEventArgs <RemoteHostResponse> >(this, new RemoteDataEventArgs <RemoteHostResponse>(data)); return; } default: return; } }
internal void HandleRemoteHostCalls(object sender, RemoteDataEventArgs <RemoteHostCall> eventArgs) { if (this.HostCallReceived != null) { this.HostCallReceived.SafeInvoke <RemoteDataEventArgs <RemoteHostCall> >(sender, eventArgs); } else { RemoteHostCall data = eventArgs.Data; if (data.IsVoidMethod) { data.ExecuteVoidMethod(base.host); } else { RemoteHostResponse hostResponse = data.ExecuteNonVoidMethod(base.host); this.dataStructureHandler.SendHostResponseToServer(hostResponse); } } }
internal void SendHostResponseToServer(RemoteHostResponse hostResponse) { using (ClientPowerShellDataStructureHandler.tracer.TraceMethod()) this.transportManager.DataToBeSentCollection.Add <PSObject>(RemoteDataObject <PSObject> .CreateFrom(RemotingDestination.Server, RemotingDataType.RemotePowerShellHostResponseData, this.clientRunspacePoolId, this.clientPowerShellId, hostResponse.Encode()), DataPriorityType.PromptResponse); }
internal void ProcessReceivedData(RemoteDataObject <PSObject> receivedData) { using (ServerRunspacePoolDataStructureHandler.tracer.TraceMethod()) { if (receivedData == null) { throw ServerRunspacePoolDataStructureHandler.tracer.NewArgumentNullException(nameof(receivedData)); } switch (receivedData.DataType) { case RemotingDataType.SetMaxRunspaces: this.SetMaxRunspacesReceived((object)this, new RemoteDataEventArgs <PSObject>((object)receivedData.Data)); break; case RemotingDataType.SetMinRunspaces: this.SetMinRunspacesReceived((object)this, new RemoteDataEventArgs <PSObject>((object)receivedData.Data)); break; case RemotingDataType.CreatePowerShell: this.CreateAndInvokePowerShell((object)this, new RemoteDataEventArgs <RemoteDataObject <PSObject> >((object)receivedData)); break; case RemotingDataType.AvailableRunspaces: this.GetAvailableRunspacesReceived((object)this, new RemoteDataEventArgs <PSObject>((object)receivedData.Data)); break; case RemotingDataType.GetCommandMetadata: this.GetCommandMetadata((object)this, new RemoteDataEventArgs <RemoteDataObject <PSObject> >((object)receivedData)); break; case RemotingDataType.RemoteRunspaceHostResponseData: this.HostResponseReceived((object)this, new RemoteDataEventArgs <RemoteHostResponse>((object)RemoteHostResponse.Decode(receivedData.Data))); break; } } }
internal void SendHostResponseToServer(RemoteHostResponse hostResponse) { RemoteDataObject <PSObject> data = RemoteDataObject <PSObject> .CreateFrom(RemotingDestination.InvalidDestination | RemotingDestination.Server, RemotingDataType.RemotePowerShellHostResponseData, this.clientRunspacePoolId, this.clientPowerShellId, hostResponse.Encode()); this.transportManager.DataToBeSentCollection.Add <PSObject>(data, DataPriorityType.PromptResponse); }
/// <summary> /// Process the data received from the runspace pool on /// the server. /// </summary> /// <param name="receivedData">Data received.</param> internal void ProcessReceivedData(RemoteDataObject <PSObject> receivedData) { if (receivedData == null) { throw PSTraceSource.NewArgumentNullException("receivedData"); } Dbg.Assert(receivedData.TargetInterface == RemotingTargetInterface.RunspacePool, "RemotingTargetInterface must be Runspace"); switch (receivedData.DataType) { case RemotingDataType.CreatePowerShell: { Dbg.Assert(CreateAndInvokePowerShell != null, "The ServerRunspacePoolDriver should subscribe to all data structure handler events"); CreateAndInvokePowerShell.SafeInvoke(this, new RemoteDataEventArgs <RemoteDataObject <PSObject> >(receivedData)); } break; case RemotingDataType.GetCommandMetadata: { Dbg.Assert(GetCommandMetadata != null, "The ServerRunspacePoolDriver should subscribe to all data structure handler events"); GetCommandMetadata.SafeInvoke(this, new RemoteDataEventArgs <RemoteDataObject <PSObject> >(receivedData)); } break; case RemotingDataType.RemoteRunspaceHostResponseData: { Dbg.Assert(HostResponseReceived != null, "The ServerRunspacePoolDriver should subscribe to all data structure handler events"); RemoteHostResponse remoteHostResponse = RemoteHostResponse.Decode(receivedData.Data); // part of host message robustness algo. Now the host response is back, report to transport that // execution status is back to running _transportManager.ReportExecutionStatusAsRunning(); HostResponseReceived.SafeInvoke(this, new RemoteDataEventArgs <RemoteHostResponse>(remoteHostResponse)); } break; case RemotingDataType.SetMaxRunspaces: { Dbg.Assert(SetMaxRunspacesReceived != null, "The ServerRunspacePoolDriver should subscribe to all data structure handler events"); SetMaxRunspacesReceived.SafeInvoke(this, new RemoteDataEventArgs <PSObject>(receivedData.Data)); } break; case RemotingDataType.SetMinRunspaces: { Dbg.Assert(SetMinRunspacesReceived != null, "The ServerRunspacePoolDriver should subscribe to all data structure handler events"); SetMinRunspacesReceived.SafeInvoke(this, new RemoteDataEventArgs <PSObject>(receivedData.Data)); } break; case RemotingDataType.AvailableRunspaces: { Dbg.Assert(GetAvailableRunspacesReceived != null, "The ServerRunspacePoolDriver should subscribe to all data structure handler events"); GetAvailableRunspacesReceived.SafeInvoke(this, new RemoteDataEventArgs <PSObject>(receivedData.Data)); } break; case RemotingDataType.ResetRunspaceState: { Dbg.Assert(ResetRunspaceState != null, "The ServerRunspacePoolDriver should subscribe to all data structure handler events."); ResetRunspaceState.SafeInvoke(this, new RemoteDataEventArgs <PSObject>(receivedData.Data)); } break; } }
internal void SendHostResponseToServer(RemoteHostResponse hostResponse) { using (ClientRunspacePoolDataStructureHandler.tracer.TraceMethod()) this.SendDataAsync(hostResponse.Encode(), DataPriorityType.PromptResponse); }
internal void SendHostResponseToServer(RemoteHostResponse hostResponse) { this.SendDataAsync(hostResponse.Encode(), DataPriorityType.PromptResponse); }
/// <summary> /// Start (or Connect) event handler. /// <para>There are 2 instances of the process control control.</para> /// <para>When context is null, this function handles the Start event for the local TPE.</para> /// <para>When context is not null, this function handles the Connect event for a remote TPE.</para> /// </summary> /// <param name="context">Indicates to handler method whether it is from the local or remote TPE.</param> public void Start(object context) { // Start Event from local TPE if (context == null) { // ensure that this tpe host is unique host session base on engineId // When the Overwrite parameter of appSession.Start is false // we will receive an error message when there is an existing record. // As long as we receive an error message, the session already exists // so user will be presented with dialog box. // When user confirms, then we call function with Overwrite = true; string sessionExists = _appSession.Start(_configSettings, "Application Startup", false, _hostEndpointAddress); while (!string.IsNullOrEmpty(sessionExists)) { if (MessageBox.Show(sessionExists + " Press OK to reset; CANCEL to stop." , "Session Startup Conflict", MessageBoxButton.OKCancel) == MessageBoxResult.Cancel) { return; } // otherwise reset session record (remove existing) else { sessionExists = _appSession.Start(_configSettings , "Application Startup After Session Conflict Reset" , true , _hostEndpointAddress); // host address of this local TPE to be used for other applications to connect to. } } // instantiate this application's local TPE _localTpe = new TaskProcessing.TaskProcessingEngine(_daMgr , _taskAssemblyPath , _engineId , _configId , _appSession.SignonControl , _maxTasks , _hostEndpointAddress); // start the TPE _localTpe.Start(); // display status Status(); } else { // WCF Connect pagingTableRemoteHosts.IsEnabled = false; EndpointAddress remoteAddress = new EndpointAddress(string.Format("{0}{1}", _hostEndpointAddress , _engineId)); WSHttpBinding binding = new WSHttpBinding(SecurityMode.None); _remoteTpe = new RemoteHostClient(binding, remoteAddress); RemoteHostResponse response = _remoteTpe.Connect(_engineId); if (response.Success) { RemoteHostResponseString configSettingsResponse = _remoteTpe.ConfigSettings(); RemoteHostResponseString dynamicSettingsReponse = _remoteTpe.DynamicSettings(); if (configSettingsResponse.Success && dynamicSettingsReponse.Success) { Dictionary <string, string> configSettings = (Dictionary <string, string>) Core.Functions.Deserialize <Dictionary <string, string> > (configSettingsResponse.ReturnValue); Dictionary <string, string> dynamicSettings = (Dictionary <string, string>) Core.Functions.Deserialize <Dictionary <string, string> > (dynamicSettingsReponse.ReturnValue); DisplayRemoteTpeConfiguration(configSettings, dynamicSettings); } else { remoteTpeStatus.Status = string.Format("{0}{1}{2}", configSettingsResponse.ErrorMsg , Environment.NewLine, dynamicSettingsReponse.ErrorMsg); } } else { HostConnectionAborted(response.ErrorMsg); } } }
internal void ProcessReceivedData(RemoteDataObject <PSObject> receivedData) { using (ServerPowerShellDataStructureHandler.tracer.TraceMethod()) { if (receivedData == null) { throw ServerPowerShellDataStructureHandler.tracer.NewArgumentNullException(nameof(receivedData)); } switch (receivedData.DataType) { case RemotingDataType.PowerShellInput: this.InputReceived((object)this, new RemoteDataEventArgs <object>((object)receivedData.Data)); break; case RemotingDataType.PowerShellInputEnd: this.InputEndReceived((object)this, new EventArgs()); break; case RemotingDataType.StopPowerShell: this.StopPowerShellReceived((object)this, new EventArgs()); break; case RemotingDataType.RemotePowerShellHostResponseData: this.HostResponseReceived((object)this, new RemoteDataEventArgs <RemoteHostResponse>((object)RemoteHostResponse.Decode(receivedData.Data))); break; } } }