Esempio n. 1
0
        public FailedEvaluator(IFailedEvaluatorClr2Java clr2Java)
        {
            FailedEvaluatorClr2Java = clr2Java;
            _id = FailedEvaluatorClr2Java.GetId();
            _failedContexts = new List<IFailedContext>(
                FailedEvaluatorClr2Java.GetFailedContextsClr2Java().Select(clr2JavaFailedContext => 
                    new FailedContext(clr2JavaFailedContext)));

            var errorBytes = FailedEvaluatorClr2Java.GetErrorBytes();
            if (errorBytes != null && errorBytes.Length != 0)
            {
                // When the Exception originates from the C# side.
                Exception inner;
                try
                {
                    inner = (Exception)ByteUtilities.DeserializeFromBinaryFormat(errorBytes);
                }
                catch (SerializationException se)
                {
                    inner = NonSerializableEvaluatorException.UnableToDeserialize(
                        "Exception from Evaluator was not able to be deserialized, returning a NonSerializableEvaluatorException.", se);
                }

                _evaluatorException = new EvaluatorException(_id, inner.Message, inner);
            }
            else
            {
                // When the Exception originates from Java.
                _evaluatorException = new EvaluatorException(
                    _id, FailedEvaluatorClr2Java.GetJavaCause(), FailedEvaluatorClr2Java.GetJavaStackTrace());
            }
        }
Esempio n. 2
0
        public FailedEvaluator(IFailedEvaluatorClr2Java clr2Java)
        {
            FailedEvaluatorClr2Java = clr2Java;
            _id             = FailedEvaluatorClr2Java.GetId();
            _failedContexts = new List <IFailedContext>(
                FailedEvaluatorClr2Java.GetFailedContextsClr2Java().Select(clr2JavaFailedContext =>
                                                                           new FailedContext(clr2JavaFailedContext)));

            var errorBytes = FailedEvaluatorClr2Java.GetErrorBytes();

            if (errorBytes != null && errorBytes.Length != 0)
            {
                // When the Exception originates from the C# side.
                Exception inner;
                try
                {
                    inner = (Exception)ByteUtilities.DeserializeFromBinaryFormat(errorBytes);
                }
                catch (SerializationException se)
                {
                    inner = NonSerializableEvaluatorException.UnableToDeserialize(
                        "Exception from Evaluator was not able to be deserialized, returning a NonSerializableEvaluatorException.", se);
                }

                _evaluatorException = new EvaluatorException(_id, inner.Message, inner);
            }
            else
            {
                // When the Exception originates from Java.
                _evaluatorException = new EvaluatorException(
                    _id, FailedEvaluatorClr2Java.GetJavaCause(), FailedEvaluatorClr2Java.GetJavaStackTrace());
            }
        }
Esempio n. 3
0
        /// <summary>
        /// This handles runtime error occurs on the evaluator
        /// </summary>
        /// <param name="runtimeErrorProto"></param>
        public void Handle(RuntimeErrorProto runtimeErrorProto)
        {
            FailedRuntime error = new FailedRuntime(runtimeErrorProto);

            LOGGER.Log(Level.Warning, "Runtime error:" + error);

            EvaluatorException evaluatorException = error.Cause != null
                ? new EvaluatorException(error.Id, error.Cause.Value)
                : new EvaluatorException(error.Id, "Runtime error");
            EvaluatorManager evaluatorManager = null;

            lock (_evaluators)
            {
                if (_evaluators.ContainsKey(error.Id))
                {
                    evaluatorManager = _evaluators[error.Id];
                }
                else
                {
                    LOGGER.Log(Level.Warning, "Unknown evaluator runtime error: " + error.Cause);
                }
            }
            if (null != evaluatorManager)
            {
                evaluatorManager.Handle(evaluatorException);
            }
        }
Esempio n. 4
0
 public BridgeFailedEvaluator(
     string id,
     EvaluatorException evaluatorException,
     IList <IFailedContext> failedContexts,
     Optional <IFailedTask> failedTask)
 {
     Id = id;
     EvaluatorException = evaluatorException;
     FailedContexts     = failedContexts;
     FailedTask         = failedTask;
 }
Esempio n. 5
0
        /// <summary>
        /// EvaluatorException will trigger is FailedEvaluator and state transition to FAILED
        /// </summary>
        /// <param name="exception"></param>
        public void Handle(EvaluatorException exception)
        {
            lock (_evaluatorDescriptor)
            {
                if (_state >= STATE.DONE)
                {
                    return;
                }
                LOGGER.Log(Level.Warning, "Failed Evaluator: " + Id + exception.Message);
                try
                {
                    IList <FailedContext>    failedContexts = new List <FailedContext>();
                    IList <EvaluatorContext> activeContexts = new List <EvaluatorContext>(_activeContexts);
                    activeContexts = activeContexts.Reverse().ToList();
                    foreach (EvaluatorContext context in activeContexts)
                    {
                        Optional <IActiveContext> parentContext = context.ParentId.IsPresent()
                            ? Optional <IActiveContext> .Of(GetEvaluatorContext(context.ParentId.Value))
                            : Optional <IActiveContext> .Empty();

                        failedContexts.Add(context.GetFailedContext(parentContext, exception));
                    }

                    //Optional<FailedTask> failedTask = _runningTask != null ?
                    //    Optional<FailedTask>.Of(new FailedTask(_runningTask.Id, exception)) : Optional<FailedTask>.Empty();
                    //LOGGER.Log(Level.Info, "TODO: REPLACE THIS " + failedTask.ToString());
                    //this.dispatcher.onNext(FailedEvaluator.class, new FailedEvaluatorImpl(
                    //exception, failedContextList, failedTaskOptional, this.evaluatorId));
                }
                catch (Exception e)
                {
                    Exceptions.CaughtAndThrow(e, Level.Error, "Exception while handling FailedEvaluator.", LOGGER);
                }
                finally
                {
                    _state = STATE.FAILED;
                    Dispose();
                }
            }
        }
Esempio n. 6
0
        public void Handle(IRemoteMessage <EvaluatorHeartbeatProto> evaluatorHearBeatProtoMessage)
        {
            lock (_evaluatorDescriptor)
            {
                EvaluatorHeartbeatProto heartbeatProto = evaluatorHearBeatProtoMessage.Message;
                if (heartbeatProto.evaluator_status != null)
                {
                    EvaluatorStatusProto status = heartbeatProto.evaluator_status;
                    if (status.error != null)
                    {
                        Handle(new EvaluatorException(Id, ByteUtilities.ByteArrarysToString(status.error)));
                        return;
                    }
                    else if (_state == STATE.SUBMITTED)
                    {
                        string evaluatorRId = evaluatorHearBeatProtoMessage.Identifier.ToString();
                        LOGGER.Log(Level.Info, "TODO: REPLACE THIS " + evaluatorRId);
                        // TODO
                        // _evaluatorControlHandler = _remoteManager.getHandler(evaluatorRID, EvaluatorRuntimeProtocol.EvaluatorControlProto.class);
                        _state = STATE.RUNNING;
                        LOGGER.Log(Level.Info, string.Format(CultureInfo.InvariantCulture, "Evaluator {0} is running", _evaluatorId));
                    }
                }

                LOGGER.Log(Level.Info, "Evaluator heartbeat: " + heartbeatProto);

                EvaluatorStatusProto evaluatorStatusProto = heartbeatProto.evaluator_status;
                foreach (ContextStatusProto contextStatusProto in heartbeatProto.context_status)
                {
                    Handle(contextStatusProto, heartbeatProto.task_status != null);
                }

                if (heartbeatProto.task_status != null)
                {
                    Handle(heartbeatProto.task_status);
                }

                if (evaluatorStatusProto.state == State.FAILED)
                {
                    _state = STATE.FAILED;
                    EvaluatorException e = evaluatorStatusProto.error != null ?
                                           new EvaluatorException(_evaluatorId, ByteUtilities.ByteArrarysToString(evaluatorStatusProto.error)) :
                                           new EvaluatorException(_evaluatorId, "unknown cause");
                    LOGGER.Log(Level.Warning, "Failed evaluator: " + Id + e.Message);
                    Handle(e);
                }
                else if (evaluatorStatusProto.state == State.DONE)
                {
                    LOGGER.Log(Level.Info, string.Format(CultureInfo.InvariantCulture, "Evaluator {0} done", Id));
                    _state = STATE.DONE;

                    // TODO
                    // dispatcher.onNext(CompletedEvaluator.class, new CompletedEvaluator() {
                    //@Override
                    //public String getId() {
                    //  return EvaluatorManager.this.evaluatorId;
                    Dispose();
                }
            }
            LOGGER.Log(Level.Info, "DONE with evaluator heartbeat");
        }