The following components which are involved are:

-       Database Instance

-       TNS Listener

-       Nodemanager

-       AdminServer

-       SOA Suite Managed server including soa-infra application

The following scripts are used:

- dbora : init service file to stop start the database and listenere during startup

- soa_rc: init service file to start  WebLogic and the SOA Suite during startup

The image shows you the flow of the various scripts that are called by soa_rc

For the database, create  as root a file dbora with the following contents ( see attachment )

Use for ORA_HOME the database ORACLE_HOME (in the script, modify it to your own)

Make the file executable for others and place it in /etc/init.d

chmod +x dbora

Then add it to the Linux service level

chkconfig --add dbora

Linux has 7 different run levels (or operating modes):

• rc0.d – System Halted
• rc1.d – Single User Mode
• rc2.d – Single User Mode with Networking
• rc3.d – Multi-User Mode – boot up in text mode
• rc4.d – Not yet Defined
• rc5.d – Multi-User Mode – boot up in X Windows
• rc6.d – Shutdown & Reboot

You can download the scripts here. Do not forget to modify for you own environment like passwords, WLS Admin Port, etc

Also beware of setting some variables in your O/S profile like MW_HOME, WL_HOME etc…

The dbora script was obtained from Tim Hall, as Marco already mentioned

So I decided to bundle some tips for JAVA programmers how they should configure their EJB, MDB and Servlet applications when they will be deployed on a WebLogic cluster.

This is an example of a typical EJB application architecture in WebLogic Server:

Some hints and tips:

• Use stateless session beans, when you don’t have heavy transactional load
• Make use of home-is-clusterable in weblogic-ejb-jar.xml  and set in on “true”. The EJB can be deployed to multiple managed servers in a cluster. Calls to the home stub are load-balanced between the servers on which its deployed, and if a server hosting the bean is unreachable, the call automatically fails over.
• On bean level, set stateless-bean-methods-are-idempotent in weblogic-ejb-jar.xml on “true”.
• Set stateless-bean-is-clusterable in weblogic-ejb-jar.xml on “true” to deploy EJB’s in a WLS cluster
• Use the stateless-bean-load-algorithm in weblogic-ejb-jar.xml for load balancing between EJB replica’s.
• With in EJB MDB listeners set  setting start-mdbs-with-application to false in weblogic-ejb-jar.xml or weblogic-application.xml with clustered EJB’s. This avoids  hanging of current  messages and processing of the MDB  listeners. Listeners will wait with processing messaging after other services are fully started in WebLogic ( JDBC, JCA, JMS)
• Configure in-memory replication of stateful session beans
• Use batching with Message-Driven Beans.You can enable MDB transaction batching by defining the max-messages-in-transaction element in weblogic-ejb-jar.xml deployment descriptor. Beware , database deadlocks can occur in an application where an MDB makes multiple calls to a database so not all MDB’s are suitable
• Use Multitier Clustered Architecture ( WebTier and Objectier separated) to utilize method calls of clustered EJB’s.
  Single combined-tier clusters provide no opportunity for load balancing method calls to clustered EJBs. Because they  are deployed on all WebLogic Server instances in the cluster, each object instance is available locally to each server. WebLogic Server optimizes method calls to clustered EJBs by always selecting the local object instance, rather than distributing it to remote objects which causes more network overhead.
  This  is, in most cases, more efficient than load balancing each method request to a different server. But if the processing load to individual servers becomes unbalanced, it may eventually become more efficient to submit method calls to remote objects than process methods locally.
  To utilize load balancing for method calls to clustered EJBs, it’s better to split the presentation and object tiers of the application in separate physical clusters.

Failover EJB’s in a cluster

As stateless session EJBs do not maintain any server-side state, the EJBObject stub returned by the EJB home object can route a method call to any server hosting the object. Failover occurs only on idempotent methods.

Stateless session EJBs can have both a cluster-aware home stub and a replica-aware EJBObject stub. By default, WebLogic Server provides failover services for EJB method calls, but only if a failure occurs between method calls. For example, failover is automatically supported if there is a failure after a method completes, or if the method fails to connect to a server. When failures occur while an EJB method is in progress, WebLogic Server does not automatically failover from one server to another.

This ensures that database updates within an EJB method are not “duplicated” in a failover scenario. If a client calls a method which increments a value in a datastore and WebLogic Server fails over to another server before the method completes, the datastore would be updated twice for the client’s single method call. So, set the stateless-bean-methods-are-idempotent to “true” in weblogic-ejb-jar.xml, WebLogic  assumes that the method is idempotent and will provide failover services for the EJB method, even if a failure occurs during a method call.

Stateful session EJBs

Stateful session EJBs should be set to home-is-clusterable to “true.” This provides failover and load balancing for stateful EJB lookups. Stateful session EJBs can’t utilize replica-aware EJBObject stubs, and WebLogic Server does not provide failover services for method calls to stateful session EJBs.

Entity EJBs

WebLogic supports load balancing and failover only at the home level, and not at the method call level (the EJBObject level). Also Enitity EJBs should be set with the home-is-clusterable to “true.”

First I created a properties file, let’s call it DsCf.properties. Everything between <> should be replaced with your own values:

# Propertie file for creating datasource and EIS DB Adapter
# Created by Michel Schildmeijer
# Domain settings
domainname="<your WLS DOMAIN>"
adminurl=<WLS HOST:Admin Port>
adminusername=weblogic
adminpassword=<passwd weblogic>
#datasource settings
datasourcename=<Name DataSource>
datasourcedatabasename=<database>
datasourcetarget=<targeted manaegd server>
datasourcefilename= datasourcename + '.xml'
datasourcejndiname= 'jdbc/' + datasourcename
datasourcedriverclass=oracle.jdbc.OracleDriver
datasourceurl=jdbc:oracle:thin:@<db host>:1521:<db sid>
datasourceusername=<db user>
datasourcepassword=<db user password
datasourcetestquery=SQL SELECT * FROM DUAL
#EIS Connection Factory settings
connfactname=eis/DB/<Connection factory Name>

Second, I created a WLST script to execute these properties and added the DataSource and ConnectionFactory. See the script below.

When running on a UNIX or linux system, navigate to the WLS DOMAIN DIR /bin( Specified during domaincreation) like /app/oracle/middleware/user_projects/domains/<Your domain>/bin and run

./setDomainEnv.sh

After this you are able to deploy the DataSource en ConnectionFactory:

java weblogic.WLST loadProperties DsCf.properties

After finished you can check in the WebLogic Admin Console to see:

• If datasource is created
• If in your outbound connections of the database adapter the EIS connection factory with binding to the DataSource has been created.

Script DsCf.py

 

<code></code><code>import os
</code><code>import time
</code><code>domainName = domainname
</code><code>adminURL= adminurl
</code><code>adminUserName= adminusername
</code><code>adminPassword= adminpassword
</code><code>dsName= datasourcename
</code><code>dsFileName= datasourcefilename
</code><code>dsDatabaseName=datasourcedatabasename
</code><code>datasourceTarget=datasourcetarget
</code><code>dsJNDIName=datasourcejndiname
</code><code>dsDriverName=datasourcedriverclass
</code><code>dsURL=datasourceurl
</code><code>dsUserName=datasourceusername
</code><code>dsPassword=datasourcepassword
</code><code>dsTestQuery=datasourcetestquery
</code><code>connect(adminUserName, adminPassword, adminURL)
</code><code>TargetServerName='soa_server1'
</code><code>edit()
</code><code>startEdit()
</code><code>cd('/')
</code><code>cmo.createJDBCSystemResource(dsName)
</code><code>cd('/JDBCSystemResources/' + dsName + '/JDBCResource/' + dsName)
</code><code>cmo.setName(dsName)
</code><code>cd('/JDBCSystemResources/' + dsName + '/JDBCResource/' + dsName + '/JDBCDataSourceParams/' + dsName )
</code><code>set('JNDINames',jarray.array([String('jdbc/' + dsName )], String))
</code><code>cd('/JDBCSystemResources/' + dsName + '/JDBCResource/' + dsName + '/JDBCDriverParams/' + dsName )
</code><code>cmo.setUrl(dsURL)
</code><code>cmo.setDriverName( dsDriverName )
</code><code>cmo.setPassword(dsPassword)
</code><code>cd('/JDBCSystemResources/' + dsName + '/JDBCResource/' + dsName + '/JDBCConnectionPoolParams/' + dsName )
</code><code>cmo.setTestTableName(dsTestQuery)
</code><code>cd('/JDBCSystemResources/' + dsName + '/JDBCResource/' + dsName + '/JDBCDriverParams/' + dsName + '/Properties/' + dsName )
</code><code>cmo.createProperty('user')
</code><code>cd('/JDBCSystemResources/' + dsName + '/JDBCResource/' + dsName + '/JDBCDriverParams/' + dsName + '/Properties/' + dsName + '/Properties/user')
</code><code>cmo.setValue(dsUserName)
</code><code>cd('/JDBCSystemResources/' + dsName + '/JDBCResource/' + dsName + '/JDBCDriverParams/' + dsName + '/Properties/' + dsName )
</code><code>cmo.createProperty('databaseName')
</code><code>cd('/JDBCSystemResources/' + dsName + '/JDBCResource/' + dsName + '/JDBCDriverParams/' + dsName + '/Properties/' + dsName + '/Properties/databaseName')
</code><code>cmo.setValue(dsDatabaseName)
</code><code>cd('/JDBCSystemResources/' + dsName + '/JDBCResource/' + dsName + '/JDBCDataSourceParams/' + dsName )
</code><code>cmo.setGlobalTransactionsProtocol('OnePhaseCommit')
</code><code>cd('/SystemResources/' + dsName )
</code><code>set('Targets',jarray.array([ObjectName('com.bea:Name=' + datasourceTarget + ',Type=Server')], ObjectName))
</code><code>save()
</code><code>activate()
</code><code>print 'Data source ' + dsName + ' configured'</code>
<code></code><code>
</code><code>#Connect
</code><code>#appPath='/app/oracle/middleware/soa11g/soa/connectors/DbAdapter.rar'
</code><code>#planPath='/app/oracle/middleware/soa11g/soa/connectors/DbAdapterPlanGenerated.xml'</code>
<code></code><code></code>oracleHome = os.environ.get(“ORACLE_HOME”)
<code></code><code>appPath= oracleHome + 'soa/connectors/DbAdapter.rar'
planPath=oracleHome + 'soa/connectors/DbAdapterPlanGenerated.xml'</code>
<code></code><code></code>
<code>CFName=connfactname
</code><code>dsName=datasourcename
</code><code>appName='DbAdapter'
</code><code>moduleOverrideName=appName+'.rar'
</code><code>moduleDescriptorName='META-INF/weblogic-ra.xml'
</code><code>def makeDeploymentPlanVariable(wlstPlan, name, value, xpath, origin='planbased'):
</code><code>while wlstPlan.getVariableAssignment(name, moduleOverrideName, moduleDescriptorName):
</code><code>wlstPlan.destroyVariableAssignment(name, moduleOverrideName, moduleDescriptorName)
</code><code>while wlstPlan.getVariable(name):
</code><code>wlstPlan.destroyVariable(name)
</code><code>variableAssignment = wlstPlan.createVariableAssignment( name, moduleOverrideName, moduleDescriptorName )
</code><code>variableAssignment.setXpath( xpath )
</code><code>variableAssignment.setOrigin( origin )
</code><code>wlstPlan.createVariable( name, value )
</code><code>             def main():
</code><code>                     connect(adminUserName, adminPassword, adminURL)
</code><code>                     edit()
</code><code>                           try:
</code><code>                           startEdit()
</code><code>                           planPath = get('/AppDeployments/DbAdapter/PlanPath')
</code><code>                           print '__ Using plan ' + planPath
</code><code>                           myPlan=loadApplication(appPath, planPath)
</code><code>                           print '___ BEGIN change plan'
</code><code>                           makeDeploymentPlanVariable(myPlan, 'ConnectionInstance_' '+ CFName' +'_JNDIName_abc123XXX','+ CFName', '/weblogic-connector/outbound-resource-adapter/connection-definition-group/[connection-factory-interface="javax.resource.cci.ConnectionFactory"]/connection-instance/[jndi-name="'+ CFName + '"]/jndi-name')
</code><code>                           makeDeploymentPlanVariable(myPlan, 'ConfigProperty_xADataSourceName_'+ dsName +'_abc123XXX',dsName, '/weblogic-connector/outbound-resource-adapter/connection-definition-group/[connection-factory-interface="javax.resource.cci.ConnectionFactory"]/connection-instance/[jndi-name="'+ CFName + '"]/connection-properties/properties/property/[name="xADataSourceName"]/value')
</code><code>                           print '___ DONE change plan'
</code><code>                           myPlan.save();
</code><code>                           save();
</code><code>                           activate(block='true');
</code><code>                           cd('/AppDeployments/DbAdapter/Targets');
</code><code>
</code><code>                           redeploy(appName, planPath,targets=cmo.getTargets());
</code><code>                           print 'EIS Connection factory ' + CFName + 'using' + dsName + ' configured';
</code><code>                    except:
</code><code>                           stopEdit('y')
</code><code>main()</code>

<code>
</code>

I was trying some new JAVA EE 6 features in WebLogic 12c, so here is a is a way to create a Web Application with JPA under WebLogic 12c

Some of the JAVA EE 6 specifications we’re already supported in WebLogic 11g. JPA 2.0 was one of them. Though version 1.0 was the default. 2.0 also worked.Unless an explicit <provider>…</provider> wass specified in the persistence.xml file of a deployed application, WebLogic 11g used OpenJPA/Kodo by default.

The default JPA provider setting is exposed via a new MBean: JPAMBean on the DomainMBean, and persists the configuration into the config.xml file.

Furthermore, you needed to install the patch QWG8 – Enable JPA 2.0 support on WebLogic Server.

To make it work on 11g, you had to use Oracle TopLink as the persistency provider like the image shows you in the WebLogic Admin Console

Now for 12c this is not needed anymore, TopLink will be the default JPA Provider

We will create our own JAVA EE 6 Web Application with the NetBeans 7.1 IDE.

Choose File > New Project

Select Web Application from the Java Web category. Click Next.

Type WLS12cJPA for the project name and specify the project location.

Deselect the Use Dedicated Folder option, if selected. Click Next.

Select Oracle WebLogic Server from the Server dropdown list.

Select Java EE 6 as the Java EE Version. Click Next.

Use the registered JSF 2.1 library and Select JSF 2.1 from the  dropdown list. Click Finish.

NetBeans creates the web application project and opens index.xhtml in the editor. The faces/index.xhtml acts as the default index page.In WebLogic 12c your weblogic.xml shows no reference anymore to JSF

In 11g there was a reference in your weblogic.xml:

<strong>&lt;library-ref&gt;
      &lt;library-name&gt;jsf&lt;/library-name&gt;
      &lt;specification-version&gt;2.0&lt;/specification-version&gt;
      &lt;implementation-version&gt;1.0.0.0_2-0-2&lt;/implementation-version&gt;
      &lt;exact-match&gt;true&lt;/exact-match&gt;
  &lt;/library-ref&gt;</strong>

For now, disable the fastswap feature by setting it to false in the weblogic.xml.

Connect to a database

We will now create the database connection by using the embedded derby database.

Click on the services tab in the left pane, and expand the derby APP tables

Create the persistence unit

To have  persistence in the application you only need to create a persistence unit, specify which data source and entity manager to use, and then let the container do the work of managing entities and persistence. You create a persistence unit by defining it in persistence.xml.

Right-click the project node in the Projects window and choose Properties, and specify in the Sources category of the Properties window,  JDK 6 as the Source/Binary Format.

-  Choose New File and select Persistence Unit from the Persistence category. Click Next.

-  Use the suggested unit name and create a new datasource from the derby connection, jdbc/jpasample.Edit the persistence.xml to use TopLink by specifying  oracle.toplink.essentials.PersistenceProvider as the persistence provider . The IDE will add the Oracle TopLink Essentials – 2.0.1 libraries to the classpath. In current and future versions of Oracle TopLink, Oracle TopLink Essentials is replaced by EclipseLink. Where possible, you should choose to use Oracle TopLink/EclipseLink instead of Oracle TopLink Essentials.

After clicking Finish the persistence unit will be created.

Creating  Entity Classes

You will now use the Entity Classes from Database wizard to create the entity classes based on the  database.

1. Choose New File
2. Select Entity Classes from Database from the Persistence category. Click Next.
3. In the Entity Classes from Database wizard, select jdbc/jpasample from the Data Source drop-down list and supply the password, if necessary.
4. 
5. Select the Customer table from the Available Tables and click Add. Click Next.The customertable and  related tables will be placed under Selected Tables.
6. Type ejb as the package for the generated classes. Click Finish.

After Finish, NetBeans creates entity classes for each of the selected tables.

You can expand the ejb source package node to view the generated entity classes.

Generating JSF Pages

In this exercise you will use a wizard to generate JSF pages based on the existing entity classes.

1. Right-click the project node and choose New > Other.
2. Select from Persistence JSF Pages from Entity Classes in the JavaServer Faces category . Click Next.
3. Click Add All to create JSF pages for all the available entities. Click Next.
4. Type web in the JSF fields. Click Finish.

When you click Finish, the IDE generates JSF 2.0 pages and controller and converter classes for the JSF pages.

Running the Project

In this exercise you will build and deploy the web application to the WebLogic Server. You will use the Run command in the IDE to build, deploy and launch the application.

Right-click the project node and choose Run.

When you click Run, building  and deploys the WAR archive to  WebLogic r and creates and registers the new JDBC datasource. The welcome page of the application (http://<weblogicHost>:7001/WLS12cJPA/) opens in your browser.

In WebLogic the application and data source are deployed

More interesting features are for example to use JPA with Coherence as L2Cache, maybe in another post.

Many new features come out of the fact that Oracle has made its key application server ready for the cloud, that is, ready for to run on enigineered systems, in fact its own Exalogic machine, Oracle’s solution for implementing the cloud.

So let’s take a look what this new release brings us, in this blogpost. There are several new features available in the 12c

New or enhanced WebLogic 12c features

• JAVA EE 6 support all kinds of JEE6 specifications are implemented like :
  • JSF 2.0,Java Servlets 3.0 JPA 2.0 and EJB 3.1.
  • Managed Beans 1.0
• WebLogic 12c also supports supports Java SE 7 (and Java SE 6).
  • Java language optimizations and Internationalization
  • Client and server support
  • SSL/TLS 1.2 in JSSE to support JAVA Socket Transport security
  • Converged Java VM:JRockit and HotSpot are  incorporated with the best features from both.The JVM convergence will be a multi-year process, which was confirmed during my presence at Oracle’s Publisher Seminar 2011 during OOW

I won’t discuss the full list in this blog because there’s more about WebLogic than only (although very important of course!) the JAVA EE 6 specifications.

• Support for IDE’s. WebLogic already supported JDeveloper 11.1.1.5, but will come out with the 11.1.1.6 later on. Also suported are Eclipse and NetBeans 7.1 IDE. As said, the JDeveloper 11.1.1.6 and IntelliJIdea IDE will be supported in a later timeframe.
• New enhanced WebLogic Maven Plug-in See the various new options below in this scheme

As you can see, you can even build a simple domain or control it out of Maven!

• WebLogic 12c provide upgrades from
  • iAS with automated tooling
  • WebLogic 11g
  • GlassFish redeployment – With a built in GlassFish descriptor recognition for Re-Deployment to WebLogic Server
  • JBoss and webSphere with migration services
• WebLogic 12c has Active GridLink –> optimalisation for RAC –Uses Fast Connection Failover for faster RAC failure detection.
• Enhanced High Availability and Disaster Recovery
• Higher Performance accomplished with different kinds of techniques like:
  • Parallel muxers with Java NIO APIs for low-level I/O based operations
  • An optimized work scheduler providing improvements to the Increment Advisor used to manage the size of WebLogic Server’s Self-Tuning Thread Pool
  • “Lazy” de-serialization of session data on the replica server until required.
  • Multiple replication channels for synchronous in-memory session replication between servers in a WebLogic cluster

• Tight integration with the Enterprise Manager 12 Cloud Control and the use of the Middleware.

• Tighter integration with the latest Coherence like:
  • ActiveCache integration for WebLogic Server , being used by JPA entities and TopLink. Allows JPA Entity caching and TopLink Grid enables you to direct queries to ActiveCache.
  • Coherence cluster MBeans within WLS
  • Node Manager integration for starting/stopping cache servers . So you don’t have to use the start-stop scripts anymore.
  • Coherence*Web integration for session management

• WebLogic 12c supports Oracle traffic Director. Oracle Traffic Director is a layer-7 software loadbalancer thats acts as a -and supports:
  • Load balancer
  • Local traffic manager
  • Uses the application network layer 7
  • Can act as a reverse proxy
  • Support for SSL 3.0 and TLS 1.0. You can configure SSL/TLS-enabled HTTP listeners
  • Will be the replacement for Oracle WebCache.
  • Is not a built-in feature of  WebLogic 12c
  • Integrated Traffic Management like routing, Load Balancing,  request
    routing and caching and SSL Crypto acceleration.

Screenshot of the OTD

Some more Exalogic features

• The Virtual Assembly Builder:
  • Deploy, un-deploy scale Assemblies with Oracle Virtual Assembly, quickly create and configure entire multi-tier application topologies
• Exabus – High Speed Network Virtualization using:
  • Coherence 3.7 for JAVA applications
  • Tuxedo 12c for C C++ applications
• Both are using: Direct Memory Access and Kernel Bypass for better throughput and lower latency

Summary

Of course, I can’t discuss all of the over more than 200 features WebLogic 12c brings with this new release.You can see the Exalogic readiness of the WebLogic 12c release, but for those who can’t afford such a configuration, or simply do not need it, WebLogic 12c can still be of a great value leveraging a solid, robust, fast and scalable application server from which you can use all the built in enhancements.

WebLogic 12c will be ready for all kinds of other products from the Oracle portfolio like the SOA Suite, WebCenter and so on, although those products will be at the 12c level in the coming 2012/2013 year.

An sort of minor detail but for the native BEA customers: the Administration Console will be phased out somewhere in the future bot not in the 12c family!

Have fun using it! Planned at December the 5th available for download.

https://event.on24.com/eventRegistration/EventLobbyServlet?target=registration.jsp&eventid=375727&sourcepage=register

So, what’s there to be expected. Personally I think WebLogic has been made Exalogic ready, according to Mike Lehmann, Director of Product Management for Oracle WebLogic.

Some of the few features I expect:

• Edwin Biemond

http://www.amazon.com/Oracle-Weblogic-Server-11gR1-Administration/dp/1849683026/ref=sr_1_5?ie=UTF8&qid=1320912495&sr=8-5

• Jurgen Kress

https://weblogiccommunity.wordpress.com/2011/11/09/oracle-weblogic-server-11gr1-ps2-administration-essentials-book-and-ebook

• Markus Eisele

http://blog.eisele.net/2011/11/review-oracle-weblogic-server-11gr1-ps2.html

• Frank Muntz

http://t.co/ukq1SUx6

One of those products was BEA Tuxedo, at that time at the release of 6. I worked at a settlements project, and Tuxedo was used for as distributed transaction processing, to process settlements an clearing messageg from the bank to an international Clearing an Settlements Project, called CLS. It used the SWIFT network to connect; CLS  was an international and timezone independent settlements and clearance platform to overcome timezone and bankrupt issues, and prevent a domino effect when an important bank in the chain becomes bankrupt.

Tuxedo is a transaction processing system or transaction-oriented middleware, or enterprise application server for a variety of systems and programming languages.

Tuxedo was designed for high availability and to provide  scalable applications to support a lot  transactions per second on commonly available distributed systems. It was developed and designed by AT&T  if that required online transaction processing (OLTP) capabilities.

Tuxedo is a  message routing and queuing system. Requests are sent to named services and Tuxedo uses memory based inter-process communication facilities to queue the requests to servers. The requester is unaware of where the server that actually processes the request is located or how it is implemented. In fact, Tuxedo was already implementing the SOA, in the early days before even the concept of SOA was familiair to any one.

Oracle acquired it in 2008, along with all other products from the BEA stack. I was really curious how Oracle would position this product, but during Oracle OpenWorld 2011 it became clear to me.

Oracle Tuxedo 12c will be part of the new Exabus stack, a component embedded in the Exalogic solution Oracle launched some earlier.

In this picture, you can see the position of the Exabus stack and in particular Tuxedo:

Oracle poses Tuxedo as THE interface for C/C++ and Cobol applications, so from here Oracle tries to reach the Mainframe segment to migrate those applications to a Exalogic infrastructures with in this case the Tuxedo as a middleware solution for these applications, where on the other side of the Exabus stack Coherence for JAVA applications.

Tuxedo in the Oracle version delivers:

Communication concentrators

For remote clients (Java, CORBA, or WebServices)

Gateways

To facilitate the sharing of services across domains, Tuxedo provides domain gateways.

Failure recovery

Each machine monitors the state of all servers and can automatically restart failed servers.

Transaction monitoring and coordination

Tuxedo applications can  make use of the transactions ( to databases or other subsystems)  to be controlled by the application or automatically controlled by the Tuxedo configuration, i.e., container controlled transactions.

Queuing subsystem

Tuxedo uses a queuing subsystem called /Q. This facility provides transient and persistent queues. Looks a lot like JMS or MQ

Newer Products from Oracle

Mainframe re-hosting

To migrate the C/C++ and  Cobol applications

SALT

For web services, SOAP/HTTP(S) gateway and for developing SCA based applications in C++, Python, PHP and Ruby. Supports modules for Apache Web Server, Oracle HTTP Server, and Oracle iPlanet Web Server

Tuxedo Mainframe Adapters (TMA)

This  provides a set of  processes that run on Tuxedo that communicate with a mainframe.

JCA Adapter

This  is a wrapper to  WebLogic Tuxedo Connector (WTC) as part of WebLogic Server . WTC can only be used on WebLogic, but the JCA adapter allows deploying WTC capabilities on other Java Apps Servers that support JEE JCA

Conclusion

I think Tuxedo, although less known than some other software products,  is a solid, reliable and scalable product which Oracle transformed to be part of the Exabus API. I will be monitoring Tuxedo an will come up with news as soon as I know. The technology is proven in mission critical systems like the SWIFT Banking infrastructure.

While busy dropping some tweets, I noticed a tweet mentioning my book; I opened the link and what did I see? An article on the San Francisco Chronicle online version, about the announcement form Packt about the publishing of my book.

So now, I’m waiting for the limo taking me downtown to SF  … well, it didn’t show up so I took BART to downtown SF. Bit still a neat thing to see you name in a local paper!

Here’s the article:

http://www.sfgate.com/cgi-bin/article.cgi?f=/g/a/2011/10/04/prweb8846728.DTL