/// <summary> /// This extension adds the inline command to the pipeline /// </summary> /// <typeparam name="E">The pipeline type.</typeparam> /// <param name="cpipe">The pipeline.</param> /// <param name="contract">The contract.</param> /// <param name="commandFunction">The command function.</param> /// <param name="referenceId">The reference identifier.</param> /// <param name="startupPriority">The startup priority.</param> /// <param name="channelResponse">The channel response.</param> /// <returns>Returns the pipeline.</returns> /// <exception cref="InvalidMessageContractException"></exception> /// <exception cref="InvalidPipelineChannelContractException"></exception> public static E AttachCommand <E>(this E cpipe, Type contract , Func <CommandMethodRequestContext, Task> commandFunction , string referenceId = null , int startupPriority = 100 , IPipelineChannelOutgoing <IPipeline> channelResponse = null ) where E : IPipelineChannelIncoming <IPipeline> { string channelId, messageType, actionType; if (!ServiceMessageHelper.ExtractContractInfo(contract, out channelId, out messageType, out actionType)) { throw new InvalidMessageContractException(contract); } if (channelId != cpipe.Channel.Id) { throw new InvalidPipelineChannelContractException(contract, channelId, cpipe.Channel.Id); } var command = new CommandMethodInline((channelId, messageType, actionType), commandFunction, referenceId); cpipe.Pipeline.AddCommand(command, startupPriority, null, cpipe, channelResponse); return(cpipe); }
/// <summary> /// This method unregisters a command. /// </summary> /// <typeparam name="C">The message contract type</typeparam> protected virtual void CommandUnregister <C>() where C : IMessageContract { string channelId, messageType, actionType; ServiceMessageHelper.ExtractContractInfo <C>(out channelId, out messageType, out actionType); CommandUnregister(channelId, messageType, actionType); }
/// <summary> /// This method unregisters a command. /// </summary> /// <typeparam name="C">The message contract type</typeparam> protected virtual void CommandUnregister <C>() where C : IMessageContract { string channelId, messageType, actionType; if (!ServiceMessageHelper.ExtractContractInfo <C>(out channelId, out messageType, out actionType)) { throw new InvalidMessageContractException(typeof(C)); } CommandUnregister(channelId, messageType, actionType); }
/// <summary> /// This method register a command. /// </summary> /// <typeparam name="C">The contract channelId.</typeparam> /// <param name="action">The process action.</param> /// <param name="exceptionAction">The optional action call if an exception is thrown.</param> protected virtual void CommandRegister <CM>( Func <TransmissionPayload, List <TransmissionPayload>, Task> action, Func <TransmissionPayload, List <TransmissionPayload>, Task> deadLetterAction = null, Func <Exception, TransmissionPayload, List <TransmissionPayload>, Task> exceptionAction = null) where CM : IMessageContract { string channelId, messageType, actionType; ServiceMessageHelper.ExtractContractInfo <CM>(out channelId, out messageType, out actionType); CommandRegister(channelId, messageType, actionType, action, deadLetterAction, exceptionAction); }
/// <summary> /// /// </summary> /// <typeparam name="CM"></typeparam> /// <param name="action"></param> /// <param name="exceptionAction"></param> protected virtual void CommandRegister <CM>( Func <TransmissionPayload, List <TransmissionPayload>, Task> action, Func <Exception, TransmissionPayload, List <TransmissionPayload>, Task> exceptionAction = null) where CM : IMessageContract { string channelId, messageType, actionType; if (!ServiceMessageHelper.ExtractContractInfo <CM>(out channelId, out messageType, out actionType)) { throw new InvalidMessageContractException(typeof(CM)); } CommandRegister((channelId, messageType, actionType), action, exceptionAction, typeof(CM).Name); }
/// <summary> /// This method creates a service message and injects it in to the execution path and bypasses the listener infrastructure. /// </summary> /// <typeparam name="C">The message contract.</typeparam> /// <param name="package">The objet package to process.</param> /// <param name="ChannelPriority">The prioirty that the message should be processed. The default is 1. If this message is not a valid value, it will be matched to the nearest valid value.</param> /// <param name="options">The process options.</param> /// <param name="release">The release action which is called when the payload has been executed.</param> /// by the receiving commands.</param> public void Process <C>(object package = null , int ChannelPriority = 1 , ProcessOptions options = ProcessOptions.RouteExternal | ProcessOptions.RouteInternal , Action <bool, Guid> release = null) where C : IMessageContract { string channelId, messageType, actionType; if (!ServiceMessageHelper.ExtractContractInfo <C>(out channelId, out messageType, out actionType)) { throw new InvalidMessageContractException(typeof(C)); } Process(channelId, messageType, actionType, package, ChannelPriority, options, release); }
/// <summary> /// This method is used to send requests to the remote command. /// </summary> /// <typeparam name="I">The contract interface.</typeparam> /// <typeparam name="RQ">The request type.</typeparam> /// <typeparam name="RS">The response type.</typeparam> /// <param name="rq">The request object.</param> /// <param name="routing"></param> /// <param name="settings"></param> /// <returns>Returns a response object of the specified type in a response metadata wrapper.</returns> protected virtual async Task <ResponseWrapper <RS> > ProcessOutgoing <I, RQ, RS>(RQ rq , RequestSettings settings = null , ProcessOptions?routing = null , IPrincipal principal = null) where I : IMessageContract { string channelId, messageType, actionType; if (!ServiceMessageHelper.ExtractContractInfo <I>(out channelId, out messageType, out actionType)) { throw new InvalidOperationException("Unable to locate message contract attributes for " + typeof(I)); } return(await ProcessOutgoing <RQ, RS>(channelId, messageType, actionType, rq, settings, routing , principal : principal ?? Thread.CurrentPrincipal)); }
public CommandContractAttribute(Type interfaceType) { if (!interfaceType.IsInterface || interfaceType.IsSubclassOf(typeof(IMessageContract))) { throw new ArgumentOutOfRangeException("interfaceType must be an interface and derived from IMessageContract"); } string channelId, messageType, actionType; if (!ServiceMessageHelper.ExtractContractInfo(interfaceType, out channelId, out messageType, out actionType)) { throw new InvalidOperationException($"Unable to locate contract attributes for {interfaceType.Name}"); } Header = new ServiceMessageHeader(channelId, messageType, actionType); }
/// <summary> /// /// </summary> /// <typeparam name="T"></typeparam> /// <returns></returns> public static TransmissionPayload Create <T>(bool traceEnabled = false) where T : IMessageContract { string channelId, messageType, actionType; if (!ServiceMessageHelper.ExtractContractInfo(typeof(T), out channelId, out messageType, out actionType)) { throw new InvalidOperationException("Unable to locate contract attributes for " + typeof(T)); } var message = new ServiceMessage { ChannelId = channelId, MessageType = messageType, ActionType = actionType }; return(new TransmissionPayload(message, traceEnabled: traceEnabled)); }
/// <summary> /// This method is used to send requests to the remote command. /// </summary> /// <typeparam name="I">The contract interface.</typeparam> /// <typeparam name="RQ">The request type.</typeparam> /// <typeparam name="RS">The response type.</typeparam> /// <param name="rq">The request object.</param> /// <param name="rqSettings">The request settings. Use this to specifically set the timeout parameters.</param> /// <param name="routingOptions">The routing options by default this will try internal and then external.</param> /// <param name="processResponse"></param> /// <param name="fallbackMaxProcessingTime">This is the fallback max processing time used if the timeout /// is not set in the request settings. /// If this is also null, the max time out will fall back to the policy settings.</param> /// <param name="principal">This is the principal that you wish the command to be executed under. /// By default this is taken from the calling thread if not passed.</param> /// <returns>Returns the async response wrapper.</returns> /// <returns>Returns a response object of the specified type in a response metadata wrapper.</returns> protected internal virtual async Task <ResponseWrapper <RS> > ProcessOutgoing <I, RQ, RS>(RQ rq , RequestSettings rqSettings = null , ProcessOptions?routingOptions = null , Func <TaskStatus, TransmissionPayload, bool, ResponseWrapper <RS> > processResponse = null , TimeSpan?fallbackMaxProcessingTime = null , IPrincipal principal = null) where I : IMessageContract { string channelId, messageType, actionType; if (!ServiceMessageHelper.ExtractContractInfo <I>(out channelId, out messageType, out actionType)) { throw new InvalidOperationException("Unable to locate message contract attributes for " + typeof(I)); } return(await ProcessOutgoing <RQ, RS>(channelId, messageType, actionType , rq , rqSettings , routingOptions , processResponse , fallbackMaxProcessingTime , principal ?? Thread.CurrentPrincipal )); }