public ErrorMessage(short?messageId, short?askId, ErrorType type, string additionalExceptionInformation)
{
this.MessageId = messageId;
this.AskId = askId;
ErrorType = type;
Exception = RemoteException.Create(type, additionalExceptionInformation, messageId, askId);
}
public async Task SendMessage(string id, [FromQueryAttribute] string message)
{
RemoteException ex = new RemoteException(1, "Unknown");
await _notificationsMessageHandler.InvokeClientMethodToAllAsync("receiveMessage", ex, ex);
await _notificationsMessageHandler.InvokeClientMethodToAllAsync("receiveMessage", message, ex);
await _notificationsMessageHandler.InvokeClientMethodToAllAsync("receiveMessage", message);
await _notificationsMessageHandler.InvokeClientMethodToAllAsync("receiveMessage", ex);
await _notificationsMessageHandler.InvokeClientMethodOnlyAsync(id, "receiveMessage", message, ex);
await _notificationsMessageHandler.SendClientResultAsync(id, "receiveResult", ex);
await _notificationsMessageHandler.SendClientErrorAsync(id, "receiveError", ex);
await _notificationsMessageHandler.SendClientNotifyAsync(id, "receiveNotify", ex);
await _notificationsMessageHandler.SendAllNotifyAsync("receiveAllNotify", ex);
//object[] objs = new object[1];
//objs[0] = ex;
//var t = _notificationsMessageHandler.InvokeClientMethodAsync<RemoteException>(id, "waitMessage", objs);
}
public static void ShowRemoteException(RemoteException exception)
{
var remote = exception.Remote;
ConsoleUtils.Error("Remote error " + exception.ToMessageWithType());
ShowRemoteExceptionData(remote, 2);
}
public void Constructors()
{
_ = new RemoteException();
_ = new RemoteException("exception");
_ = new RemoteException("exception", new Exception("bang"));
_ = new RemoteException(RemoteError.Undefined, true);
_ = new RemoteException(RemoteError.Undefined, "exception");
_ = new RemoteException(RemoteError.Undefined, "exception", true);
_ = new RemoteException(RemoteError.Undefined, new Exception("bang"));
_ = new RemoteException(RemoteError.Undefined, "exception", new Exception("bang"));
_ = new RemoteException(RemoteError.Undefined, new Exception("bang"), true);
var e = new RemoteException(RemoteError.AccessControl, "exception", new Exception("bang"), true);
Assert.That(e.Message, Is.EqualTo("exception"));
Assert.That(e.InnerException, Is.Not.Null);
Assert.That(e.InnerException.Message, Is.EqualTo("bang"));
Assert.That(e.Retryable, Is.True);
Assert.That(e.Error, Is.EqualTo(RemoteError.AccessControl));
e = e.SerializeAndDeSerialize();
Assert.That(e.Message, Is.EqualTo("exception"));
Assert.That(e.InnerException, Is.Not.Null);
Assert.That(e.InnerException.Message, Is.EqualTo("bang"));
Assert.That(e.Retryable, Is.True);
Assert.That(e.Error, Is.EqualTo(RemoteError.AccessControl));
Assert.Throws <ArgumentNullException>(() => e.GetObjectData(default !, default));
private ErrorRecord GetErrorFromRemoteCommand(string commandName, RuntimeException runtimeException)
{
string str;
ErrorDetails errorDetails;
if (string.IsNullOrEmpty(commandName))
{
throw PSTraceSource.NewArgumentNullException("commandName");
}
if (runtimeException == null)
{
throw PSTraceSource.NewArgumentNullException("runtimeException");
}
RemoteException exception = runtimeException as RemoteException;
if (((exception != null) && (exception.SerializedRemoteException != null)) && Deserializer.IsInstanceOfType(exception.SerializedRemoteException, typeof(CommandNotFoundException)))
{
str = "ErrorRequiredRemoteCommandNotFound";
errorDetails = this.GetErrorDetails(str, new object[] { base.MyInvocation.MyCommand.Name });
return(new ErrorRecord(new RuntimeException(errorDetails.Message, runtimeException), str, ErrorCategory.ObjectNotFound, null)
{
ErrorDetails = errorDetails
});
}
str = "ErrorFromRemoteCommand";
errorDetails = this.GetErrorDetails(str, new object[] { "Get-Command", runtimeException.Message });
return(new ErrorRecord(new RuntimeException(errorDetails.Message, runtimeException), str, ErrorCategory.InvalidResult, null)
{
ErrorDetails = errorDetails
});
}
public byte[] Compile(string sourceCode)
{
using (var peStream = new MemoryStream())
{
var result = GenerateCode(sourceCode, this.name, this.references).Emit(peStream);
if (!result.Success)
{
StringBuilder stringBuilder = new StringBuilder("Compilation errors: ");
var failures = result.Diagnostics.Where(diagnostic => diagnostic.IsWarningAsError || diagnostic.Severity == DiagnosticSeverity.Error);
foreach (var diagnostic in failures)
{
//Console.Error.WriteLine("{0}: {1}", diagnostic.Id, diagnostic.GetMessage());
stringBuilder.AppendLine(diagnostic.Id.ToString() + ". " + diagnostic.GetMessage());
}
var ex = new RemoteException(stringBuilder.ToString());
ex.Code = "COMPILATION_ERROR";
throw ex;
}
//Console.WriteConsole.WriteLine("Compilation done without any error.");
peStream.Seek(0, SeekOrigin.Begin);
return(peStream.ToArray());
}
}
public async Task <IServiceRemotingResponseMessage> RequestResponseAsync(
IServiceRemotingRequestMessage remotingRequestRequestMessage)
{
var interfaceId = remotingRequestRequestMessage.GetHeader().InterfaceId;
var serializedHeader = this.serializersManager.GetHeaderSerializer()
.SerializeRequestHeader(remotingRequestRequestMessage.GetHeader());
var msgBodySeriaizer = this.serializersManager.GetRequestBodySerializer(interfaceId);
var serializedMsgBody = msgBodySeriaizer.Serialize(remotingRequestRequestMessage.GetBody());
var fabricTransportRequestBody = serializedMsgBody != null
? new FabricTransportRequestBody(serializedMsgBody.GetSendBuffers(),
serializedMsgBody.Dispose)
: new FabricTransportRequestBody(new List <ArraySegment <byte> >(), null);
//Send Request
using (var retval = await this.fabricTransportClient.RequestResponseAsync(
new FabricTransportMessage(
new FabricTransportRequestHeader(serializedHeader.GetSendBuffer(), serializedHeader.Dispose),
fabricTransportRequestBody),
this.fabricTransportClient.Settings.OperationTimeout))
{
var incomingHeader = (retval != null && retval.GetHeader() != null)
? new IncomingMessageHeader(retval.GetHeader().GetRecievedStream())
: null;
////DeSerialize Response
var header =
this.serializersManager.GetHeaderSerializer()
.DeserializeResponseHeaders(
incomingHeader);
byte[] headerValue;
if (header != null && header.TryGetHeaderValue("HasRemoteException", out headerValue))
{
Exception e;
var isDeserialzied =
RemoteException.ToException(retval.GetBody().GetRecievedStream(),
out e);
if (isDeserialzied)
{
throw new AggregateException(e);
}
else
{
throw new ServiceException(e.GetType().FullName, string.Format(
CultureInfo.InvariantCulture,
Remoting.SR.ErrorDeserializationFailure,
e.ToString()));
}
}
var responseSerializer = this.serializersManager.GetResponseBodySerializer(interfaceId);
var incomingMsgBody = (retval != null && retval.GetBody() != null)
? new IncomingMessageBody(retval.GetBody().GetRecievedStream())
: null;
var msgBody =
responseSerializer.Deserialize(incomingMsgBody);
return((IServiceRemotingResponseMessage) new ServiceRemotingResponseMessage(header, msgBody));
}
}
public void RemoteException_Constructor_MessageArgument_Valid()
{
// This test verifies that the default constructor works.
// Note: this test is useless except for code coverage since we are testing the constructor with no custom logic.
var ex = new RemoteException("test");
Assert.AreEqual("test", ex.Message);
Assert.IsNull(ex.InnerException);
}
public void DemoException_Constructor_MessageArgument_Null()
{
// This test verifies that the default constructor works.
// Note: this test is useless except for code coverage since we are testing the constructor with no custom logic.
var ex = new RemoteException(null);
Assert.AreEqual("Exception of type 'Rightpoint.UnitTesting.Demo.Mvc.Exceptions.RemoteException' was thrown.", ex.Message);
Assert.IsNull(ex.InnerException);
}
public object Run()
{
try
{
try
{
byte[] tmppw = TestDelegationTokensWithHA.dtSecretManager.RetrievePassword(identifier
);
NUnit.Framework.Assert.Fail("InvalidToken with cause StandbyException is expected"
+ " since nn0 is standby");
return(tmppw);
}
catch (IOException e)
{
// Mimic the UserProvider class logic (server side) by throwing
// SecurityException here
throw new SecurityException(SecurityUtil.FailedToGetUgiMsgHeader + " " + e, e);
}
}
catch (Exception oe)
{
//
// The exception oe caught here is
// java.lang.SecurityException: Failed to obtain user group
// information: org.apache.hadoop.security.token.
// SecretManager$InvalidToken: StandbyException
//
HttpServletResponse response = Org.Mockito.Mockito.Mock <HttpServletResponse>();
ExceptionHandler eh = new ExceptionHandler();
eh.InitResponse(response);
// The Response (resp) below is what the server will send to client
//
// BEFORE HDFS-6475 fix, the resp.entity is
// {"RemoteException":{"exception":"SecurityException",
// "javaClassName":"java.lang.SecurityException",
// "message":"Failed to obtain user group information:
// org.apache.hadoop.security.token.SecretManager$InvalidToken:
// StandbyException"}}
// AFTER the fix, the resp.entity is
// {"RemoteException":{"exception":"StandbyException",
// "javaClassName":"org.apache.hadoop.ipc.StandbyException",
// "message":"Operation category READ is not supported in
// state standby"}}
//
Response resp = eh.ToResponse(oe);
// Mimic the client side logic by parsing the response from server
//
IDictionary <object, object> m = (IDictionary <object, object>)JSON.Parse(resp.GetEntity
().ToString());
RemoteException re = JsonUtil.ToRemoteException(m);
Exception unwrapped = ((RemoteException)re).UnwrapRemoteException(typeof(StandbyException
));
NUnit.Framework.Assert.IsTrue(unwrapped is StandbyException);
return(null);
}
}
// Token: 0x060010CA RID: 4298 RVA: 0x00033B8C File Offset: 0x00031D8C
private ErrorRecord ResolveErrorRecord(ErrorRecord errorRecord)
{
RemoteException ex = errorRecord.Exception as RemoteException;
if (ex != null)
{
return(new ErrorRecord(MonadCommand.DeserializeException(ex), errorRecord.FullyQualifiedErrorId, errorRecord.CategoryInfo.Category, errorRecord.TargetObject));
}
return(errorRecord);
}
internal static Exception DeserializeException(Exception ex)
{
RemoteException ex2 = ex as RemoteException;
if (ex2 != null && MonadCommand.CanDeserialize(ex2.SerializedRemoteException))
{
return((MonadCommand.Deserialize(ex2.SerializedRemoteException) as Exception) ?? ex);
}
return(ex);
}
public void TC001_OnlyMessage()
{
//Arrange
string message = "this is a message";
//Act
RemoteException remoteException = new RemoteException(message);
//Assert
Assert.IsFalse(string.IsNullOrEmpty(remoteException.Backtrace));
}
public void RemoteException_Constructor_MessageAndInnerExArgument_EmptyMessage()
{
// This test verifies that the default constructor works.
// Note: this test is useless except for code coverage since we are testing the constructor with no custom logic.
var ex = new RemoteException(string.Empty, new Exception("Inner"));
Assert.AreEqual(string.Empty, ex.Message);
Assert.IsNotNull(ex.InnerException);
Assert.AreEqual("Inner", ex.InnerException.Message);
Assert.IsNull(ex.InnerException.InnerException);
}
private static void DefaultThrowIcfExceptionImplementation(Exception e, ErrorRecord error, string message)
{
LOG.Info(e, "DefaultThrowIcfExceptionImplementation dealing with Exception, message = {1}", message);
if (error.CategoryInfo != null)
{
// TODO is this really correct? It is not sure that the object in question is really missing (although it's quite probable).
String reason = error.CategoryInfo.Reason;
if ("ManagementObjectNotFoundException".Equals(reason))
{
throw new ObjectNotFoundException(message);
}
else if ("DuplicateAcceptedDomainException".Equals(reason) ||
"ADObjectAlreadyExistsException".Equals(reason))
{
throw new AlreadyExistsException(message, e);
}
else if ("ProxyAddressExistsException".Equals(reason))
{
throw new ProxyAddressExistsException(message, e);
}
}
if (e == null)
{
throw new ConnectorException(message);
}
if (e is RemoteException)
{
RemoteException remote = (RemoteException)e;
PSObject serialized = remote.SerializedRemoteException;
if (serialized != null && serialized.BaseObject is Exception)
{
DefaultThrowIcfExceptionImplementation((Exception)serialized.BaseObject, error, message);
}
else
{
throw new ConnectorException("Remote exception: " + message, e);
}
}
string name = e.GetType().Name;
switch (name)
{
// not sure if these cases are covered by reason checking above ... to be sure, include them also here (for now)
case "DuplicateAcceptedDomainException":
case "ADObjectAlreadyExistsException":
throw new AlreadyExistsException(message, e);
default:
throw new ConnectorException(message, e);
}
}
public async Task <ResponseMessage> RequestResponseAsync(ArraySegment <byte> messageHeaders,
IEnumerable <ArraySegment <byte> > requestBody)
{
IMessageBody outgoingMessageBody = null;
IMessageHeader outgoingMessageHeader = null;
try
{
var headerSerializer = this.serializersManager.GetHeaderSerializer();
var deSerializedHeader =
headerSerializer.DeserializeRequestHeaders(
new IncomingMessageHeader(new SegmentedReadMemoryStream(messageHeaders)));
var msgBodySerializer =
this.serializersManager.GetRequestBodySerializer(deSerializedHeader.InterfaceId);
var deserializedMsg =
msgBodySerializer.Deserialize(
new IncomingMessageBody(new SegmentedReadMemoryStream(requestBody)));
var msg = new ServiceRemotingRequestMessage(deSerializedHeader, deserializedMsg);
var retval = await
this.messageHandler.HandleRequestResponseAsync(
this.requestContext,
msg);
if (retval == null)
{
return(new ResponseMessage());
}
outgoingMessageHeader = headerSerializer.SerializeResponseHeader(retval.GetHeader());
var responseSerializer =
this.serializersManager.GetResponseBodySerializer(deSerializedHeader.InterfaceId);
outgoingMessageBody = responseSerializer.Serialize(retval.GetBody());
var responseMessage = new ResponseMessage();
responseMessage.ResponseBody = outgoingMessageBody != null
? outgoingMessageBody.GetSendBuffers()
: new List <ArraySegment <byte> >();
responseMessage.MessageHeaders = outgoingMessageHeader != null
? outgoingMessageHeader.GetSendBuffer()
: new ArraySegment <byte>();
return(responseMessage);
}
catch (Exception e)
{
ServiceTrace.Source.WriteInfo("WcfRemotingService", "Remote Exception occured {0}", e);
throw new FaultException <RemoteException>(RemoteException.FromException(e), e.Message);
}
}
public void TC003_TestStatic()
{
//Arrange
string message = "my special exception";
Exception exception = new Exception(message);
//Act
RemoteException remoteException = RemoteException.CreateRemoteException(exception);
//Assert
Assert.AreEqual(message, remoteException.Message);
}
/// <summary>
/// Sends response to the remote application that invoked a service method.
/// </summary>
/// <param name="requestMessage">Request message</param>
/// <param name="returnValue">Return value to send</param>
/// <param name="exception">Exception to send</param>
private void SendInvokeResponse(IMessage requestMessage, object returnValue, RemoteException exception)
{
try {
_requestReplyMessenger.SendMessage(
new RemoteInvokeReturnMessage {
RepliedId = requestMessage.Id,
ReturnValue = returnValue,
RemoteException = exception
});
} catch {
}
}
/// <exception cref="Org.Xml.Sax.SAXException"/>
public override void StartElement(string ns, string localname, string qname, Attributes
attrs)
{
if (!typeof(ContentSummary).FullName.Equals(qname))
{
if (typeof(RemoteException).Name.Equals(qname))
{
throw new SAXException(RemoteException.ValueOf(attrs));
}
throw new SAXException("Unrecognized entry: " + qname);
}
this.contentsummary = HftpFileSystem.ToContentSummary(attrs);
}
/// <exception cref="Org.Xml.Sax.SAXException"/>
public override void StartElement(string ns, string localname, string qname, Attributes
attrs)
{
if (!typeof(MD5MD5CRC32FileChecksum).FullName.Equals(qname))
{
if (typeof(RemoteException).Name.Equals(qname))
{
throw new SAXException(RemoteException.ValueOf(attrs));
}
throw new SAXException("Unrecognized entry: " + qname);
}
this.filechecksum = MD5MD5CRC32FileChecksum.ValueOf(attrs);
}
private FabricTransportMessage CreateFabricTransportExceptionMessage(Exception ex)
{
var header = new ServiceRemotingResponseMessageHeader();
header.AddHeader("HasRemoteException", new byte[0]);
var serializedHeader = this.serializersManager.GetHeaderSerializer().SerializeResponseHeader(header);
var serializedMsg = RemoteException.FromException(ex);
var msg = new FabricTransportMessage(
new FabricTransportRequestHeader(serializedHeader.GetSendBuffer(), serializedHeader.Dispose),
new FabricTransportRequestBody(serializedMsg.Data, null));
return(msg);
}
protected HttpWebResponse RequestGetResponse(NationBuilderWebRequest req)
{
HttpWebResponse response;
try
{
response = (HttpWebResponse)req.GetResponse();
}
catch (WebException exc)
{
response = (HttpWebResponse)exc.Response;
if (null == response)
{
throw; // unrecognized exceptions back.
}
// Marshall Nation Builder exceptions back:
switch (response.StatusCode)
{
case HttpStatusCode.BadRequest:
case HttpStatusCode.NotFound:
RemoteException exceptionInformation;
try {
exceptionInformation = DeserializeNationBuilderObject <RemoteException>(response.GetResponseStream());
}
catch
{
Stream stream = response.GetResponseStream();
stream.Seek(0, SeekOrigin.Begin);
using (var reader = new StreamReader(stream, Encoding.UTF8)) {
exceptionInformation = new RemoteException()
{
message = "Unknown error. See 'error_description' field for the unparsed server response.",
error_description = reader.ReadToEnd(),
};
}
}
throw new NationBuilderRemoteException(response.StatusCode, exceptionInformation, req, exc);
}
// Throw unrecognized exceptions back:
throw;
}
return(response);
}
public async Task CallRpc(string id, string method, [FromBody] string message)
{
if (message.Length == 0)
{
message = "Unknown";
}
RemoteException ex = new RemoteException(1, message);
object[] objs = new object[1];
objs[0] = message;
var t = await _notificationsMessageHandler.InvokeClientMethodAsync <RemoteException>(id, method, objs);
await Task.CompletedTask;
}
/// <summary>
/// Create a C# exception that represents an exception that was thrown remotely on a server.
/// </summary>
/// <param name="errorHolders">Server errors.</param>
/// <returns>An exception representing the specified server errors.</returns>
private static RemoteException CreateException(IEnumerator <ErrorHolder> errorHolders)
{
if (errorHolders == null)
{
throw new ArgumentNullException(nameof(errorHolders));
}
if (!errorHolders.MoveNext())
{
return(null);
}
var errorHolder = errorHolders.Current;
if (errorHolder == null)
{
return(new RemoteException(RemoteError.Undefined));
}
var innerException = CreateException(errorHolders);
var error = RemoteError.Undefined;
if (Enum.IsDefined(typeof(RemoteError), errorHolder.ErrorCode))
{
error = (RemoteError)errorHolder.ErrorCode;
}
var retryable = RetryableExceptions.Contains(error);
var exception = new RemoteException(error, errorHolder.Message, innerException, retryable);
var sb = new StringBuilder();
var first = true;
foreach (var stackTraceElement in errorHolder.StackTraceElements)
{
if (first)
{
first = false;
}
else
{
sb.AppendLine();
}
sb.Append(" ").Append(stackTraceElement);
}
exception.Data.Add("server", sb.ToString());
return(exception);
}
private Task RespondError(IInboundMessageEvent <RmiRequestDto> e, Exception ex)
{
if (logger.IsDebugEnabled)
{
logger.Debug($"Threw when handling RMI {e.Body.InvocationId.ToString("n").Substring(0, 6)} Request on method {e.Body.MethodName} for service {e.Body.ServiceId.ToString("n").Substring(0, 6)}. Error: {ex}.");
}
return(messenger.SendReliableAsync(
new RmiResponseDto {
InvocationId = e.Body.InvocationId,
Outs = new object[0],
ReturnValue = null,
Exception = RemoteException.Create(ex, e.Body)
},
e.Sender.Identity.Id));
}
/// <summary>
/// 处理远返回的程异常
/// </summary>
/// <param name="package">数据包</param>
private void ProcessRemoteException(JsonPacket package)
{
var taskSetter = this.taskSetterTable.Take(package.id);
if (taskSetter == null)
{
return;
}
var body = package.body;
var message = body == null ? null : body.ToString();
var exception = new RemoteException(message);
taskSetter.SetException(exception);
}
public async Task MissingCallback()
{
RemoteException exception = null;
try
{
await _systemClient.MissingCallback(new SystemMessage());
}
catch (RemoteException ex)
{
exception = ex;
}
exception.Message.ShouldBe("Callback contract mismatch. Requested System.IDisposable, but it's UiPath.CoreIpc.Tests.ISystemCallback.");
exception.Is <ArgumentException>().ShouldBeTrue();
}
public void TC002_TestException()
{
//Arrange
string message = "this is a message";
string blob = "blob";
string stacktrace = "this is a stacktrace";
//Act
RemoteException remoteException = new RemoteException(message, stacktrace, blob);
//Assert
Assert.AreEqual(message, remoteException.Message);
Assert.AreEqual(blob, remoteException.Blob);
Assert.AreEqual(stacktrace, remoteException.Backtrace);
}
/// <summary>
/// 处理远返回的程异常
/// </summary>
/// <param name="requestContext">请求上下文</param>
private void ProcessRemoteException(RequestContext requestContext)
{
var taskSetter = this.TaskSetterTable.Take(requestContext.Packet.id);
if (taskSetter == null)
{
return;
}
var body = requestContext.Packet.body;
var message = body == null ? null : body.ToString();
var exception = new RemoteException(message);
taskSetter.SetException(exception);
}
/// <summary>
/// 设置Api行为返回的任务异常
/// </summary>
/// <param name="taskSetActionTable">任务行为表</param>
/// <param name="requestContext">请求上下文</param>
/// <returns></returns>
public static bool SetApiActionTaskException(TaskSetterTable <long> taskSetActionTable, RequestContext requestContext)
{
var taskSetAction = taskSetActionTable.Remove(requestContext.Packet.Id);
if (taskSetAction == null)
{
return(true);
}
var exceptionBytes = requestContext.Packet.Body;
var message = exceptionBytes == null ? string.Empty : Encoding.UTF8.GetString(exceptionBytes);
var exception = new RemoteException(message);
return(taskSetAction.SetException(exception));
}
/// <summary>
/// Gets the exception that occured when the given thread was executing.
/// </summary>
/// <param name="sc">security credentials to verify if the owner has permission to perform this operation
/// (i.e get failed thread exception, which is associated with the ManageOwnApp / ManageAllApps permission)</param>
/// <param name="ti">ThreadIdentifier of the failed thread</param>
/// <returns></returns>
public Exception Owner_GetFailedThreadException(SecurityCredentials sc, ThreadIdentifier ti)
{
AuthenticateUser(sc);
ApplicationAuthorizationCheck(sc, ti.ApplicationId);
logger.Debug("Getting exception for thread:" + ti.ThreadId);
Exception newEx = _Applications[ti.ApplicationId][ti.ThreadId].FailedThreadException;
//wrap the exception
if ( newEx != null && !(newEx is RemoteException))
newEx = new RemoteException(newEx.Message, newEx);
if (newEx != null)
return new RemoteException(newEx.Message, newEx);
else
return null;
//return _Applications[ti.ApplicationId][ti.ThreadId].FailedThreadException;
}
/// <summary>
/// 处理远返回的程异常
/// </summary>
/// <param name="requestContext">请求上下文</param>
private void ProcessRemoteException(RequestContext requestContext)
{
var taskSetAction = this.TaskSetActionTable.Take(requestContext.Packet.id);
if (taskSetAction == null)
{
return;
}
var body = requestContext.Packet.body;
var message = body == null ? null : body.ToString();
var exception = new RemoteException(message);
taskSetAction.SetException(exception);
}
/// <summary>
/// Connect to an executor which is in dedicated mode.
/// This method is called by the remote executor using its reference to this manager.
/// </summary>
/// <param name="sc">security credentials to verify if the executor has permission to perform this operation
/// (i.e connect dedicated, which is associated with the ExecuteThread permission)</param>
/// <param name="executorId">executor id</param>
/// <param name="executorEP">end point of the executor</param>
/// <returns>Returns the exception that ocured.</returns>
public Exception Executor_ConnectDedicatedExecutor(SecurityCredentials sc, string executorId, EndPoint executorEP)
{
Exception ret = null;
try
{
logger.Debug("Executor called: ConnectDedicated: Authenticate,EnsurePermission,Connect,Set DedicatedScheduler");
AuthenticateUser(sc);
EnsurePermission(sc, Permission.ExecuteThread);
try
{
_Executors[executorId].ConnectDedicated(executorEP);
InternalShared.Instance.DedicatedSchedulerActive.Set();
}
catch (ExecutorCommException ece)
{
logger.Error("Couldnt connect back to the supplied executor", ece);
throw new ConnectBackException("Couldn't connect back to the supplied Executor", ece);
}
}
catch (Exception ex)
{
ret = new RemoteException(ex.Message, ex);
}
return ret;
}
/// <summary>
/// Connect to an executor which is in non-dedicated mode.
/// This is called by a non-dedicated executor using its reference to this manager.
/// </summary>
/// <param name="sc">security credentials to verify if the executor has permission to perform this operation
/// (i.e connect non-dedicated, which is associated with the ExecuteThread permission)</param>
/// <param name="executorId">executor id</param>
/// Returns the exception that ocured.
public Exception Executor_ConnectNonDedicatedExecutor(SecurityCredentials sc, string executorId, EndPoint executorEP)
{
Exception ret = null;
try
{
logger.Debug("Executor called: ConnectNonDedicated");
AuthenticateUser(sc);
EnsurePermission(sc, Permission.ExecuteThread);
_Executors[executorId].ConnectNonDedicated(executorEP);
logger.Debug("Connected to executor non-dedicated: " + executorId);
_Executors[executorId].HeartbeatUpdate(new HeartbeatInfo(0, 0, 0));
}
catch (Exception ex)
{
ret = new RemoteException(ex.Message, ex);
}
return ret;
}
protected internal override void OnRemoteException(RemoteException e)
{
base.OnRemoteException(e);
Security.RemoveNonce(mNonce);
}
/// <summary>
/// Called when a remote exception occurs while trying to execute the
/// <seealso cref="#run()"/> method. The derived class can override this to
/// execute exception-handling code. </summary>
/// <param name="e"> the exception </param>
protected internal virtual void OnRemoteException(RemoteException e)
{
Log.Warn(TAG, "remote billing service crashed");
mService = null;
}
