SOARanch

Working on ways to speeden web graphics generation. The objective is to generate a raster representation of nodes and vertices

Wouldn't it be great to dump all your BPEL and ESB or any web services specific to a project into a folder and hit ANT for deploying all of the processes automatically? The main challenge here is to find the dependency of the processes and create the deployment-build file in Runtime.

Working on this one ... will have some news soon...

ANT script for creating Restricted Users on Oracle BPEL and ESB console for Oracle Application Server 10.1.3.3.
The default config creates two users viz. bpelReadOnly2/welcome1 and esbReadOnly2/welcome1 with Restricted Privileges.
Tested on OEL and Windows.

Steps for Creating Restricted Users
1. Set the deploy.properties to your target Application Server Instance.
2. Set the setenv.sh/setenv.bat to your target Application Server Instance.
3. Run ANT command.

Steps for Removing Restricted Users
1. Set the deploy.properties to your target Application Server Instance.
2. Set the setenv.sh/setenv.bat to your target Application Server Instance.
3. Set default task in build.xml to default="uninstall"
4. Run ANT command.

Note that the values for deploy.properties can be obtained from %OracleAS%bpel\utilities\ant-orabpel.properties.
Also make sure that you have cleared the browser cache before testing.

1. Roles are specified in Config/Config.txt.

2. The users to be created are specified in Config/usersAndRoles.xml. Users under usersWithAdmin are granted with Admin privileges for BPEL and ESB while users under
usersWithReadOnly are granted read-only privileges for BPEL and ESB Console.The attribute create in usersAndRoles.xml determines whether a user should be created
or only associated with a role.

3. The BPEL Console permissions can be controlled by changing the JSP page access in webComponents/FilterList.txt. The following are the default restrictions:
3.1. No access to Admininster BPEL domain
3.2. No access to Deploy New BPEL Processes
3.3. No access to initiate BPEL processes
3.4. No access to Clear WSDL Cache
3.5. No access to perform manual recovery
3.6. No access to refresh Alarm Table
3.7. No access to View Process Log
3.8. No access to Bulk Update
3.9. No access to Purge Instances
3.10. No access to Purge Sensor Data

The permissions available for a restricted BPEL user are:
3.11. Access Instances and Search Specific Instance IDs, or States
3.12. Access to Activities for retrying faulted instances.
3.13. Access to view BPEL Processes listing
3.14. Access to view the Dashboard.

4. The ESB Console restrictions are:
4.1. No access to routing rules
4.2. No access to create or delete System or Service Groups
4.3. No access to delete System, Service Groups or Services
4.4. No access to move services
4.5. No access to Create, Import,Export or Update DVMs.

The permissions available for a restricted ESB user are:
4.6. Access to Diagram Tab
4.7. Access to Definition Tab
4.8. Access to Properties Tab
4.9. Access to Trackable Fields

Deployment Logic:
Creating ANT scripts for read only user for BPEL and ESB consoles.
The script allows the following configurations:
1. User can define the admin and viewer roles.
2. A custom error.jsp page that the servlet filter will forward to when the filter is satisfied.

The code is an extension to Chintan Shah's code.

The logic for the same is as follows:
1. Script loads Config.txt and creates admins and viewers roles on Oracle App Server. Note that these roles have the "Grant RMI Login Permission" privilege.
First, the user is created.
Then, roles are associated with these users and created.

2. Then the script loads UsersAndRoles.xml and creates/associates usersWithAdmin users with admins role and usersWithReadOnly users with viewers role.
Creation/Association is controlled by the create="true|false" attribute.
3. The script then replaces viewers and admins tokens in Config/web.xml and Config/orion-web.xml

4. The script then copies required classes to
%OracleAS%\j2ee\OC4J_SOA\applications\orabpel\console\WEB-INF
And Config.txt, FilterList.txt to
%OracleAS%\j2ee\OC4J_SOA\applications\orabpel\console\WEB-INF\classes
5. Then the script copies webComponents/error.jsp to
%OracleAS%\j2ee\OC4J_SOA\applications\orabpel\console
And Config/web.xml to
%OracleAS%\j2ee\OC4J_SOA\applications\orabpel\console\WEB-INF
And Config/orion-web.xml to
%OracleAS%\j2ee\OC4J_SOA\application-deployments\orabpel\console

This completes the BPEL ReadOnly Configuration.
For esb read only, the script performs the following tasks:
1. Copy and overwrite webComponents/controller.ServiceNavigator.js to
%soasuite%/j2ee/oc4j_soa/applications/esb-dt/esb_console/esb/commands/
2. Copy and overwrite webComponents/controller.ESBController.js to
%soasuite%/j2ee/oc4j_soa/applications/esb-dt/esb_console/esb/commands/

Finally the ANT script restarts the App Server for the imported classes to be loaded.
At each stage where ever a change in an existing file is made, a backup based on timestamp is created.

Resources:
1. http://chintanblog.blogspot.com/2007/12/i-saw-numerous-people-asking-about-bpel_290.html
2. http://download-west.oracle.com/docs/cd/B14099_19/core.1012/b13995/cmdline.htm

The zip file for the script is located here:
ReadOnlyPatch

A multiple document author editing will enable a single document to be edited in parallel by multiple authors in different sections at the same time. Internally, each such section would be a node in a tree. For cases where the same section is being edited by more than one author in parallel, the individual chunks would be merged and noted.

Application Areas, blogs with multiple authors, online scratch pad, etc.

One of the ways a cloud based memory can be achieved is via a Distributed BTree. So then why not a Distributed Map? A Distributed Map would be an optimal solution that is guaranteed to produce constant time look ups. The problem, however, is the mapping Hash Function. It is not possible to find an optimum hashing function that could map correctly for large number of memory nodes. What is really required is a dynamic function that mutates with the nodes addition or removal in order to keep the lookup time constant. This is possible, but difficult.

One of the most important aspect when it comes to creating such a Distributed BTree is the connection to individual memory nodes. Replication complicates the arrangement. For HA, it is important to be able to replicate efficiently across multiple nodes. A point to point connection of this kind will lead to NACK/ACK implosion at some point of time. So an efficient Distributed BTree should be based on some kind of a Tree Based Reliable Multicast Protocol. We can also choose to decrease the level of replication and network traffic by using neighborhood node based correction algorithms. This means that if the node pointed to by an index does not have the data,we can use a corrective algorithm to get the data from the linked list of its immediate descendants. For this it is important that the descendant nodes are all grouped on the basis of the number of hops.

Another problem is that individual nodes may not be connected via high performance network devices. The design should be able to accommodate the slowest link as well. To make sure that the cloud's data retrieval is not limited to that of the slowest link, parallel data retrievals can be initiated on a configurable number of separate threads on different nodes and the quickest data should be accepted.

Experimenting with ways to track and represent process dependencies in a SOA Integration. If you know any of the processes involved as part of an integration, just type the name and you can get the entire dependency in a graphical mode that has been scaled and designed to handle large number of processes.

You can pan,scale,spatially distort, do anything that is convenient for analyzing dependent processes, fan-outs and fan-ins,cyclic runs, message interaction patterns, without knowing anything about Oracle SOA Suite or having to delve into JDeveloper based BPEL or ESB code.
You can also view parts or whole of the involved processes.

Moreover, the dependencies are represented as GraphML. This means that any third party application that can read and parse XML (like Flex) can hook their front ends to represent the graphical view in any way that they want without knowing a single thing about Oracle SOA Intricacies.

A small video that shows how the dependency trackers crawls through all the processes in an Oracle AIA demo based on Foundation Pack 2.2.

Current Enhancements being done:

1) Automated Testing: The information present in the GraphML will be used to gather more information like the messages exchanged between the processes (cardinality,type,etc).The messages will be tested against preconfigured values or ranges in an incremental manner. The GraphML representation will also be used to construct necessary stubs when individual processes require to be tested.

2) Connectivity with WebLogic: Currently sCrawler supports only Oracle Containers for J2EE. Adding functionality for Weblogic and OSB.

3) Automated Deployment: sCrawlers dependency tracking is being extended to incorporate the ability to find dependency of SOA Processes source code. The idea is to deploy processes starting from the edge vertices with the least edges and move into the vertices with maximum edges. Also, sub-graphs may be found which can be independently deployed. This will help in making certain deployments in parallel.

4) JDeveloper Extension: Working on JDeveloper extension plugin. This will help developers to have an end-to-end view while they work on an existing SOA Ecosystem.

5) ANTlibs for sCrawler: For cases where users intend to use a third party graph renderer a separate ANT library will be made available. This library will generate the GraphML documents which will be ready-to-import and use.

Detailed White Paper on sCrawler

A basic need for any scaling application. Data sharing across multiple JVMs is one way an application can be scaled. Imagine an application that is loaded once, and can be run across multiple JVMs which might be local or remote.
This can be achieved by the Master-Slave pattern bound by a common shared space.
Problem1: There must be some way to share the data amongst these processes in this space without using Queues or RMI.
Problem 2: Dividing the tasks into chunks to be taken up in the multiple JVMs and collating the result into a consistent single output which can be efficiently transported to intended recipients that may be single or multiple.
Problem 3: Allowing any arbitrary JVM to leave or become part of the shared space at any point of time without corrupting computational results.

There are tons of ongoing research in this regards and one that looks most promising is The Java(TM) Multi-Tasking Virtual Machine.

However, I believe there can be a way to create such a system without reverting to a new JVM or creating extensions thereof.

1. Apache Hadoop is a framework for supporting High Volumes of data in a distributed environment. The framework is impressive but the only problem I see is the use of SSH for communication across nodes. This might be required to prevent packet sniffing and IP Spoofing (a big concern in distributed systems). The additional problem I see is that Hadoop uses a point to point connection. It can be improved by using Reliable Multicast protocols.

2. Terracotta is a very simple yet powerful Java based clustering technology that uses loadtime and runtime byte code injection methods to create clustered JVMS that may be local or remote. The Distributed Shared Memory looks impressive and can be integrated with existing POJOs with little or no code changes! It is an API less alternative. It does not involve RMI and only the object state deltas are communicated to reduce traffic. There are no benchmarks though and it would be interesting to see how well it scales.

3. JavaParty is a neat Extension that enables parallel programming over a set of distributed memory machines without the overhead of RMI,Socket based communication and message passing. Problem is...it uses Pre-Compilers. Scary!!!

Search on ....