Cogility® Manager enables highly complex business processes to be implemented as scalable J2EE applications without requiring a single line of specialized Java code for implementing business logic.

Cogility® Manager circumvents the need for large quantities of specialized application code to implement business logic by directly executing model-defined business logic.

Cogility® Manager automatically handles parallel database requests, is transactional, invokes other web services, publishes JMS messages, transforms information between disparate silos and enforces the business process of the enterprise as defined in Cogility® Modeler.

Cogility® Manager Features and Benefits

Schema Generation and Validation: Cogility® Manager begins working at the start of the deployment cycle. Manager ensures that the Information Models defined in the application model can be converted to consistent structures within a relational database. With every re-deployment, Manager makes sure that the deployed Information Model is compatible with the prior version, already present in the database.

Meta Schema Mapping: Once Cogility® Manager generates the database table structure for the Application business model, it persists the mapping from model nomenclature to physical nomenclature. This action allows the end-user to interact with the system in business terms without having to refer to physical table details.

Behavior Version Tracking: Once Business Processes or Web Services deploy, Cogility® Manager keeps track of the current version number associated with that business logic artifact. These can then be retrieved to verify the version of any active web service or business process.

Automated Transacted Persistence: Cogility® Manager ensures that every logic execution resulting from requests being sent to the application’s entry points has a proper database transaction associated with it. This eliminates the need for the user to specify it every time. When the business logic calls for database activity, Cogility® Manager seamlessly converts the requirements to proper SQL statements that perform the appropriate activity within the automatically provided transaction. However, this does not preclude the modeling layer from requesting different transaction semantics, which exercise full control if required.

Dynamically assembled business logic runs in parallel J2EE threads

Model Driven JMS Message Parsing: Cogility® Manager is key to the execution of model driven Message Driven Beans. When a message arrives, Cogility intelligently decides the type of business logic to fetch and the type of business object to execute. For example, Cogility® Manager quickly differentiates whether a message indicates that a new order should be created for a customer versus an existing order that should be processed for fulfillment.

Model Driven Web Service Parsing: When Cogility® Manager receives a Web Service request, Manager retrieves the Web Service logic from the database or cache and executes it. Thus, every Web Service can use a common Web Service shell for J2EE purposes, and need not be coded separately. Cogility® Manager performs the task of mapping the incoming web service request with its model-based logic.

Automated SOAP Parsing and Generation: Cogility® Manager can automatically read the Simple Object Access Protocol (SOAP) formatted message over HTTP input and then translate the SOAP request to an object form. This can then be used by the data-driven Web Services deployed by Cogility. Cogility Manager also offers tools to parse XML as required. SOAP messages must be generated to respond to Web Service requests or to invoke remote web services. Cogility® Manager does this automatically by using the model metadata that has been pushed into the execution database

Massively Parallel Operation: J2EE operates upon the philosophy of massively parallel Enterprise Java Beans. Since every J2EE required artifact is actually a Model Driven artifact, the model specified behavior is retrieved from the database and cached. Since every business object is responsible for its own business processes as well as their sequencing, the execution environment can handle inputs in parallel by simply dispatching them to the correct objects in separate threads. Cogility® Manager orchestrates this by translating messages into business events and dispatching them to the appropriate business objects.

Hot Swappable Logic: Business logic specified by Cogility® Modeler executes inside Cogility® Manager in a data driven manner. Late binding logic can be hot-swapped on a running application server in a platform independent manner by updating the logic in the business logic repository.

 Combine Database and Messaging Transactions: Cogility® Manager automatically keeps track of all message publish requests, and executes them only if the database transaction for the thread has been committed. This feature ensures non-publication of spurious messages.

Business Process to J2EE Mapping: Cogility® Manager automatically maps defined business processes to J2EE in terms of a sequence of loosely connected Message Driven Beans (MDB). They are executed in the correct sequence by the Cogility® Manager UML State Machine enactment engine in response to business events. By mapping from a flow-chart-like graphical representation to J2EE artifacts utilizing rich business logic, Cogility allows business analysts and application developers to collaborate within a single tool.

Traditional systems keep data and logic separated. The logic is specified by the application code, and the data by rows and columns in the database. Cogility® Manager provides a metadata rich environment that stores both data and behavior in the same execution database.

Once connected to a database, the coexistence of data and behavior enables a thin Cogility client to infer business model details. It is then possible to locate specific business objects and invoke their behavior. This SmartObjects™ technique makes possible a number of Operational Support Tools, such as Cogility® Insight, that would not be feasible in alternate approaches.

Cogility® Manager reduces errors in the implementation by automating many of the hand-coded methods of alternate implementation techniques. It enables a code free approach to building Composite Applications, allowing stake-holders to focus on business logic and rather than the minutiae of its implementation.

Cogility® Manager Consoles

Cogility® Manager JMS Console: Cogility® Manager JMS Console allows an administrator the ability to subscribe to the JMS traffic of the executing model after deployment on the J2EE Application Server and publish a new JMS message to trigger specific business behavior. These features allow an administrator or model developer to verify whether the JMS message traffic in the deployed system is working as expected, as well as the ability to initiate those actions that are triggered by messages.

Cogility® Manager Web Services Console: Cogility® Manager Web Service Console has tools that provide executable access to all the Web Services that are deployed or invoked by the executing system model for testing purposes. It also provides access to any other web service that can be accessed over the Internet to validate it before it is used as part of the executing model. Sets of relevant web services with calling parameters included can be stored and reused as a regression test suite. These features allow an administrator or model developer to verify if a particular web service that is either deployed or invoked by Cogility is working as defined within the model.

Cogility® Manager System Console - ActionPad: Cogility® Manager allows complex executable model Action Semantics commands or scripts to be executed directly against the system. These capabilities can be accessed outside the J2EE Application Server by using the Cogility® ActionPad. These command scripts can invoke J2EE behavior if required and may run model defined logic in conjunction with other commands. Command scripts can be used to define automated model regression tests, to produce reports, to perform database cleanups, to debug model logic with breakpoints or as an aid to developing new model logic in a J2EE platform and database neutral manner. ActionPad will persist the definition of all model Action Semantics scripts and maintain the environment across restarts of the tool. New commands, in conjunction with deployed logic, can be executed, paused and inspected in an environment consisting of a remote J2EE Application Server and a remote execution database.

The metadata rich environment provided by Cogility® Manager enables the ActionPad to conform to the high-level design time view of the system while the application is actually executing within the J2EE Application Server. This maintains a consistent and unvarying view of the system at all times from design to execution, making it easier to understand.

This unique approach simplifies operation and maintenance of the system by removing the complex technical overhead of the technological platform and reducing interaction to familiar business terms.

Cogility® ActionPad: Cogility® Manager system console

Cogility® ActionPad: Pause executing model Action Semantics and observe the state of system attributes