public override string Evaluate(Token token) { TraceLog.Info("Entering CBR: " + Name); XDocument testedDocument = Config.TestedSelection.GetSelectedDocument(token); string targetNodeName = evaluator.GetTargetNodeName(testedDocument); return targetNodeName; }
public void FinishToken(string updatingProcessorName, Token targetToken, SerializableXDocument resultMessage) { lock (syncLock) { MessageFlowState messageflowState = targetToken.GetMessageFlowState(); if (messageflowState.AssignedProcessor == updatingProcessorName) { storage.UpdateToken(targetToken, delegate(Token token) { token.UpdateMessageFlowState(mfs => { mfs.LastResponseFromProcessor = DateTime.Now; }); }); XDocument sourceMetadata = targetToken.GetSourceMetadata(); var sourceAdress = targetToken.GetSourceAddress(); if (sourceAdress != null) { string sourceGatewayName = sourceAdress.GatewayName; GatewayAccessor sourceGateway = componentsAccessors.Values.OfType<GatewayAccessor>().SingleOrDefault(gwa => gwa.ComponentName == sourceGatewayName); sourceGateway.ReceiveReturn(targetToken.Guid, resultMessage, new SerializableXDocument(sourceMetadata)); } storage.UpdateToken(targetToken, delegate(Token token) { token.State = TokenState.Finished; }); } } }
public void Evaluate(Token token) { TraceLog.Info(string.Format("Entering XSL transformation of '{0}' to message '{1}'", inputMessageSelection.SelectionPattern, outputMessageName)); XDocument inputMessage = inputMessageSelection.GetSelectedDocument(token); var reader = inputMessage.Root.CreateReader(); XDocument outputMessage; if (xslTransform.OutputSettings.OutputMethod != XmlOutputMethod.Xml) { StringWriter writer = new StringWriter(); XmlDocument xmlInputMessage = new XmlDocument(); xmlInputMessage.Load(reader); xslTransform.Transform(xmlInputMessage, null, writer); string result = writer.ToString(); outputMessage = new XDocument(new XElement(XName.Get("content"))); outputMessage.Root.Value = result; } else { StringBuilder outputBuilder = new StringBuilder(); var writer = XmlWriter.Create(outputBuilder); xslTransform.Transform(reader, writer); outputMessage = XDocument.Parse(outputBuilder.ToString()); } ProcessorService.CreateMessage(token, outputMessageName, outputMessage); }
public override string Evaluate(Token token) { TraceLog.Info("Entering terminator: " + Name); XDocument resultMessage = null; if (Config.IsReturningOutput) { resultMessage = Config.ResultMessageSelection.GetSelectedDocument(token); } ProcessorService.FinishToken(token, resultMessage); return null; }
public void AddMessageToToken(string updatingProcessorName, Token targetToken, string messageName, SerializableXDocument message) { lock (syncLock) { storage.UpdateToken(targetToken, delegate(Token token) { MessageFlowState messageflowState = token.GetMessageFlowState(); if (messageflowState.AssignedProcessor == updatingProcessorName) { token.UpdateMessageFlowState(mfs => { mfs.LastResponseFromProcessor = DateTime.Now; }); token.AddMessage(messageName, message); } }); } }
public override string Evaluate(Token token) { TraceLog.Info("Evaluating action: " + Name); Parallel.ForEach(actions, delegate(IActionPlugin action) { try { action.Evaluate(token); } catch (Exception ex) { ProcessorService.AddExceptionToToken(token, ex); } }); return Config.NextNode.Name; }
public void AddExceptionToToken(string updatingProcessorName, Token targetToken, string sourceNodeName, string message, string stackTrace) { lock (syncLock) { storage.UpdateToken(targetToken, delegate(Token token) { MessageFlowState messageflowState = token.GetMessageFlowState(); if (messageflowState.AssignedProcessor == updatingProcessorName) { token.UpdateMessageFlowState(mfs => { mfs.LastResponseFromProcessor = DateTime.Now; }); token.AddException(sourceNodeName, message, stackTrace); } }); } }
public void AddWork(Token token) { TraceLog.Info("Processor received a token with GUID " + token.Guid); lock (addWorkLock) { if (isStopping) { throw new InvalidOperationException(string.Format( "Cannot add token with GUID '{0}' the a processor because it is just stopping.", token.Guid)); } if (token.State != TokenState.Finished) { tokensFinishedEvent.Reset(); Interlocked.Increment(ref tokensCount); tokensToProcess.Add(token); } } }
public void Evaluate(Token token) { TraceLog.Info(string.Format("Sending '{0}' to output endpoint '{1}'", messageSelection.SelectionPattern, targetEndpoint.ToString())); XDocument message = messageSelection.GetSelectedDocument(token); XDocument metadata = metadataSelection.GetSelectedDocument(token); XDocument outputMessage = null; Task sendTask = Task.Factory.StartNew( TraceLog.WrapWithExceptionLogging(delegate { outputMessage = processorService.SendMessage(targetEndpoint, message, metadata); })); bool isFinished = sendTask.Wait(TimeSpan.FromSeconds(timeoutInSeconds)); if (isFinished) { if (resultMessageName.Trim().Length > 0) { processorService.CreateMessage(token, resultMessageName.Trim(), outputMessage); } } }
/// <summary> /// Dispatches the token to the processor. /// </summary> /// <param name="token"></param> public void Dispatch(Token token) { if (isStopping) { return; } lock (tokenDispatchingLock) { MessageFlowState messageflowState = token.GetMessageFlowState(); if (messageflowState.AssignedProcessor != null) { return; // Token is already dispatched } // NOTE: it compares to default GUID returned by the new Guid() if (messageflowState.MessageFlowGuid == new Guid()) { token = brokerService.UpdateTokenMessageFlow(token.Guid, messageFlowGuid); } try { TraceLog.Info(string.Format( "Dispatcher assigning token '{0}' to processor '{1}'", token.Guid, processor.ComponentName)); token = brokerService.UpdateTokenLastResponseFromProcessor(token.Guid, DateTime.Now); token = brokerService.UpdateTokenAssignedProcessor(token.Guid, processor.ComponentName); token.State = TokenState.InProcessor; processor.AddWork(token); } catch { // NOTE: token retains the Received state brokerService.UpdateTokenAssignedProcessor(token.Guid, null); } } }
/// <summary> /// Finishes the token processing. It changes only the token state, not /// the message flow. Also it might send a reply message back to the /// source gateway. /// </summary> /// <param name="token">token to be finished</param> /// <param name="resultMessage">reply message going back the the original /// gateway; can be null</param> public void FinishToken(Token token, XDocument resultMessage) { SerializableXDocument serializableResultMessage = new SerializableXDocument(resultMessage); BrokerService.FinishToken(ProcessorName, token, serializableResultMessage); }
private IEnumerable<Token> CreateTokens(IEnumerable<string> tokensXml) { List<Token> result = new List<Token>(); foreach (string tokenXml in tokensXml) { Token token = new Token(tokenXml); result.Add(token); } return result; }
/// <summary> /// Updates a token and stores the content into an exiting instance. /// </summary> /// <remarks> /// Loads a token specified by its GUID from the storage, updates it /// with a provided action, saves it and returns the provided token /// instance only with updated content. /// </remarks> /// <param name="token"></param> /// <param name="updater"></param> public void UpdateToken(Token token, Action<Token> updater) { lock (updateTokenLock) { Token currentToken = GetToken(token.Guid); updater(currentToken); SaveToken(currentToken); token.UpdateContent(currentToken.Content); } }
public void SaveToken(Token token) { dataAccess.SaveToken(token); }
public Token GetToken(Guid tokenGuid) { // TODO: what about GUID of a non-existent token string tokenXml = dataAccess.LoadToken(tokenGuid); Token result = new Token(tokenGuid, tokenXml); return result; }
public void UpdateTokenMessageFlowState(string updatingProcessorName, Token targetToken, MessageFlowState messageFlowState) { lock (syncLock) { storage.UpdateToken(targetToken, delegate(Token token) { if (messageFlowState.AssignedProcessor == updatingProcessorName) { messageFlowState.LastResponseFromProcessor = DateTime.Now; token.SetMessageFlowState(messageFlowState); } }); } }
/// <summary> /// Receives an input message containing XML data in an XDocument. /// </summary> /// <remarks> /// This method is asynchronous and can simulate synchronous /// communication. The reply is send back from within a given result /// handler and a context is preseved. /// </remarks> /// <param name="message">XML message content in an XDocument</param> /// <param name="endpointName">input endpoint name; can be null</param> /// <param name="metadata">metadata about the input message; can be null</param> /// <param name="context">arbitrary context which should be retained /// until a possible reply; can be null</param> /// <param name="resultHandler">action to be performed with the reply /// message when the token processing has been finished</param> protected void ReceiveMessageXml( XDocument message, string endpointName, XDocument metadata, object context, MessageResultHandler resultHandler) { Token token = new Token(); token.IsPersistent = AreInputTokensPersistent; token.SetSourceAddress(new EndpointAddress(Gateway.Name, AdapterName, endpointName)); token.SaveSourceMetadata(metadata); token.AddMessage(Constants.InputMessageName, message); TraceLog.Info("Created token with GUID " + token.Guid); Gateway.ReceiveToken(token, context, resultHandler); }
public void SaveToken(Token token) { string tokenXml = token.Content.XDocument.ToString(); string inputMessage = token.GetMessage("input").ToString(); EndpointAddress endpointAddress = token.GetSourceAddress(); ExecuteProcedure("SaveToken", new SqlParameter[] { new SqlParameter("InputGUID", token.Guid), new SqlParameter("Token", tokenXml), new SqlParameter("TokenState", token.State.ToString()), new SqlParameter("Message", inputMessage), (token.Created == DateTime.MinValue ? new SqlParameter("Created", DBNull.Value): new SqlParameter("Created", token.Created)), (token.Received == DateTime.MinValue ? new SqlParameter("Received", DBNull.Value): new SqlParameter("Received", token.Received)), (token.Dispatched == DateTime.MinValue ? new SqlParameter("Dispatched", DBNull.Value): new SqlParameter("Dispatched", token.Dispatched)), (token.Finished == DateTime.MinValue ? new SqlParameter("Finished", DBNull.Value): new SqlParameter("Finished", token.Finished)), new SqlParameter("IsPersistent", token.IsPersistent), new SqlParameter("AdapterName", endpointAddress.AdapterName), new SqlParameter("EndpointName", endpointAddress.EndpointName) }).Close(); }
/// <summary> /// Adds an exception to the token along with the name of the node /// where the exception was thrown. /// </summary> /// <param name="targetToken">token to which to add the exception /// </param> /// <param name="ex">exception to be added to the token</param> /// <param name="updatedToken">updated token</param> public void AddExceptionToToken(Token targetToken, Exception ex) { BrokerService.AddExceptionToToken(ProcessorName, targetToken, Node.Name, ex.Message, ex.StackTrace); }
/// <summary> /// Performs a single step in the message flow graph traversal. This /// corresponds to moving along an edge from one node to another. /// </summary> /// <remarks> /// After each step the message flow state is saved to the token. /// </remarks> /// <param name="token">token to be processed</param> /// <returns>true if the traversal should continue; false if it has /// finished</returns> public bool DoStep(Token token) { #region Determine currentNode Node currentNode; string currentNodeName = token.GetMessageFlowState().NextNodeName; if (currentNodeName != null) { currentNode = nodesByName[currentNodeName]; } else { currentNode = entryNode; } #endregion string nextNodeName = currentNode.Evaluate(token); MessageFlowState messageflowState = token.GetMessageFlowState(); messageflowState.NextNodeName = nextNodeName; token.SetMessageFlowState(messageflowState); if ((token.IsPersistent) && (!(currentNode is CbrNode))) { Processor.BrokerService.UpdateTokenMessageFlowState( Processor.Name, token, messageflowState); } bool shouldContinue = nextNodeName != null; return shouldContinue; }
/// <summary> /// Creates a new message within the token. /// </summary> /// <param name="targetToken">token to which to add the new message /// </param> /// <param name="messageName">name of the new message</param> /// <param name="message">message content</param> /// <returns>updated token</returns> public void CreateMessage( Token targetToken, string messageName, XDocument message) { BrokerService.AddMessageToToken(ProcessorName, targetToken, messageName, new SerializableXDocument(message)); }
/// <summary> /// Evaluates the node with the given token. /// </summary> /// <param name="token"></param> /// <returns> /// Name of the next node or null if the processing is terminated. /// </returns> public abstract string Evaluate(Token token);
public TokenRow(Token token) { Guid = token.Guid.ToString(); State = token.State.ToString(); ContentWithEnters = token.Content.XDocument.ToString(); Content = ContentWithEnters.Replace(Environment.NewLine, " "); }
public override string Evaluate(Token token) { return Config.NextNode.Name; }
/// <summary> /// Persistently updates the state of the message flow of a given /// token, ie. the state of its processing. /// </summary> /// <param name="token">token to be updated</param> /// <seealso cref="XRouter.Common.MessageFlowState"/> public void MakeMessageFlowStatePersistent(Token token) { BrokerService.UpdateTokenMessageFlowState(ProcessorName, token, token.GetMessageFlowState()); }
public void SaveToken(Token token) { SaveToken(token.Guid, token.Content.XDocument.ToString()); }
public void AddWork(Token token) { processor.AddWork(token); }
internal void ReceiveToken(Token token, object context, MessageResultHandler resultHandler = null) { if (resultHandler != null) { ResultHandlingInfo resultHandlingInfo = new ResultHandlingInfo(token.Guid, resultHandler, context); waitingResultMessageHandlers.AddOrUpdate(token.Guid, resultHandlingInfo, (key, oldValue) => resultHandlingInfo); } Broker.ReceiveToken(token); }
public void ReceiveToken(Token token) { lock (syncLock) { token.State = TokenState.Received; storage.SaveToken(token); dispatcher.Dispatch(token); } }