Пример #1
0
		public LogImpl(DateTime date, EventType eventType, IFlow flow)
		{
			this._date = date;
			this._eventType = eventType;
			this._flow = flow;
			this._details = new ListSet();
		}
Пример #2
0
 public ProcessInstanceImpl(String actorId, ProcessDefinitionImpl processDefinition)
 {
     this._start = DateTime.Now;
     this._initiatorActorId = actorId;
     this._processDefinition = processDefinition;
     this._rootFlow = new FlowImpl(actorId, this);
 }
Пример #3
0
		public LogImpl(String actorId, DateTime date, EventType eventType, IFlow flow)
		{
			this._actorId = actorId;
			this._date = date;
			this._eventType = eventType;
			this._flow = flow;
			this._details = new ListSet();
		}
Пример #4
0
		public ActivityFormImpl(FlowImpl flow, IList fields, IDictionary attributeValues)
		{
			this._flow = flow;
			this._processInstance = flow.ProcessInstance;
			this._processDefinition = _processInstance.ProcessDefinition;
			this._activityState = (IActivityState) flow.Node;
			this._fields = fields;
			this._attributeValues = attributeValues;
			InitTransitionNames(flow.Node);
		}
Пример #5
0
		private void WriteFlow(TextWriter logDetail, IFlow flow)
		{
			WriteFlowStart(logDetail, flow);
			IEnumerator iter = flow.Logs.GetEnumerator();
			//@todo add sort see http://www.koders.com/csharp/fid7483E2E4A14A57A929B3D9338410A60E4E911842.aspx?s=sort
			while (iter.MoveNext())
			{
				ILog eventLog = (ILog) iter.Current;
				WriteFlowEvent(logDetail, eventLog, flow);
			}
			WriteFlowEnd(logDetail, flow);
		}
Пример #6
0
 public FlowImpl(String name, FlowImpl parent, ProcessBlockImpl processBlock)
 {
     this._name = name;
     this._start = DateTime.Now;
     this._processInstance = parent.ProcessInstance;
     this._subProcessInstances = null;
     this._parent = parent;
     this._children = null;
     this._logs = new ListSet();
     this._parentReactivation = true;
     CreateAttributeInstances(processBlock.Attributes);
 }
Пример #7
0
		public JobImpl(Job job, String reference)
		{
			_processDefinition = job.ProcessDefinition;
			_context = job.Context;
			_date = job.Date;
			_userId = job.UserId;
			_pwd = job.Pwd;

			this._reference = reference;
			_actionDelegation = new DelegationImpl();
			_actionDelegation.ProcessDefinition = job.ProcessDefinition;
			_actionDelegation.ClassName = job.TaskClassName;
			_actionDelegation.Configuration = job.Configuration;
		}
Пример #8
0
 public FlowImpl(String actorId, ProcessInstanceImpl processInstance)
 {
     ProcessDefinitionImpl processDefinition = (ProcessDefinitionImpl) processInstance.ProcessDefinition;
     this._name = "root";
     this._actorId = actorId;
     this._start = DateTime.Now;
     this._node = processDefinition.StartState;
     this._processInstance = processInstance;
     this._subProcessInstances = null;
     this._parent = null;
     this._children = null;
     this._logs = new ListSet();
     this._parentReactivation = true;
     CreateAttributeInstances(processDefinition.Attributes);
 }
Пример #9
0
		private void WriterAttributes(IFlow flow, StreamWriter xmlwriter)
		{
			//NHibernate.LazyInitializationException: Failed to lazily initialize a collection - no session
			IEnumerator iter = flow.AttributeInstances.GetEnumerator();
			while (iter.MoveNext())
			{
				IAttributeInstance attributeInstance = (IAttributeInstance)iter.Current;
				xmlwriter.WriteLine("		<attribute type=\"AT_UDA_12_"+attributeInstance.Attribute.Name+"\">"+attributeInstance.GetValue()+"</attribute>");
			}

			// recursively descend to the children
			iter = flow.Children.GetEnumerator();
			while (iter.MoveNext())
			{
				WriterAttributes((IFlow) iter.Current,xmlwriter);
			}
		}
Пример #10
0
		public AttributeInstanceImpl(AttributeImpl attribute, FlowImpl scope)
		{
			this._valueText = attribute.InitialValue;
			this._attribute = attribute;
			this._scope = scope;
		}
Пример #11
0
 /// <summary>
 /// Provides a single flow to execute as the job.
 /// </summary>
 /// <param name="flow"></param>
 /// <returns></returns>
 public FlowJobBuilder Flow(IFlow flow)
 {
     _flow = flow;
     return this;
 }
Пример #12
0
 /// <summary>
 /// Custom constructor using a flow and a name.
 /// </summary>
 /// <param name="flow"></param>
 /// <param name="name"></param>
 public FlowState(IFlow flow, string name)
     : base(name)
 {
     _flow = flow;
 }
Пример #13
0
        public ActionResult ShowHome(String preview, Int32 processDefinitionId, Int32 flowId)
        {
            IDefinitionSessionLocal definitionComponent = null;
            IExecutionSessionLocal  executionComponent  = null;

            try
            {
                definitionComponent = ServiceLocator.Instance.GetService(typeof(IDefinitionSessionLocal)) as IDefinitionSessionLocal;
                executionComponent  = ServiceLocator.Instance.GetService(typeof(IExecutionSessionLocal)) as IExecutionSessionLocal;
                IList taskList           = executionComponent.GetTaskList();
                IList processDefinitions = definitionComponent.GetProcessDefinitions();

                if (preview != null)
                {
                    if (preview.Equals("process"))
                    {
                        if (processDefinitionId == 0)
                        {
                            ArrayList errors = new ArrayList();
                            errors.Add("when parameter 'preview' is equal to 'process', a valid parameter 'processDefinitionId' should be provided as well,");
                            ViewData["errormessages"] = errors;
                            //Context.Flash["errormessages"] = errors;
                        }

                        IProcessDefinition processDefinition = null;

                        // Get the processDefinition
                        processDefinition             = definitionComponent.GetProcessDefinition(processDefinitionId);
                        ViewData["processDefinition"] = processDefinition;
                        //Context.Flash["processDefinition"] = processDefinition;
                    }
                    else if (preview.Equals("activity"))
                    {
                        if (flowId == 0)
                        {
                            ArrayList errors = new ArrayList();
                            errors.Add("when parameter 'preview' is equal to 'activity', a valid parameter 'flowId' should be provided as well,");
                            ViewData["errormessages"] = errors;
                            //Context.Flash["errormessages"] = errors;
                        }
                        //					IFlow flow = executionComponent.GetFlow(flowId, new Relations(new System.String[]{"processInstance.processDefinition"}));
                        IFlow flow = executionComponent.GetFlow(flowId);
                        ViewData["activity"] = flow.Node;
                        //Context.Flash["activity"] = flow.Node;
                        //AddImageCoordinates((IState)flow.Node);
                        ViewData["processDefinition"] = flow.ProcessInstance.ProcessDefinition;
                        //Context.Flash["processDefinition"] = flow.ProcessInstance.ProcessDefinition;
                    }
                }

                ViewData["taskList"]           = taskList;
                ViewData["processDefinitions"] = processDefinitions;
                ViewData["preview"]            = preview;
                //Context.Flash["taskList"] = taskList;
                //Context.Flash["processDefinitions"] = processDefinitions;
                //Context.Flash["preview"] = preview;
            }
            finally
            {
                ServiceLocator.Instance.Release(executionComponent);
                ServiceLocator.Instance.Release(definitionComponent);
            }

            return(View());
        }
Пример #14
0
		private void GetStateAndAttributes(IList state, IList attributeRows, String indentation, IFlow flow)
		{
			// add the flow to the state
			IEnumerator iter = flow.Children.GetEnumerator();
			while (iter.MoveNext())
			{
				state.Add(iter.Current);
			}
			
			// add the flow-name to the attributeRows
			System.Collections.IDictionary row = new System.Collections.Hashtable();
			if (flow.IsRootFlow())
			{
				row["name"] = indentation + "rootflow <b>[</b>" + flow.Name + "<b>]</b>";
			}
			else
			{
				row["name"] = indentation + "subflow <b>[</b>" + flow.Name + "<b>]</b>";
			}
			row["value"] = "";
			attributeRows.Add(row);
			
			// add the flow-local attributes to the attributeRows
			iter = flow.AttributeInstances.GetEnumerator();
			while (iter.MoveNext())
			{
				IAttributeInstance attributeInstance = (IAttributeInstance) iter.Current;
				row = new Hashtable();
				
				log.Debug("adding attribute instance value " + attributeInstance.GetValue());
				row["name"] = indentation + "&nbsp;&nbsp;&nbsp;+-&nbsp;<b>[</b>" + 
							  attributeInstance.Attribute.Name + "<b>]</b>";
				row["value"] = attributeInstance.GetValue();
				attributeRows.Add(row);
			}
			
			// recursively descend to the children
			iter = flow.Children.GetEnumerator();
			while (iter.MoveNext())
			{
				GetStateAndAttributes(state, attributeRows, indentation + "&nbsp;&nbsp;&nbsp;|&nbsp;&nbsp;&nbsp;", (IFlow) iter.Current);
			}
			
			IProcessInstance processInstance = flow.GetSubProcessInstance();
			if (processInstance != null)
			{
				state.Add(processInstance.RootFlow);
				GetStateAndAttributes(state, attributeRows, indentation + "&nbsp;&nbsp;&nbsp;|&nbsp;&nbsp;&nbsp;", processInstance.RootFlow);
			}
		}
Пример #15
0
 /// <summary>
 /// 
 /// </summary>
 /// <param name="flow"></param>
 /// <param name="map"></param>
 private void FindSteps(IFlow flow, IDictionary<string, IStep> map)
 {
     foreach (IState state in flow.GetStates())
     {
         var stepLocator = state as IStepLocator;
         if (stepLocator != null)
         {
             IStepLocator locator = stepLocator;
             foreach (string name in locator.GetStepNames())
             {
                 map.Add(name, locator.GetStep(name));
             }
         }
         else
         {
             var holder = state as IStepHolder;
             if (holder != null)
             {
                 IStep step = holder.Step;
                 string name = step.Name;
                 _stepMap.Add(name, step);
             }
             else
             {
                 var flowHolder = state as IFlowHolder;
                 if (flowHolder != null)
                 {
                     foreach (IFlow subflow in flowHolder.GetFlows())
                     {
                         FindSteps(subflow, map);
                     }
                 }
             }
         }
     }
 }
Пример #16
0
        void Run(IContext context, string host)
        {
            // Validate parameters
            if (context == null)
            {
                throw new ArgumentException("Solace Systems API context Router must be not null.", "context");
            }
            if (string.IsNullOrWhiteSpace(host))
            {
                throw new ArgumentException("Solace Messaging Router host name must be non-empty.", "host");
            }
            if (string.IsNullOrWhiteSpace(VPNName))
            {
                throw new InvalidOperationException("VPN name must be non-empty.");
            }
            if (string.IsNullOrWhiteSpace(UserName))
            {
                throw new InvalidOperationException("Client username must be non-empty.");
            }

            // Create session properties
            SessionProperties sessionProps = new SessionProperties()
            {
                Host             = host,
                VPNName          = VPNName,
                UserName         = UserName,
                Password         = Password,
                CompressionLevel = 0, // 0..9 for more compression, but only usable against appliance
                ReconnectRetries = DefaultReconnectRetries
            };

            // Connect to the Solace messaging router
            Console.WriteLine("Connecting as {0}@{1} on {2}...", UserName, VPNName, host);
            Session = context.CreateSession(sessionProps, null, null);
            ReturnCode returnCode = Session.Connect();

            if (returnCode == ReturnCode.SOLCLIENT_OK)
            {
                Console.WriteLine("Session successfully connected.");

                // Provision the queue
                string queueName = "Q/tutorial";
                Console.WriteLine("Attempting to provision the queue '{0}'...", queueName);

                // Set queue permissions to "consume" and access-type to "exclusive"
                EndpointProperties endpointProps = new EndpointProperties()
                {
                    Permission = EndpointProperties.EndpointPermission.Consume,
                    AccessType = EndpointProperties.EndpointAccessType.Exclusive
                };
                // Create the queue
                Queue = ContextFactory.Instance.CreateQueue(queueName);

                // Provision it, and do not fail if it already exists
                Session.Provision(Queue, endpointProps,
                                  ProvisionFlag.IgnoreErrorIfEndpointAlreadyExists | ProvisionFlag.WaitForConfirm, null);
                Console.WriteLine("Queue '{0}' has been created and provisioned.", queueName);

                // Create and start flow to the newly provisioned queue
                // NOTICE HandleMessageEvent as the message event handler
                // and HandleFlowEvent as the flow event handler
                Flow = Session.CreateFlow(new FlowProperties()
                {
                    AckMode = MessageAckMode.ClientAck
                },
                                          Queue, null, HandleMessageEvent, HandleFlowEvent);
                Flow.Start();
                Console.WriteLine("Waiting for a message in the queue '{0}'...", queueName);

                WaitEventWaitHandle.WaitOne();
            }
            else
            {
                Console.WriteLine("Error connecting, return code: {0}", returnCode);
            }
        }
        public override void SampleCall(string[] args)
        {
            // Parse arguments and initialize Session properties.
            ArgParser cmdLineParser = new ArgParser();

            if (!cmdLineParser.Parse(args))
            {
                // Parse failed.
                PrintUsage(INVALID_ARGUMENTS_ERROR);
                return;
            }
            // Create Session properties from the command line options.
            SessionProperties sessionProps = SampleUtils.NewSessionPropertiesFromConfig(cmdLineParser.Config);

            try
            {
                InitContext(cmdLineParser.LogLevel);

                // Create and connect 'sessionA' with No Local delivery set to false.
                sessionProps.NoLocal = false; // No Local is set to 'false' by default.
                InitializeAndAssertCapabilities(ref context, ref sessionA, "sessionA", sessionProps);

                // Create and connect 'sessionB' with No Local delivery set to true.
                sessionProps.NoLocal = true; // <-- this is how we set NoLocal at the session level
                InitializeAndAssertCapabilities(ref context, ref sessionB, "sessionB", sessionProps);

                // Create a Flow to a temporary Queue within sessionA.
                IQueue         queue     = sessionB.CreateTemporaryQueue();
                FlowProperties flowProps = new FlowProperties();
                flowProps.NoLocal      = true; // <-- this is how we set NoLocal at the flow level
                flowProps.BindBlocking = true;
                flowA = sessionA.CreateFlow(flowProps, queue, null, HandleMessageEvent, SampleUtils.HandleFlowEvent);
                flowA.Start();

                // Add a Topic subscription to sessionB.
                ITopic topic = ContextFactory.Instance.CreateTopic(SampleUtils.SAMPLE_TOPIC);
                sessionB.Subscribe(topic, true /*wait for confirm*/);

                // Publish a Direct message to Topic T from each Session; verify it is not delivered locally.
                IMessage msg = ContextFactory.Instance.CreateMessage();
                msg.BinaryAttachment = Encoding.ASCII.GetBytes(SampleUtils.MSG_ATTACHMENTTEXT);
                msg.Destination      = topic;
                msg.DeliveryMode     = MessageDeliveryMode.Direct;
                // Send from 'sessionA'.
                Console.WriteLine(string.Format("\nSending a direct message to topic '{0}' from sessionA", topic.ToString()));
                sessionA.Send(msg);
                Thread.Sleep(500);
                PrintCounters();
                Console.WriteLine(string.Format("Expecting msgCounterForSessionB to be 1, it's '{0}'", msgCounterForSessionB));
                Console.WriteLine(string.Format("Expecting msgCounterForSessionA to be 0, it's '{0}'", msgCounterForSessionA));
                ResetCounters();
                // Send from 'sessionB'.
                Console.WriteLine(string.Format("\nSending a direct message to topic '{0}' from sessionB", topic.ToString()));
                sessionB.Send(msg);
                Thread.Sleep(500);
                PrintCounters();
                Console.WriteLine(string.Format("Expecting msgCounterForSessionA to be 0, it's '{0}'", msgCounterForSessionA));
                Console.WriteLine(string.Format("Expecting msgCounterForSessionB to be 0, it's '{0}'", msgCounterForSessionB));
                ResetCounters();


                // Publish a message to the Queue on each Session; verify it is not delivered locally.
                msg.Destination  = queue;
                msg.DeliveryMode = MessageDeliveryMode.Persistent;
                // Send from 'sessionA'.
                Console.WriteLine(string.Format("\nSending a persistent message to queue '{0}' from sessionA", queue.ToString()));
                sessionA.Send(msg);
                Thread.Sleep(500);
                PrintCounters();
                Console.WriteLine(string.Format("Expecting msgCounterForFlowA to be 0, it's '{0}'", msgCounterForFlowA));
                ResetCounters();
                // Send from 'sessionB'.
                Console.WriteLine(string.Format("\nSending a persistent message to queue '{0}' from sessionB", queue.ToString()));
                sessionB.Send(msg);
                Thread.Sleep(500);
                PrintCounters();
                Console.WriteLine(string.Format("Expecting msgCounterForFlowA to be 1, it's '{0}'", msgCounterForFlowA));
                ResetCounters();
                Console.WriteLine("\nDone");
            }
            catch (Exception ex)
            {
                PrintException(ex);
            }
            finally
            {
                if (flowA != null)
                {
                    flowA.Dispose();
                }
                if (sessionA != null)
                {
                    sessionA.Dispose();
                }
                if (context != null)
                {
                    context.Dispose();
                }
                // Must cleanup after.
                CleanupContext();
            }
        }
Пример #18
0
 public static IFlow <T> Map <S, T>(this IFlow <S> @this, Func <S, T> func)
 {
     return(new MapFlow <S, T>(@this, func));
 }
Пример #19
0
 public void RunStep(IFlow flow)
 {
     _action();
 }
Пример #20
0
 public static void Subscribe <X>(this IFlow <X> @this)
 {
     @this.Subscribe(new EmptyFlowCallback <X>(), new Subscription());
 }
Пример #21
0
 public MapFlow(IFlow <TSource> upstream, Func <TSource, TTarget> func)
 {
     Upstream = upstream;
     Func     = func;
 }
Пример #22
0
 public static double Length(this IFlow flowObj)
 {
     return((flowObj.Geometry() as ICurve).ILength());
 }
Пример #23
0
 public void SetFlow(IFlow flow)
 {
     this._flow = (FlowImpl) flow;
 }
        private async Task <bool> SubscribeQueueAsyncInternal(Queue queue, BufferBlock <Message> messageQueue = null,
                                                              BufferBlock <FlowStateContext> flowEvtQueue     = null, bool flowStartState = false)
        {
            FlowBindings.FlowBindingElement binding = null;
            if (messageQueue == null)
            {
                // Use default message block
                messageQueue = defaultAppMsgQueue;
            }
            bool newSubscription = flowBindings.AddBinding(queue, messageQueue, flowEvtQueue, out binding);

            if (newSubscription && binding != null)
            {
                try
                {
                    // Configure flow properties
                    var fp = new FlowProperties
                    {
                        AckMode        = solaceOptions.ClientAck ? MessageAckMode.ClientAck : MessageAckMode.AutoAck,
                        BindBlocking   = false, // ensure we bind in non-blocking mode
                        FlowStartState = flowStartState
                    };

                    // Destination
                    IEndpoint solQueue = null;
                    if (queue.IsTemporary)
                    {
                        solQueue = session.CreateTemporaryQueue(queue.Name);
                    }
                    else
                    {
                        solQueue = ContextFactory.Instance.CreateQueue(queue.Name);
                    }

                    // Create the flow
                    TaskCompletionSource <bool> tcs = new TaskCompletionSource <bool>();
                    IFlow flow = session.CreateFlow(
                        fp,
                        solQueue,
                        null,
                        async(sender, msgEv) => { await AcceptMessageEventAsync(msgEv, binding).ConfigureAwait(false); },
                        async(sender, flowEv) =>
                    {
                        logger.LogDebug("FlowEvent: {0}, Info: {1}", flowEv.Event, flowEv.Info);
                        var flowStateCtx = new FlowStateContext()
                        {
                            Info = flowEv.Info, ResponseCode = flowEv.ResponseCode
                        };
                        switch (flowEv.Event)
                        {
                        case FlowEvent.UpNotice:
                            flowStateCtx.State = FlowState.Up;
                            tcs.TrySetResult(true);
                            break;

                        case FlowEvent.BindFailedError:
                            flowStateCtx.State = FlowState.BindFailedError;
                            logger.LogWarning(string.Format("Queue connection failure: {0}", flowEv.Event.ToString()));
                            tcs.TrySetResult(false);
                            break;

                        case FlowEvent.DownError:
                            flowStateCtx.State = FlowState.Down;
                            break;

                        case FlowEvent.FlowActive:
                            flowStateCtx.State = FlowState.FlowActive;
                            break;

                        case FlowEvent.FlowInactive:
                            flowStateCtx.State = FlowState.FlowInactive;
                            break;

                        default:
                            break;
                        }

                        // Notify caller of the flow event
                        await binding.DispatchFlowEventAsync(flowStateCtx).ConfigureAwait(false);
                    });
                    binding.Flow = flow;
                    return(await tcs.Task.ConfigureAwait(false));
                }
                catch (Exception e)
                {
                    binding.Flow = null;
                    flowBindings.RemoveBinding(queue, out binding);
                    throw new MessagingException(e.Message, e);
                }
            }

            if (!newSubscription && binding != null)
            {
                // If existing subscription then ignore and return success
                return(true);
            }
            return(false);
        }
        private void SubscribeAndSendMessage(ISession session)
        {
            // Provision the queue
            string queueName = "Q/tutorial/topicToQueueMapping";

            Console.WriteLine("Attempting to provision the queue '{0}'...", queueName);

            // Create the queue
            using (IQueue queue = ContextFactory.Instance.CreateQueue(queueName))
            {
                // Set queue permissions to "consume" and access-type to "exclusive"
                EndpointProperties endpointProps = new EndpointProperties()
                {
                    Permission = EndpointProperties.EndpointPermission.Consume,
                    AccessType = EndpointProperties.EndpointAccessType.Exclusive,
                };
                // Provision it, and do not fail if it already exists
                session.Provision(queue, endpointProps,
                                  ProvisionFlag.IgnoreErrorIfEndpointAlreadyExists & ProvisionFlag.WaitForConfirm, null);
                Console.WriteLine("Queue '{0}' has been created and provisioned.", queueName);

                // Add subscription to the topic mapped to the queue
                ITopic tutorialTopic = ContextFactory.Instance.CreateTopic("T/mapped/topic/sample");
                session.Subscribe(queue, tutorialTopic, SubscribeFlag.WaitForConfirm, null);

                // Create the message
                using (IMessage message = ContextFactory.Instance.CreateMessage())
                {
                    // Message's destination is the queue topic and the message is persistent
                    message.Destination  = tutorialTopic;
                    message.DeliveryMode = MessageDeliveryMode.Persistent;

                    // Send it to the mapped topic a few times with different content
                    for (int i = 0; i < TotalMessages; i++)
                    {
                        // Create the message content as a binary attachment
                        message.BinaryAttachment = Encoding.ASCII.GetBytes(
                            string.Format("Topic to Queue Mapping Tutorial! Message ID: {0}", i));

                        // Send the message to the queue on the Solace messaging router
                        Console.WriteLine("Sending message ID {0} to topic '{1}' mapped to queue '{2}'...",
                                          i, tutorialTopic.Name, queueName);
                        ReturnCode returnCode = session.Send(message);
                        if (returnCode == ReturnCode.SOLCLIENT_OK)
                        {
                            Console.WriteLine("Done.");
                        }
                        else
                        {
                            Console.WriteLine("Sending failed, return code: {0}", returnCode);
                        }
                    }
                }
                Console.WriteLine("{0} messages sent. Processing replies.", TotalMessages);

                // Create and start flow to the newly provisioned queue
                // NOTICE HandleMessageEvent as the message event handler
                // and HandleFlowEvent as the flow event handler
                Flow = session.CreateFlow(new FlowProperties()
                {
                    AckMode = MessageAckMode.ClientAck
                },
                                          queue, null, HandleMessageEvent, HandleFlowEvent);
                Flow.Start();

                // block the current thread until a confirmation received
                CountdownEvent.Wait();
            }
        }
Пример #26
0
 private void OnEnter(IFlow flow) => Debug.Log(Message.Value);
 public void AddFlow(IFlow flow)
 {
     this.AddStreams(flow.Streams);
     this.AddOperations(flow.Operations);
 }
Пример #28
0
 /// <summary>
 /// Creates a new job builder that will execute a flow.
 /// </summary>
 /// <param name="flow"></param>
 /// <returns></returns>
 public JobFlowBuilder Start(IFlow flow)
 {
     return new FlowJobBuilder(this).Start(flow);
 }
Пример #29
0
		private void WriterNodes(IFlow flow, StreamWriter xmlwriter)
		{
			IEnumerator iter = flow.Logs.GetEnumerator();
			while (iter.MoveNext())
			{
				ILog eventLog = (ILog) iter.Current;
				xmlwriter.WriteLine("id->"+eventLog.Id);
				if (eventLog.EventType == EventType.FORK)
				{
					IEnumerator flowIter = eventLog.GetObjectReferences("Flow").GetEnumerator();
			
					while (flowIter.MoveNext())
					{
						ObjectReferenceImpl objectReference = (ObjectReferenceImpl) flowIter.Current;
						DbSession session = OpenSession();
						objectReference.Resolve(session);
						session.Close();
						IFlow subFlow = (IFlow) objectReference.GetObject();
						xmlwriter.WriteLine("subflow"+subFlow+" ->"+subFlow);
						WriterNodes(subFlow ,xmlwriter);
					}
				}			
				else if (eventLog.EventType == EventType.SUB_PROCESS_INSTANCE_START)
				{
					IObjectReference objectReference = (IObjectReference) eventLog.GetObjectReferences("ProcessInstance").GetEnumerator().Current;
					IProcessInstance subProcessInstance = (IProcessInstance) objectReference.GetObject();
					WriterNodes(subProcessInstance.RootFlow ,xmlwriter);
				}

			}
		}
Пример #30
0
 public override void Initialize(ref IFlow flow)
 {
     Flow = flow;
     Flow.Set(Id, (T)DefaultValue);
 }
Пример #31
0
 public void Visit(IFlow flow)
 {
     Visit((dynamic)flow);
 }
Пример #32
0
 public void RunStep(IFlow flow)
 {
 }
Пример #33
0
 protected override void Calculate(IFlow flow)
 {
     Output.Value = !Input.Value;
 }
Пример #34
0
        private void GetStateAndAttributes(IList state, IList attributeRows, String indentation, IFlow flow)
        {
            // add the flow to the state
            IEnumerator iter = flow.Children.GetEnumerator();

            while (iter.MoveNext())
            {
                state.Add(iter.Current);
            }

            // add the flow-name to the attributeRows
            System.Collections.IDictionary row = new System.Collections.Hashtable();
            if (flow.IsRootFlow())
            {
                row["name"] = indentation + "rootflow <b>[</b>" + flow.Name + "<b>]</b>";
            }
            else
            {
                row["name"] = indentation + "subflow <b>[</b>" + flow.Name + "<b>]</b>";
            }
            row["value"] = "";
            attributeRows.Add(row);

            // add the flow-local attributes to the attributeRows
            iter = flow.AttributeInstances.GetEnumerator();
            while (iter.MoveNext())
            {
                IAttributeInstance attributeInstance = (IAttributeInstance)iter.Current;
                row = new Hashtable();

                log.Debug("adding attribute instance value " + attributeInstance.GetValue());
                row["name"] = indentation + "&nbsp;&nbsp;&nbsp;+-&nbsp;<b>[</b>" +
                              attributeInstance.Attribute.Name + "<b>]</b>";
                row["value"] = attributeInstance.GetValue();
                attributeRows.Add(row);
            }

            // recursively descend to the children
            iter = flow.Children.GetEnumerator();
            while (iter.MoveNext())
            {
                GetStateAndAttributes(state, attributeRows, indentation + "&nbsp;&nbsp;&nbsp;|&nbsp;&nbsp;&nbsp;", (IFlow)iter.Current);
            }

            IProcessInstance processInstance = flow.GetSubProcessInstance();

            if (processInstance != null)
            {
                state.Add(processInstance.RootFlow);
                GetStateAndAttributes(state, attributeRows, indentation + "&nbsp;&nbsp;&nbsp;|&nbsp;&nbsp;&nbsp;", processInstance.RootFlow);
            }
        }
Пример #35
0
		private void AddAllActiveFlows(IFlow flow, IList flows)
		{
			if (flow.Children == null || flow.Children.Count == 0)
			{
				flows.Add(flow);
			} 
			else
			{
				IEnumerator flowEnumer = flow.Children.GetEnumerator();
				while (flowEnumer.MoveNext())
				{
					AddAllActiveFlows((IFlow)flowEnumer.Current,flows);
				}
			}
		}
Пример #36
0
		private void  WriteFlowEnd(TextWriter logDetail, IFlow flow)
		{
			logDetail.Write("</table>" + "\r\n");
			logDetail.Write("</td></tr></table>" + "\r\n");
		}
Пример #37
0
 /// <summary>
 /// Starts a job with this flow, but expect to transition from there to other flows or steps.
 /// </summary>
 /// <param name="flow"></param>
 /// <returns></returns>
 public JobFlowBuilder Start(IFlow flow)
 {
     return new JobFlowBuilder(this, flow);
 }
Пример #38
0
        public NodeField(Instance instance, IObservableValue <string> name, IFlow flowInput, IFlow flowOutput, IOpacity opacity, ILaminarValueStore valueStore, IUserInterfaceManager userInterfaces)
            : base(name, flowInput, flowOutput, opacity)
        {
            _valueStore    = valueStore;
            UserInterfaces = userInterfaces;

            UserInterfaces.Displays = instance.RegisteredDisplays;
            UserInterfaces.Editors  = instance.RegisteredEditors;
            _factory = instance.Factory;

            _valueStore.ChildValueChanged += ValueStore_ChildValueChanged;
            _valueStore.ChangedAtKey      += (o, e) => AnyValueChanged?.Invoke(this, e);
            Name.OnChange += _valueStore.SetValueName;
        }
Пример #39
0
		public Job(IFlow context, String taskClassName)
		{
			if (_processDefinition == null)
			{
				throw new SystemException("couldn't create a Job with a null-value for processDefinition");
			}
			if ((Object) taskClassName == null)
			{
				throw new SystemException("couldn't create a Job with a null-value for taskClassName");
			}

			this._taskClassName = taskClassName;
			this._context = context;
			this._processDefinition = context.ProcessInstance.ProcessDefinition;
		}
        /// <summary>
        /// Main function in the sample.
        /// </summary>
        /// <param name="args"></param>
        public override void SampleCall(string[] args)
        {
            #region Parse Arguments
            ArgParser cmdLineParser = new ArgParser();
            if (!cmdLineParser.Parse(args))
            {
                // Parse failed.
                PrintUsage(INVALID_ARGUMENTS_ERROR);
                return;
            }
            if (!SampleParseArgs(cmdLineParser))
            {
                // Parse failed for sample's arguments.
                PrintUsage(INVALID_ARGUMENTS_ERROR);
                return;
            }
            #endregion

            #region Initialize properties from command line
            // Initialize the properties.
            ContextProperties contextProps = new ContextProperties();
            SessionProperties sessionProps = SampleUtils.NewSessionPropertiesFromConfig(cmdLineParser.Config);
            #endregion

            // Define IContext and ISession.
            IContext context = null;
            ISession session = null;
            try
            {
                InitContext(cmdLineParser.LogLevel);
                Console.WriteLine("About to create the context ...");
                context = ContextFactory.Instance.CreateContext(contextProps, null);
                Console.WriteLine("Context successfully created. ");

                Console.WriteLine("About to create the session ...");
                session = context.CreateSession(sessionProps,
                                                SampleUtils.HandleMessageEvent,
                                                SampleUtils.HandleSessionEvent);
                Console.WriteLine("Session successfully created.");

                Console.WriteLine("About to connect the session ...");
                if (session.Connect() == ReturnCode.SOLCLIENT_OK)
                {
                    Console.WriteLine("Session successfully connected");
                    Console.WriteLine(GetRouterInfo(session));
                }
                if (!session.IsCapable(CapabilityType.SUB_FLOW_GUARANTEED) || !(session.IsCapable(CapabilityType.TEMP_ENDPOINT)))
                {
                    Console.WriteLine(string.Format("Capabilities '{0}' and '{1}' are required to run this sample",
                                                    CapabilityType.SUB_FLOW_GUARANTEED,
                                                    CapabilityType.TEMP_ENDPOINT));
                    return;
                }
                IQueue queue = null;
                if (cmdLineParser.Config.UseDurableEndpoint)
                {
                    Console.WriteLine(string.Format("A non-temporary queue with name '{0}' must be provisioned and accessible on the appliance within the same user's Message VPN)", SampleUtils.SAMPLE_QUEUE));
                    queue = ContextFactory.Instance.CreateQueue(SampleUtils.SAMPLE_QUEUE);
                }
                else
                {
                    Console.WriteLine("Creating a temporary queue");
                    queue = session.CreateTemporaryQueue();
                }
                FlowProperties flowProps = new FlowProperties();
                // The flow is created in a started state, so it is ready to receive messages.
                flowProps.FlowStartState = true;
                // ClientAck, which means that the received messages on the Flow
                // must be explicitly acked, otherwise they will be redelivered to the client
                // when the Flow reconnects.
                // ClientAck was chosen simply to illustrate ClientAck and that clients
                // can use AutoAck instead.
                flowProps.AckMode = MessageAckMode.ClientAck;

                flow = session.CreateFlow(flowProps, queue, null,
                                          // Demonstrates explicit client acknoweldgment of received messages.
                                          HandleMessageAndAck,
                                          SampleUtils.HandleFlowEvent);
                // Now publish a number of messages to the Queue.
                IMessage message = SampleUtils.CreateMessage(cmdLineParser.Config, session);
                message.Destination = queue;
                Console.WriteLine(string.Format("About to send {0} message(s) ...", cmdLineParser.Config.NumberOfMessagesToPublish));

                // Send a number of messages to the Queue.
                for (int i = 0; i < cmdLineParser.Config.NumberOfMessagesToPublish; i++)
                {
                    if (session.Send(message) == ReturnCode.SOLCLIENT_OK)
                    {
                        Console.Write(".");
                    }
                    Thread.Sleep(1000); // Wait for 0.5 seconds
                }
                Console.WriteLine(string.Format("\nDone\n Sleeping for {0} secs before exiting ", Timeout / 1000));
                Thread.Sleep(Timeout);
            }
            catch (Exception ex)
            {
                PrintException(ex);
            }
            finally
            {
                if (flow != null)
                {
                    flow.Dispose();
                }
                if (session != null)
                {
                    session.Dispose();
                }
                if (context != null)
                {
                    context.Dispose();
                }
                // Must cleanup after.
                CleanupContext();
            }
        }
Пример #41
0
 /// <summary>
 /// Starts a job with this flow, but expect to transition from there to other flows or steps.
 /// </summary>
 /// <param name="flow"></param>
 /// <returns></returns>
 public JobFlowBuilder Start(IFlow flow)
 {
     return(new JobFlowBuilder(this, flow));
 }
 public void Visit(IFlow flow)
 {
     this.Visit(flow.StartBlock);
 }
Пример #43
0
 /// <summary>
 /// Provides a single flow to execute as the job.
 /// </summary>
 /// <param name="flow"></param>
 /// <returns></returns>
 public FlowJobBuilder Flow(IFlow flow)
 {
     _flow = flow;
     return(this);
 }
Пример #44
0
 /// <summary>
 ///  Constructor for a FlowStep that sets the flow and of the step explicitly.
 /// </summary>
 /// <param name="flow"></param>
 public FlowStep(IFlow flow) : base(flow.GetName()) { }
Пример #45
0
		private void  WriteFlowStart(TextWriter logDetail, IFlow flow)
		{
			logDetail.Write("<table border=0 cellpadding=0 cellspacing=1 bgcolor=#000000 height=100%><tr><td bgcolor=#ffffff height=100% valign=top>" + "\r\n");
			logDetail.Write("<table border=0 cellpadding=0 cellspacing=0>" + "\r\n");
			logDetail.Write("<tr><th class=tableFlowCell width=100% colspan=2 nowrap> flow [<b>" + flow.Name + "</b>]</th></tr>" + "\r\n");
		}
Пример #46
0
 protected override void Calculate(IFlow flow)
 {
     Output.Value = Left.Value && Right.Value;
 }
Пример #47
0
		private void  WriteFlowEvent(TextWriter logDetail, ILog eventLog, IFlow flow)
		{
			logDetail.Write("  <tr>" + "\r\n");
			logDetail.Write("    <td bgcolor=#ffffff>" + "\r\n");
			logDetail.Write("      <table border=0 cellspacing=0 cellpadding=0 width=100%>" + "\r\n");
			logDetail.Write("        <tr><th class=tableEventLogCell width=100% colspan=2 nowrap>" + eventLog.EventType + "</th></tr>" + "\r\n");
			logDetail.Write("        <tr>" + "\r\n");
			logDetail.Write("          <td>&nbsp;&nbsp;&nbsp;&nbsp;</td>" + "\r\n");
			logDetail.Write("          <td width=100%>" + "\r\n");
			
			this.details = new System.Collections.ArrayList();
			AddDetail("Time", eventLog.Date.ToString());
			
			IActor actor = eventLog.GetActor();
			if (actor != null)
			{
				AddDetail("Actor", actor.Name);
			}
			
			if (eventLog.EventType == EventType.FORK)
			{
				logDetail.Write("            <table border=0 cellpadding=0 cellspacing=5>" + "\r\n");
				logDetail.Write("              <tr>" + "\r\n");
				IEnumerator iter = eventLog.GetObjectReferences("Flow").GetEnumerator();
			
				while (iter.MoveNext())
				{
					IObjectReference objectReference = (IObjectReference) iter.Current;
					IFlow subFlow = (IFlow) objectReference.GetObject();
					subFlow = GetFlow(subFlow.Id);
					
					logDetail.Write("                <td valign=top height=100%>" + "\r\n");
					WriteFlow(logDetail, subFlow);
					logDetail.Write("                </td>" + "\r\n");
				}
				logDetail.Write("              </tr>" + "\r\n");
				logDetail.Write("            </table>" + "\r\n");
			}
			else if (eventLog.EventType == EventType.SUB_PROCESS_INSTANCE_START)
			{
				IObjectReference objectReference = (IObjectReference) eventLog.GetObjectReferences("ProcessInstance").GetEnumerator().Current;
				IProcessInstance subProcessInstance = (IProcessInstance) objectReference.GetObject();
				IFlow subFlow = GetFlow(subProcessInstance.RootFlow.Id);
				WriteFlow(logDetail, subFlow);
			}
			else
			{
				// if it is no fork or subprocess, log the details
				IEnumerator iter = eventLog.Details.GetEnumerator();
				while (iter.MoveNext())
				{
					AddDetail((ILogDetail) iter.Current);
				}
				
				WriteDetails(logDetail);
			}
			
			logDetail.Write("          </td>" + "\r\n");
			logDetail.Write("        </tr>" + "\r\n");
			logDetail.Write("        <tr><td>&nbsp;</td></tr>" + "\r\n");
			logDetail.Write("      </table>" + "\r\n");
			logDetail.Write("    </td>" + "\r\n");
			logDetail.Write("  </tr>" + "\r\n");
		}
Пример #48
0
 /// <summary>
 /// Custom constructor using a parent JobFlowBuilder and a flow.
 /// </summary>
 /// <param name="parent"></param>
 /// <param name="flow"></param>
 public JobFlowBuilder(FlowJobBuilder parent, IFlow flow)
     : base(parent.GetName())
 {
     _parent = parent;
     Start(flow);
 }