public override string ToString() { string contextStatus = string.Empty; string taskStatusMessage = string.Empty; foreach (ContextStatusProto contextStatusProto in context_status) { contextStatus += string.Format(CultureInfo.InvariantCulture, "evaluator {0} has context {1} in state {2} with recovery flag {3}", evaluator_status.evaluator_id, contextStatusProto.context_id, contextStatusProto.context_state, contextStatusProto.recovery); } if (task_status != null && task_status.task_message != null && task_status.task_message.Count > 0) { foreach (TaskStatusProto.TaskMessageProto taskMessageProto in task_status.task_message) { taskStatusMessage += ByteUtilities.ByteArrarysToString(taskMessageProto.message); } } return(string.Format(CultureInfo.InvariantCulture, "EvaluatorHeartbeatProto: task_id=[{0}], task_status=[{1}], task_message=[{2}], evaluator_status=[{3}], context_status=[{4}], timestamp=[{5}], recoveryFlag =[{6}]", task_status == null ? string.Empty : task_status.task_id, task_status == null ? string.Empty : task_status.state.ToString(), taskStatusMessage, evaluator_status.state.ToString(), contextStatus, timestamp, recovery)); }
/// <summary> /// Get the exception from error /// </summary> /// <param name="error"></param> /// <returns>excetpiont from error</returns> private static Exception GetException(RuntimeErrorProto error) { byte[] data = error.exception; if (data != null) { return(new InvalidOperationException(ByteUtilities.ByteArrarysToString(error.exception))); } return(null); }
public void OnNext(ITaskMessage taskMessage) { string msgReceived = ByteUtilities.ByteArrarysToString(taskMessage.Message); LOGGER.Log(Level.Info, string.Format(CultureInfo.InvariantCulture, "CLR TaskMessagingTaskMessageHandler received following message from Task: {0}, Message: {1}.", taskMessage.TaskId, msgReceived)); if (!msgReceived.StartsWith(MessageTask.MessageSend, true, CultureInfo.CurrentCulture)) { Exceptions.Throw(new Exception("Unexpected message: " + msgReceived), "Unexpected task message received: " + msgReceived, LOGGER); } }
public void Handle(IDriverMessage value) { string message = string.Empty; LOGGER.Log(Level.Verbose, "Receieved a message from driver, handling it with HelloDriverMessageHandler"); if (value.Message.IsPresent()) { message = ByteUtilities.ByteArrarysToString(value.Message.Value); } _parentTask.HandleDriverMessage(message); }
public ProcessedResults Decode(byte[] data) { string[] parts = ByteUtilities.ByteArrarysToString(data).Split('+'); if (parts.Count() != 2) { throw new ArgumentException("cannot deserialize from" + ByteUtilities.ByteArrarysToString(data)); } float loss = float.Parse(parts[0], CultureInfo.InvariantCulture); List <PartialMean> means = parts[1].Split('@').Select(PartialMean.FromString).ToList(); return(new ProcessedResults(means, loss)); }
public void TestHttpRequestSerializationBytesRoundTrip() { AvroHttpRequest r = CreatAvorHttpRequest(); var b = AvroHttpSerializer.ToBytes(r); var r1 = AvroHttpSerializer.FromBytes(b); var ri = ByteUtilities.ByteArrarysToString(r.InputStream); var ri1 = ByteUtilities.ByteArrarysToString(r1.InputStream); Assert.AreEqual(ri, ri1); Assert.AreEqual(r.QueryString, r1.QueryString); }
public void TestHttpRequestSerializationJasonRoundTrip() { AvroHttpRequest r = CreatAvorHttpRequest(); string str = AvroHttpSerializer.ToJson(r); byte[] bytes = ByteUtilities.StringToByteArrays(str); var r1 = AvroHttpSerializer.FromBytesWithJoson(bytes); var ri = ByteUtilities.ByteArrarysToString(r.InputStream); var ri1 = ByteUtilities.ByteArrarysToString(r1.InputStream); Assert.AreEqual(ri, ri1); Assert.AreEqual(r.QueryString, r1.QueryString); }
public void OnNext(IFailedTask failedTask) { string errorMessage = string.Format( CultureInfo.InvariantCulture, "Task [{0}] has failed caused by [{1}], with message [{2}] and description [{3}]. The raw data for failure is [{4}].", failedTask.Id, failedTask.Reason.IsPresent() ? failedTask.Reason.Value : string.Empty, failedTask.Message, failedTask.Description.IsPresent() ? failedTask.Description.Value : string.Empty, failedTask.Data.IsPresent() ? ByteUtilities.ByteArrarysToString(failedTask.Data.Value) : string.Empty); Console.WriteLine(errorMessage); if (failedTask.GetActiveContext().IsPresent()) { Console.WriteLine("Disposing the active context the failed task ran in."); // we must do something here: either close the context or resubmit a task to the active context failedTask.GetActiveContext().Value.Dispose(); } }
/// <summary> /// Handle a context status update /// </summary> /// <param name="contextStatusProto"></param> /// <param name="notifyClientOnNewActiveContext"></param> private void Handle(ContextStatusProto contextStatusProto, bool notifyClientOnNewActiveContext) { string contextId = contextStatusProto.context_id; Optional <string> parentId = contextStatusProto.parent_id != null ? Optional <string> .Of(contextStatusProto.parent_id) : Optional <string> .Empty(); if (ContextStatusProto.State.READY == contextStatusProto.context_state) { if (!_activeContextIds.Contains(contextId)) { EvaluatorContext evaluatorContext = new EvaluatorContext(this, contextId, parentId); AddEvaluatorContext(evaluatorContext); if (notifyClientOnNewActiveContext) { LOGGER.Log(Level.Info, "TODO: REPLACE THIS " + evaluatorContext.ToString()); //TODO //dispatcher.onNext(ActiveContext.class, context); } } foreach (ContextStatusProto.ContextMessageProto contextMessageProto in contextStatusProto.context_message) { byte[] message = contextMessageProto.message; string sourceId = contextMessageProto.source_id; LOGGER.Log(Level.Info, "TODO: REPLACE THIS " + sourceId + message); // this.dispatcher.onNext(ContextMessage.class, //new ContextMessageImpl(theMessage, contextID, sourceID)); } } else { if (!_activeContextIds.Contains(contextId)) { if (ContextStatusProto.State.FAIL == contextStatusProto.context_state) { AddEvaluatorContext(new EvaluatorContext(this, contextId, parentId)); } else { var e = new InvalidOperationException("unknown context signaling state " + contextStatusProto.context_state); Exceptions.Throw(e, LOGGER); } } } EvaluatorContext context = GetEvaluatorContext(contextId); EvaluatorContext parentContext = context.ParentId.IsPresent() ? GetEvaluatorContext(context.ParentId.Value) : null; RemoveEvaluatorContext(context); if (ContextStatusProto.State.FAIL == contextStatusProto.context_state) { // TODO Exception reason = new InvalidOperationException(ByteUtilities.ByteArrarysToString(contextStatusProto.error)); Optional <IActiveContext> optionalParentContext = (null == parentContext) ? Optional <IActiveContext> .Empty() : Optional <IActiveContext> .Of(parentContext); LOGGER.Log(Level.Info, "TODO: REPLACE THIS " + reason.ToString() + optionalParentContext); // TODO //this.dispatcher.onNext(FailedContext.class, //context.getFailedContext(optionalParentContext, reason)); } else if (ContextStatusProto.State.DONE == contextStatusProto.context_state) { if (null != parentContext) { // TODO //this.dispatcher.onNext(ClosedContext.class, context.getClosedContext(parentContext)); } else { LOGGER.Log(Level.Info, "Root context closed. Evaluator closed will trigger final shutdown."); } } else { var e = new InvalidOperationException(string.Format(CultureInfo.InvariantCulture, "Unknown context state {0} for context {1}", contextStatusProto.context_state, contextId)); Exceptions.Throw(e, LOGGER); } }
/// <summary> /// helper function mostly used for logging /// </summary> /// <returns>seralized string</returns> public override string ToString() { return(ByteUtilities.ByteArrarysToString(new ProcessedResultsCodec().Encode(this))); }
public void OnNext(IContextMessage value) { LOGGER.Log(Level.Info, "Received ContextMessage: " + ByteUtilities.ByteArrarysToString(value.Message)); }
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"); }
/// <summary> /// helper function mostly used for logging /// </summary> /// <returns>the serialized string</returns> public override string ToString() { return(ByteUtilities.ByteArrarysToString(new CentroidsCodec().Encode(this))); }
private void Check() { if (_result.IsPresent() && _lastException.IsPresent()) { LOGGER.Log(Level.Warning, "Both task result and exception are present, the expcetion will take over. Thrown away result:" + ByteUtilities.ByteArrarysToString(_result.Value)); State = TaskState.Failed; _result = Optional <byte[]> .Empty(); } }
public void OnNext(IRemoteMessage <REEFMessage> value) { REEFMessage remoteEvent = value.Message; IRemoteIdentifier id = value.Identifier; LOGGER.Log(Level.Info, string.Format(CultureInfo.InvariantCulture, "receive a ReefMessage from {0} Driver at {1}.", remoteEvent, id)); if (remoteEvent.evaluatorControl != null) { if (remoteEvent.evaluatorControl.context_control != null) { string context_message = null; string task_message = null; if (remoteEvent.evaluatorControl.context_control.context_message != null) { context_message = remoteEvent.evaluatorControl.context_control.context_message.ToString(); } if (remoteEvent.evaluatorControl.context_control.task_message != null) { task_message = ByteUtilities.ByteArrarysToString(remoteEvent.evaluatorControl.context_control.task_message); } if (!(string.IsNullOrEmpty(context_message) && string.IsNullOrEmpty(task_message))) { LOGGER.Log(Level.Info, string.Format(CultureInfo.InvariantCulture, "Control protobuf with context message [{0}] and task message [{1}]", context_message, task_message)); } else if (remoteEvent.evaluatorControl.context_control.remove_context != null) { LOGGER.Log(Level.Info, string.Format(CultureInfo.InvariantCulture, "Control protobuf to remove context {0}", remoteEvent.evaluatorControl.context_control.remove_context.context_id)); } else if (remoteEvent.evaluatorControl.context_control.add_context != null) { LOGGER.Log(Level.Info, string.Format(CultureInfo.InvariantCulture, "Control protobuf to add a context on top of {0}", remoteEvent.evaluatorControl.context_control.add_context.parent_context_id)); } else if (remoteEvent.evaluatorControl.context_control.start_task != null) { LOGGER.Log(Level.Info, string.Format(CultureInfo.InvariantCulture, "Control protobuf to start an task in {0}", remoteEvent.evaluatorControl.context_control.start_task.context_id)); } else if (remoteEvent.evaluatorControl.context_control.stop_task != null) { LOGGER.Log(Level.Info, "Control protobuf to stop task"); } else if (remoteEvent.evaluatorControl.context_control.suspend_task != null) { LOGGER.Log(Level.Info, "Control protobuf to suspend task"); } } } if (_count == 0) { _begin = DateTime.Now; _origBegin = _begin; } var count = Interlocked.Increment(ref _count); int printBatchSize = 100000; if (count % printBatchSize == 0) { DateTime end = DateTime.Now; var diff = (end - _begin).TotalMilliseconds; double seconds = diff / 1000.0; long eventsPerSecond = (long)(printBatchSize / seconds); _begin = DateTime.Now; } var observer = _observer; if (observer != null) { observer.OnNext(value); } }
public static T FromBytes(byte[] bytes) { return(FromString(ByteUtilities.ByteArrarysToString(bytes))); }
public void OnHttpRequest(ReefHttpRequest requet, ReefHttpResponse response) { LOGGER.Log(Level.Info, string.Format(CultureInfo.CurrentCulture, "HelloHttpHandler OnHttpRequest: URL: {0}, QueryString: {1}, inputStream: {2}.", requet.Url, requet.Querystring, ByteUtilities.ByteArrarysToString(requet.InputStream))); response.Status = HttpStatusCode.OK; response.OutputStream = ByteUtilities.StringToByteArrays("Byte array returned from HelloHttpHandler in CLR!!!"); }
public override string ToString() { return("DriverMessage [value=" + ByteUtilities.ByteArrarysToString(_value.Value) + "]"); }
public void OnNext(byte[] value) { LOGGER.Log(Level.Info, "Received message: " + ByteUtilities.ByteArrarysToString(value)); }
public void OnNext(byte[] value) { Exceptions.Throw(new InvalidOperationException("No handler bound for client Close With Message event:" + ByteUtilities.ByteArrarysToString(value)), Logger.GetLogger(typeof(DefaultClientCloseWithMessageHandler))); }
/// <summary> /// Conver bytes which contains Json string into AvroHttpRequest object /// </summary> /// <param name="serializedBytes">The serialized bytes.</param> /// <returns>AvroHttpRequest.</returns> public static AvroHttpRequest FromBytesWithJoson(byte[] serializedBytes) { string s = ByteUtilities.ByteArrarysToString(serializedBytes); return(FromJson(s)); }