Here are the key things you will do in the lab: 1. Build a business process that uses decision and parallel process steps to control flow and process messages concurrently. 2. Add exception handling using try/catch blocks and enrich exceptions with additional context. 3. Reference an external .NET assembly from within a code process step. 4. Access Neuron ESB APIs like the configuration, client context, and publish messages directly. 5. Debug the business process using breakpoints and inspecting variables at each step. 6. Store and retrieve custom properties and state at the message, instance, and global level. The lab will reinforce how to design complex, dynamic processes that leverage Neuron

1. Building Complex Business Processes

2. Building Complex Business Processes
• Introduce logic within a Business Process that allows for process control loops.
• Show how to incorporate custom DLLs into a Business Process
• Explore debugging techniques for business processes
• Discuss exception management techniques
• Show how to access Neuron ESB specific APIs directly in a Business Process to enable
development of more dynamic and sophisticated solutions
Goals

3. Building Complex Business Processes
• Using logic steps in a business process
• Exception management techniques
• Building / returning ESB messages
• ESB Message Custom Properties and State
• Accessing Neuron ESB APIs and resources
• Using custom DLLs in language editors
• Using the Business Process Debugger
Lesson Plan

4. Building Complex Business Processes
• Simple predictive models commonly employed in situations where true / false rules need to be
enforced
• In a Business process logic steps provide certain benefits:
• Control the flow of the business process
• Dynamic routing inside a business process
• Anticipate errors and catch them before they occur
• Run portions of a process concurrently to speed up performance
Logical Steps

5. Building Complex Business Processes
Decision Process Step
• Uses Boolean values to return true
or false based on a condition
• Can have multiple branches
• Evaluated left to right – only one
branch executes
• This can be used to:
• Anticipate errors
• Control process flow
• Dynamically route messages
• In the example shown, we use a
Decision Step to determine if the
message contains data
• If not, audit the message and
cancel the flow
• Else, use another decision step
to determine which topic to
send the message to, based on
the value of a custom property

6. Building Complex Business Processes
Parallel Process Step
• The parallel step allows for aspects of a
business process to run concurrently.
• Inside of a business process this can be
used to:
• Control the logical flow of the business
process
• Allow for multiple functionalities to run
concurrently reducing processing time

7. Building Complex Business Processes
Parallel Process Step : Branches
• Each Branch gets a copy of the
original message (i.e.
context.Data.Clone(false) )
• Each Branch can modify the
message or replace it. (i.e.
context.Data )
• Each final Branch message is added
to a collection and stored in the
context property, “Messages”
• “Messages” collection can be
accessed in Process Steps following
the Parallel Process Step i.e. using a
C# Process Step

8. Building Complex Business Processes
Parallel Process Step : Messages
The “Messages” collection can be
accessed in Process Steps following
the Parallel Process Step using one of
the Control Flow steps such as the
ForEach Process Step

9. Building Complex Business Processes
Parallel Process Step
Within a Branch
Custom properties can be stored:
context.Properties["myprop"] = "my custom data";
The name of the Branch can be accessed:
context.Properties["CurrentBranch"] as string
After the Parallel Step
Custom properties can be accessed by preceding
the property name with the branch name:
var prop = context.Properties["Branch1.myprop"];

10. Building Complex Business Processes
Split Process Step
Used to process individual messages contained within a larger incoming
message (Batch file)
• Split
• Executes logic for determining the boundaries of individual messages within the Batch
• Each individual message is delivered to the Steps Block
• Options available via right-click context menu
• Code – Exposes Neuron ESB C# Code Editor
• XPATH – XPATH statement (assuming message is XML)
• Steps Block
• Contains the Process Steps used to process each individual message parsed from the Batch
• By default, each message does not have access to the other messages in the batch
• Can be configured to run either synchronously i.e. For Loop, or Asynchronously using the
following properties
• Synchronous – default is True
• Maximum Thread Count – default is 1. Determines number of threads to allocate ONLY if
Synchronous is set to False
• Join
• Executes logic to either dispose of, or aggregate the individual messages previously split and
processed into 1 outgoing message
• Options available via right-click context menu
• Code– Exposes Neuron ESB C# Code Editor
• Null – Individual messages are discarded
• Wrapper – XML element to wrap Individual

11. Building Complex Business Processes
Split Process Step : Split Type : XPath
XPATH – Easiest option when document is simple XML
<Orders>
<Order>
<OrderID>1234</OrderID>
<OrderDate>4/22/09</OrderDate>
<OrderAmount>100.00</OrderAmount>
</Order>
<Order>
<OrderID>1235</OrderID>
<OrderDate>4/22/09</OrderDate>
<OrderAmount>110.00</OrderAmount>
</Order>
<Order>
<OrderID>1236</OrderID>
<OrderDate>4/22/09</OrderDate>
<OrderAmount>120.00</OrderAmount>
</Order>
</Orders>

12. Building Complex Business Processes
Split Process Step : Split Type : Code
When dealing with NON XML or complex
documents where XPATH will not work
• List of Context Objects – This contains the
batch of messages that will be delivered to
the STEPS block
• Each individual message created using Clone
to preserve relationship

13. Building Complex Business Processes
Split Process Step : Steps Block
• Is a container that can contain any number of
Process Steps
• All Process Steps within the container will
execute for each Individual Message
• The Split feeds an individual message, one at
a time, to the container from the collection of
messages
• By default, there is only 1 thread that executes
an instance of the container with its message
(i.e. for loop)
• If Synchronous = False, more than 1 thread
can be allocated to process messages
• Example:
• Synchronous = False
• Maximum Thread Count = 10
• 10 messages, each with their own
instance of the container, will execute
concurrently

14. Building Complex Business Processes
Split Process Step : Join
• Code – When dealing with NON XML or
complex documents where a simple wrapper will
not work
• Loop through collection of processed
individual messages (i.e. splits )
• Null – When there is no need to pass on the
individual messages to other Process Steps
outside the Split Process Step
• Wrapper – Provides the name and
namespace for the XML Root to wrap all the
individual messages previously processed by the
Steps Block

15. Logical Process Steps : Demo
Purpose:
Familiarize users with using logic process steps in a business process.
Objectives:
Acquaint users with the following aspects of logic process steps.
• Using the Decision Step in logical processing
• Using the Parallel process step
• Using the Split Process Step for Batch Splitting

16. Building Complex Business Processes
Exception Management
Generic exception pattern
• Dedicated Business Process to handle
exceptions
• Should Audit to Failed Database
• Optionally enrich with business
specific info
• Optionally rethrow
• Called from Execute Process Step
in Catch block of Exception
Process Step
• See Samples **

17. Building Complex Business Processes
Why enrich an exception?
• To insert business domain information to assist in troubleshooting
• Exception shielding patterns
How to enrich an exception
• Access in Catch Block of Exception Process Step
• Use a C# Process Step
• PipelineException
• Accessed via a context property
• Contains name of process and process step that threw the exception
• Inner Exception is CurrentException
• CurrentException
• Accessed via a context property
• Actual error that is thrown
Enriching Exceptions

18. Building Complex Business Processes
Enriching Exceptions : Example
// Get the original exception that was thrown
PipelineException ex = (PipelineException)context.Properties["PipelineException"];
// business domain specific : get original record count and row number the exception occurred on
string rowNumber = "";
var recordCount = context.Data.GetProperty("CRO","RecordCount","0");
var rowNode = context.Data.ToXmlDocument().SelectSingleNode("/*/_RowNumber");
if(rowNode != null) rowNumber = rowNode.InnerText;
// Create a new exception message with more detail and return as new exception
var msg = String.Format(@"Batch Process aborted processing CRO Excel workbook,
'{0}'rnProcess Name: {0}, rnOriginal Exception Message: {4}", context.Data.GetProperty("CRO","ProcessedFileName",""), ex.InnerException.Message);
// reset the current exception object
context.Properties["CurrentException"] = new System.Exception(msg, ex);

19. Building Complex Business Processes
Always in Custom Process Step
• Allows runtime to forward and set exception property
OnPublish or OnReceive events
• Semantic = Mulitcast
• Audit (failure) and Cancel
• Semantic = Request
• Throw
ESB Message – Return instead of throw
• CreateReplyFromException() & CreateFromException()
• FaultType = Neuron.Esb.FaultType Enum
Throwing Exceptions

20. Exception Management : Demo
Purpose:
Familiarize users with using exception management techniques in a business processes.
Objectives:
Acquaint users with the following aspects of exception management.
• Using the Exception Process Step
• Enriching exception information

21. Building Complex Business Processes
Language Editors
Where can they be used?
• Neuron ESB Business Process Designer
• Neuron ESB Workflow Designer
What are they used for?
• Message mediation
• Custom business logic
• Calling external APIs (assemblies)
• Alternative to writing custom Process
Steps or Workflow Activities
• Extends Business Processes and
Workflow capabilities

22. Building Complex Business Processes
Using Custom .NET Assembles
• Can be called directly from a Code Process Step
• Must use full namespace reference to access
• Can add reference to assembly:
• At Code Step level
• At Business Process level
• Assembly must be manually deployed to Neuron install directory (location of esbservice.exe) or GAC
• To use an Alternative location, modify ProbePath:
• esbservice.exe.config
• neuronexplorer.exe.config
• esbhost.exe.config
Language Editors : Custom DLLs

23. Language Editors : Demo
Purpose:
Show users how to reference and call a function from an external .NET assembly within a Business Process.
Objectives:
Acquaint users with the following aspects of referencing external .NET assemblies
• Using the Code Editor to reference a .NET assembly
• Referencing a .NET assembly at the Business Process level

24. Building Complex Business Processes
Mediating the Neuron ESB Message
Accessing the ESB Message in a
Business Process
• In a Language Code Process Step
• context.Data is a ESBMessage()
• e.g. context.Data = new ESBMessage()
• e.g. context.Data =
context.Data.Clone(false)
• Every Process Step mediates the ESB
Message
Accessing the ESB Message in a
Workflow
• Message, reply and request arguments
is a ESB Message()
• Every Workflow Activity mediates the
ESB Message
Graphic Needed

25. Building Complex Business Processes
Mediating the Neuron ESB Message
Modifying the ESB Message Body
• ESBMessage methods:
• FromString
• FromXml
• Bytes
• Text
• Body
Retrieving the ESB Message Body
• ESBMessage methods
• ToXml, ToXmlDocument,
ToXDocument, Text, Bytes, Body,
GetBody<T>, WriteMessage(stream)
Graphic Needed

26. Building Complex Business Processes
Mediating the Neuron ESB Message
ESB Message Header
• Determines behavior of ESB Message
Common Header Properties
• Topic
• Semantic
• MessageID
• TransactionID
• Action
• Session
• SourceID
• Created
• FaultType
Graphic Needed

27. Building Complex Business Processes
Custom Properties and State : Message Level
• Lives with lifetime of the message
• Has a Prefix and a Name
• Can be read and written to in a
Business Process or Workflow
• ESBMessage.SetProperty()
• ESBMessage.GetProperty()
• Value is a string

28. Building Complex Business Processes
• Example preserving properties so they remain on the Reply message when making a request/reply call:
context.Data.Header.RequestHeadersToPreserve = "DA.Organization,DA.Dept";
• Setting a Property:
context.Data.SetProperty("DA", "Organization", "CPS");
• Setting a group of properties:
var myList = new System.Collections.Generic.List<Neuron.NameValuePair>();
myList.Add(new Neuron.NameValuePair("Organization","CPS"));
myList.Add(new Neuron.NameValuePair("Dept","Finance"));
context.Data.SetProperties("DA",myList);
• Retrieving a value of a property:
var myOrg = context.Data.GetProperty("DA","Organization","");
• Retrieving a group of a properties:
var myDAProps = context.Data.GetProperties("DA");
foreach(var prop in myDAProps)
context.Instance.TraceInformation(prop.Name + ": " + prop.Value);
Custom Properties and State : Message Level : Example

29. Building Complex Business Processes
Properties Collection
• Lives for lifetime of a Business Process “Instance”
• Value can be inserted in one Process step and accessed by any other Process Step
• Think “Module” level variable
• Value is an Object
• Used by some “Flow Control” Process Steps **
• NOT Captured during Auditing
• context.Properties
• Why?
• Can drive custom business logic
• Not visible to any other part of the system or Business Process instances
• Large amount of data that you DON’T want to live with the message
Custom Properties and State : Instance Level

30. Building Complex Business Processes
State Collection
• Lives for lifetime of an endpoint or application hosting the party
• Values are accessible for all instances of the Business Process
• Concurrent Dictionary object (thread safe)
• Think “Global Cache”
• Use a Lock if editing
• NOT Captured during Auditing
• context.State
• Why?
• Can drive custom business logic
• Increase Performance
• Must be managed in process
Custom Properties and State : State Level

31. Custom Properties and State : Demo
Purpose:
Show users when and how the various methods can be used to carry state within or across Business Process and/or
Service boundaries.
Objectives:
Acquaint users with the following aspects of business process scopes
• Using the Code Editor to create custom properties or store state
• How to access properties within a Business Process

32. Building Complex Business Processes
Allows access to the Neuron ESB Configuration
• Why?
• Access any entity and its properties at runtime/design time
• Configuration is loaded in memory at startup
• Retrieve/edit documents in repository
• Retrieve encryption keys
• Example
• Use XML/JSON documents in Repository as template approach for creating new messages
Sample C#
foreach(var key in context.Configuration.Keys)
context.Instance.TraceInformation(key.Key);
Neuron ESB APIs

33. Building Complex Business Processes
Allows access to Neuron ESB Environmental Variables
• Why?
• Access environment specific information
• Drive custom business logic
• Example
• Retrieve certificate name from environment, get actual cert from store
Sample C#
var certName = context.EnvironmentVariables["FinanceProjectCert"];
var cred = context.Configuration.Credentials[certName];
if(cred != null)
{
var findValue = cred.CertFindByValue;
var findType = cred.CertFindType;
var storeLocation = cred.CertStoreLocation;
var store = cred.CertStoreName;
factory.Credentials.ClientCertificate.SetCertificate(storeLocation, store, findType, findValue);
}
Neuron ESB APIs

34. Building Complex Business Processes
Allows access to Neuron ESB Client Context
• What is it?
• Does everything for the Party and communicates with Neuron ESB Server
• Why?
• Can obtain a reference to the Party running Business Process at runtime
• Can obtain a reference to each Topic Context of the Party
• Write a message to the Failed Auditing database
• Publish a message via C#
• Lots of things available...
• Caveat
• Only accessible in Runtime environment!
• Check design-time flag:
context.Runtime.DesignMode
Neuron ESB APIs

35. Building Complex Business Processes
Sample C#
if (context.Runtime.DesignMode)
throw new Exception("This will only work at runtime.");
// Retrieve client context
var clientContext = Neuron.Esb.Internal.PipelineRuntimeHelper.ClientContext;
// #1 way to publish.
clientContext.OwnerSubscriber.SendMessage(context.Data);
// #2 way to publish. Grab the Topic context...and do a Publish.
var topicContext = clientContext.TopicContexts[“RootTopic”];
if (topicContext != null)
topicContext.Publish(context.Data);
else
throw new Exception("The party doesn't have the topic as part of their subscription");
Neuron ESB APIs

36. Building Complex Business Processes
Business Process Debugger
Testing versus Debugging
• Testing
• High-level view if Process works or fails
• Provides error or output
• Debugging
• Can set Breakpoints and view state
at each Process Step
• Supports F5, F11
• Everything you do in Test applies to Debug
• Uses “Debug” toolbar button to launch
• Exposes Quick Watch Window
• View variable, context and ESBMessage state at each Process Step
• Allows the setting of Breakpoints within Language Process Steps

37. Building Complex Business Processes
Business Process Debugger : Quick Watch
• Quick Watch Window
• When Debug button is pressed we load all the
symbols
• This may take a few seconds....
• Will stop at first Breakpoint
• Will display Quick Watch Window

38. Building Complex Business Processes
Business Process Debugger : Breakpoints
• Setting Breakpoints
• On Process Steps
• Right-click menu option
• Within Language Code Process
Steps
• Click on left-hand pane by
statement

39. Business Process Debugger : Demo
Purpose:
Show users how to use the debugger within a Business Process.
Objectives:
Acquaint users with the following aspects of debugging business processes.
• Using the debugger to inspect context variables, messages and process step state

40. Building Complex Business Processes : Lab
Goal
In this lab, you will learn how to create a complex business, which will utilize different features of the Business Process
designer to accomplish intricate tasks and advanced scenarios.
Objectives
Creating a complex Business Process
Testing the Business Process at Design Time
Testing the Business Process at Runtime

41. Introduction to Neuron ESB
Review
• Neuron ESB provides a number of logical process steps to help control the flow of message
processing within a business process
• Decision
• Parallel
• Split / Join
• Exceptions should be handled by the business process, preferably using a separate business
process designed specifically for the task.
• Exceptions can, and should, be enriched before auditing or forwarding the exception.
• The Neuron ESB API provides access to many Neuron specific entities
• Configuration
• Environment Variables
• Client Context
• The business process debugger provides enhanced features, above and beyond testing, to help
ensure that your business process is running properly
• Quick Watch
• Breakpoints