WEBLOGIC JMS: "The persistent file store", "cannot open file"

It is well known that the way to have a persistence store on you JMS Configuration is a good habit on your development mainly if we are talking about of Cluster Enviroment, having a configuration with dat file sored on a filesystem is done by doing asignation on your JMS Server, but what-if something happen with DAT file, perhaps you could even imagine a situation can produce this event, for example a bad configuration throught a unknown familiar user on your server, a kind of application trying to access to DAT file, there some situations could happend, on my experience i have list some specific expection related above:

• The persistence store ... Cannot open file ...
• Cannot find ... DAT File
• GXA... read exception

If you are on this kind of situation my advice to you should please make a backup of your persistence store and follow the next steps:

1. BackUp Persistence Store  on a new folder under your filesystem
2. Delete Components on your weblogic likes: Module JMS, Server JMS and Persistence Store.
3. Shutdown all servers involver, including adminserver
4. Start All Servers, please be sure that no one could have any failed exception related.
5. Make your JMS Configuration Again.
6. Most common problems may be resolve by doing this, if there is another problem by creating a JMS Server please try to change the type of writing to save with cache and File locked to false, this is because the time of saving to DAT probably do a mess with another process.

Please take care about situation likes because someone or something on your operating system try to do a connection  with your DAT file.

Best Regards,

Back-Up FileStore of a JMS Weblogic Configuration

Main reasons you could be benefits of doing this, are a backup, delete, compress or replace .dat file.

• Shutdown servers, cluster, nodeManager  or coherence (cluster or server) who is occupied the JMS Configuration.

• Having access as a root or weblogic user, you  should execute the following script  shell:

1. setWLSEnv.sh: Located on  /opt/weblogic/XXXX/wlserver_10.3/server/bin or wherever is installed weblogic, maybe /root/Oracle/wlserver_10.3/server/bin is another possible location.
2. wlst.sh: Located on  /opt/weblogic/XXXX/wlserver_10.3/common/bin or wherever is installed weblogic, maybe /root/Oracle/wlserver_10.3/common/bin is another possible location.

• Now, what we have just done?, well setWLSEnv.sh configure on your enviroment several jar  that are part of the neccesary running to calling method or classes for doing changes in weblogic without a web console, at the last one is a script which is necessary for doing python/ironpython o command execution,

• After running wlst.sh, you will have a prompt just like this:  wls:/offline> with the weblogic password, user and ip/port the possibilites are unlimted to whatever your imagination could do.

1. Execute: 

wls:/offline> compactstore('<LOCATION_FILESTOREORIGINAL>','<LOCATION_COPYONFAIL>')

•  Depends on your dat size is the time that you will be waiting, may I say that for a 5 files amout of 2GB takes me about 1 hour, please waiting after the execution is complete.

1. In your LOCATION_FILESTOREORIGINAL(ex:/root/jms/filestore) you must a found a compressend file, in my case the size reduce about a 20% per file. 
2. In your LOCATION_COPYONFAIL(ex:/root/jms/backup), you must found the original file with the same size of the original file.

Now, what we have in mind?, perhaps you could limite the size of  your persistence store in the way that you could make a backup for auditing process as I said this could be benifit for each part of development.

Best regards,

How I do implement Request/Response pattern using SpringFramework and Weblogic?

Spring Framework has a lot of modules that could be implemented on several projects, On common questions in any projects is how to used it, The first factor that I could see is to Application Server well know, obviously your web application has to be deployed on an Web Application Server, we have to check the version and supporting jars to run your application, If your Application Server run up 1.5 JEE, a good choice will be Spring Framework, This small article try to getting started to first used spring jms module.

First you have to configure your Application Context:

	<?xml version="1.0" encoding="UTF-8" ?>
	<beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xmlns:context="http://www.springframework.org/schema/context" xmlns:p="http://www.springframework.org/schema/p"
	xmlns:tx="http://www.springframework.org/schema/tx"
	xmlns:jms="http://www.springframework.org/schema/jms"
	xmlns:util="http://www.springframework.org/schema/util"
	xmlns:int="http://www.springframework.org/schema/integration"
	xmlns:int-jms="http://www.springframework.org/schema/integration/jms"
	xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.2.xsd
	http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-3.2.xsd
	http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-3.2.xsd
	http://www.springframework.org/schema/integration http://www.springframework.org/schema/integration/spring-integration-2.2.xsd
	http://www.springframework.org/schema/util http://www.springframework.org/schema/util/spring-util-3.2.xsd
	http://www.springframework.org/schema/jms http://www.springframework.org/schema/jms/spring-jms-3.2.xsd
	http://www.springframework.org/schema/integration/jms http://www.springframework.org/schema/integration/jms/spring-integration-jms.xsd">
	<beans profile="DEV,TEST,PROD">
	<util:properties id="jndi_prop" location="file:///system/config/app-jndi.properties"/>
	<context:property-placeholder properties-ref="jndi_prop"/>
	<context:annotation-config/>
	<bean id="jmsTemplate" class="org.springframework.jms.core.JmsTemplate">
	<property name="connectionFactory" ref="connectionFactory" />
	<property name="destinationResolver" ref="jmsDestinationResolver" />
	<property name="pubSubNoLocal" value="true" />
	<property name="pubSubDomain" value="false" />
	<property name="defaultDestination" ref="xmlMarshallerRequestQueue" />
	<property name="explicitQosEnabled" value="true" />
	</bean>
	<bean id="jndiTemplate" class="org.springframework.jndi.JndiTemplate">
	<property name="environment">
	<props>
	<prop key="java.naming.factory.initial">#{jndi_prop['java.naming.factory.initial']}</prop>
	<prop key="java.naming.factory.url.pkgs">#{jndi_prop['java.naming.factory.url.pkgs']}</prop>
	<prop key="java.naming.provider.url">#{jndi_prop['java.naming.provider.url']}</prop>
	<prop key="java.naming.security.principal">#{jndi_prop['java.naming.security.principal']}</prop>
	<prop key="java.naming.security.credentials">#{jndi_prop['java.naming.security.credentials']}</prop>
	</props>
	</property>
	</bean>
	<bean id="connectionFactory" class="org.springframework.jndi.JndiObjectFactoryBean">
	<property name="jndiTemplate">
	<ref bean="jndiTemplate" />
	</property>
	<property name="jndiName" value="#{jms_prop['jms.connection.factory.jndi.name']}" />
	</bean>
	<bean id="cachingConnectionFactory"
	class="org.springframework.jms.connection.CachingConnectionFactory">
	<property name="targetConnectionFactory" ref="connectionFactory" />
	<property name="sessionCacheSize" value="10" />
	</bean>
	<bean id="jmsTransactionManager" class="org.springframework.jms.connection.JmsTransactionManager">
	<property name="connectionFactory" ref="cachingConnectionFactory" />
	</bean>
	<bean id="jmsDestinationResolver"
	class="org.springframework.jms.support.destination.JndiDestinationResolver">
	<property name="jndiTemplate">
	<ref bean="jndiTemplate" />
	</property>
	<property name="cache" value="true" />
	<property name="fallbackToDynamicDestination" value="false" />
	</bean>
	<bean id="lineBusinessReplyQueue" class="org.springframework.jndi.JndiObjectFactoryBean">
	<property name="jndiTemplate">
	<ref bean="jndiTemplate" />
	</property>
	<property name="jndiName" value="#{jms_prop['jms.queue.jndi.name.lineBusinessreply']}" />
	</bean>
	<bean id="lineBusinessRequestQueue" class="org.springframework.jndi.JndiObjectFactoryBean">
	<property name="jndiTemplate">
	<ref bean="jndiTemplate" />
	</property>
	<property name="jndiName" value="#{jms_prop['jms.queue.jndi.name.lineBusinessrequest']}" />
	</bean>
	<bean id="lineBusinessErrorQueue" class="org.springframework.jndi.JndiObjectFactoryBean">
	<property name="jndiTemplate">
	<ref bean="jndiTemplate" />
	</property>
	<property name="jndiName" value="#{jms_prop['jms.queue.jndi.name.lineBusinesserror']}" />
	</bean>
	<bean id="lineBusinessMessageErrorBrowser" class="mx.com.company.jms.ErrorMessageBrowser">
	<property name="queue" ref="lineBusinessErrorQueue" />
	<property name="jmsTemplate" ref="jmsTemplate" />
	<property name="transactionManager" ref="jmsTransactionManager" />
	</bean>
	</beans>
	</beans>

view raw app-context-jms.xml hosted with ❤ by GitHub

After configurate your xml file you will have to inject a browser of Message Queue:

	/* */ package mx.com.company.jms;
	/* */
	/* */ import java.io.PrintStream;
	/* */ import java.util.ArrayList;
	/* */ import java.util.Enumeration;
	/* */ import java.util.List;
	/* */ import javax.jms.JMSException;
	/* */ import javax.jms.Message;
	/* */ import javax.jms.ObjectMessage;
	/* */ import javax.jms.Queue;
	/* */ import javax.jms.QueueBrowser;
	/* */ import javax.jms.Session;
	/* */ import javax.jms.TextMessage;
	/* */ import org.springframework.jms.connection.JmsTransactionManager;
	/* */ import org.springframework.jms.core.BrowserCallback;
	/* */ import org.springframework.jms.core.JmsTemplate;
	/* */ import org.springframework.transaction.annotation.Isolation;
	/* */ import org.springframework.transaction.annotation.Propagation;
	/* */ import org.springframework.transaction.annotation.Transactional;
	/* */
	/* */ @Transactional
	/* */ public class ErrorMessageBrowser
	/* */ {
	/* */ private JmsTemplate jmsTemplate;
	/* */ private Queue queue;
	/* */ private JmsTransactionManager transactionManager;
	/* */
	/* */ @Transactional(isolation=Isolation.DEFAULT, propagation=Propagation.REQUIRED, rollbackFor={JMSException.class})
	/* */ public int contarMensajes()
	/* */ throws JMSException
	/* */ {
	/* 39 */ int count = ((Integer)this.jmsTemplate.browse(this.queue, new BrowserCallback()
	/* */ {
	/* */ public Integer doInJms(Session session, QueueBrowser browser) throws JMSException {
	/* 42 */ Enumeration enumeration = browser.getEnumeration();
	/* 43 */ int counter = 0;
	/* 44 */ while (enumeration.hasMoreElements()) {
	/* 45 */ Message msg = (Message)enumeration.nextElement();
	/* 46 */ System.out.println(String.format("\tFound : %s", new Object[] { msg }));
	/* 47 */ counter++;
	/* */ }
	/* 49 */ return Integer.valueOf(counter);
	/* */ }
	/* */ })).intValue();
	/* */
	/* 52 */ System.out.println(String.format("\tThere are %s messages", new Object[] { Integer.valueOf(count) }));
	/* 53 */ return count;
	/* */ }
	/* */ @Transactional(isolation=Isolation.DEFAULT, propagation=Propagation.REQUIRED, rollbackFor={JMSException.class})
	/* */ public List<String> obtenerTextMessages() throws JMSException {
	/* 57 */ List count = (List)this.jmsTemplate.browse(this.queue, new BrowserCallback()
	/* */ {
	/* */ public List<String> doInJms(Session session, QueueBrowser browser) throws JMSException {
	/* 60 */ Enumeration enumeration = browser.getEnumeration();
	/* 61 */ List lstText = new ArrayList();
	/* 62 */ while (enumeration.hasMoreElements()) {
	/* 63 */ Message msg = (Message)enumeration.nextElement();
	/* 64 */ if ((msg instanceof TextMessage))
	/* */ {
	/* 66 */ TextMessage tm = (TextMessage)msg;
	/* 67 */ String mensaje = tm.getText();
	/* 68 */ lstText.add(mensaje);
	/* */ }
	/* 70 */ System.out.println(String.format("\tFound : %s", new Object[] { msg }));
	/* */ }
	/* 72 */ return lstText;
	/* */ }
	/* */ });
	/* 75 */ System.out.println(String.format("\tThere are %s messages", new Object[] { count }));
	/* 76 */ return count;
	/* */ }
	/* */
	/* */ public List<Message> obtenerMessageException() throws JMSException {
	/* 80 */ List count = (List)this.jmsTemplate.browse(this.queue, new BrowserCallback()
	/* */ {
	/* */ public List<Message> doInJms(Session session, QueueBrowser browser) throws JMSException {
	/* 83 */ Enumeration enumeration = browser.getEnumeration();
	/* 84 */ List lstText = new ArrayList();
	/* 85 */ while (enumeration.hasMoreElements()) {
	/* 86 */ Message msg = (Message)enumeration.nextElement();
	/* */
	/* 88 */ if ((msg instanceof ObjectMessage))
	/* */ {
	/* 90 */ ObjectMessage om = (ObjectMessage)msg;
	/* 91 */ Object objeto = om.getObject();
	/* 92 */ if ((objeto instanceof MessageException))
	/* 93 */ lstText.add(msg);
	/* */ }
	/* 95 */ System.out.println(String.format("\tFound : %s", new Object[] { msg }));
	/* */ }
	/* 97 */ return lstText;
	/* */ }
	/* */ });
	/* 100 */ System.out.println(String.format("\tThere are %s messages", new Object[] { count }));
	/* 101 */ return count;
	/* */ }
	/* */
	/* */ public void setJmsTemplate(JmsTemplate jmsTemplate)
	/* */ {
	/* 108 */ this.jmsTemplate = jmsTemplate;
	/* */ }
	/* */
	/* */ public JmsTemplate getJmsTemplate() {
	/* 112 */ return this.jmsTemplate;
	/* */ }
	/* */
	/* */ public void setQueue(Queue queue) {
	/* 116 */ this.queue = queue;
	/* */ }
	/* */
	/* */ public Queue getQueue() {
	/* 120 */ return this.queue;
	/* */ }
	/* */
	/* */ public void setTransactionManager(JmsTransactionManager transactionManager) {
	/* 124 */ this.transactionManager = transactionManager;
	/* */ }
	/* */
	/* */ public JmsTransactionManager getTransactionManager() {
	/* 128 */ return this.transactionManager;
	/* */ }
	/* */ }

view raw queuebrowser.java hosted with ❤ by GitHub

Now you can Inject the Request/Response in any Service, this had getting easier a MQ Implementation.


Best Regards,

Create a JMS Destination Key on Weblogic 11g using WSLT

UPDATE: 13/04/2014
The article had been published on CodeProject.

http://www.codeproject.com/Tips/748377/Create-a-JMS-Configuration-on-Oracle-Weblogic-g-us

-------------------------------------------------------------------------------------------

There is another method to create a Server Configuration on Weblogic if you are not using the console, if you want to execute a script with all of your configuration you must know about WSLT.

This model solve problems like deployment on others enviroments like Quality Assurance and Production were you should dont have any permision to access to this console, only the deployer will run the script and install any executable on the server. You should follow the next steps:

1. First go to you Weblogic Home, for example the location of my weblogic installation is:

1:  [root@USER25 bin]# cd /root/Oracle/Middleware/11.1.2.4.0/   

2. Go to the next folder...

1:  [root@USER25 bin]# cd /root/Oracle/Middleware/11.1.2.4.0/wlserver_10.3/server/bin  

3. Open a console and keep in mind you should have running weblogic and the execute:

1:  [root@USER25 bin]# ./setWLSEnv.sh  

4. Running the above command you will have the opportunity to run script on Python and IronPython on your weblogic running, I will show you an script example runs several tasks to create a JMS Server, JMS Module, Queue, Dead Letter Queue and DESTINATION QUEUE that is the object we need for this tutorial, so this the code...

	# OCTAVIO SANCHEZ, http://codefixes.blogspot.mx/
	# SOFTWARE ENGINEER
	from java.io import FileInputStream
	from java.util import Properties
	def loadProperties(fileName):
	properties = Properties()
	input = FileInputStream(fileName)
	properties.load(input)
	input.close()
	result= {}
	for entry in properties.entrySet(): result[entry.key] = entry.value
	return result
	properties = loadProperties("local.properties")
	username = properties['username']
	password = properties['password']
	url = properties['providerURL']
	connect(username, password, url)
	adminServerName = cmo.adminServerName
	try:
	print "Inicializando ..."
	domainName = cmo.name
	cd("Servers/%s" % adminServerName)
	adminServer = cmo
	def deleteIgnoringExceptions(mbean):
	try: delete(mbean)
	except:
	print "delete mbean"
	pass
	def startTransaction():
	edit()
	startEdit()
	def endTransaction():
	save()
	activate(block="true")
	def createDLQ(qname, qjndiname,dkName):
	print "createDLQ() START"
	cd('/JMSSystemResources/'+moduleName+'/JMSResource/'+moduleName)
	errorQueue = create(qname, "Queue")
	errorQueue.JNDIName = qjndiname
	errorQueue.subDeploymentName = subDeploymentName
	print dkName
	cd('/JMSSystemResources/'+moduleName+'/JMSResource/'+moduleName)
	cd('/JMSSystemResources/'+moduleName+'/JMSResource/'+moduleName+'/Queues/'+qname)
	set('DestinationKeys',jarray.array([String(dkName)],String))
	cd('/JMSSystemResources/'+moduleName+'/JMSResource/'+moduleName+'/Queues/'+qname+'/DeliveryFailureParams/'+qname)
	cmo.setRedeliveryLimit(1)
	cmo.setExpirationPolicy('Log')
	cd('/JMSSystemResources/'+moduleName+'/JMSResource/'+moduleName+'/Queues/'+qname+'/DeliveryParamsOverrides/'+qname)
	cmo.setRedeliveryDelay(5000)
	cd('/JMSSystemResources/'+moduleName+'/JMSResource/'+moduleName+'/Queues/'+qname+'/DeliveryFailureParams/'+qname)
	cmo.unSet('ErrorDestination')
	cd('/JMSSystemResources/'+moduleName+'/JMSResource/'+moduleName+'/Queues/'+qname+'/DeliveryParamsOverrides/'+qname)
	cmo.setPriority(-1)
	cmo.setDeliveryMode('Persistent')
	cmo.setTimeToDeliver('-1')
	cmo.setTimeToLive(-1)
	print "createDLQ() END"
	def createDestinationKey(dkname):
	print "createDestinationKey() START"
	cd('/JMSSystemResources/'+moduleName+'/JMSResource/'+moduleName)
	dk1 = create(dkname, "DestinationKey")
	dk1.setProperty("JMSPriority")
	dk1.setKeyType("String")
	dk1.setSortOrder("Descending")
	print "createDestinationKey() END"
	def createQueue(qname, qjndiname, dlqName,dkName):
	print "createQueue() START"
	cd('/JMSSystemResources/'+moduleName+'/JMSResource/'+moduleName)
	q1 = create(qname, "Queue")
	q1.JNDIName = qjndiname
	q1.subDeploymentName = subDeploymentName
	cd('/JMSSystemResources/'+moduleName+'/JMSResource/'+moduleName)
	cd('/JMSSystemResources/'+moduleName+'/JMSResource/'+moduleName+'/Queues/'+qname)
	set('DestinationKeys',jarray.array([String(dkName)],String))
	cd('/JMSSystemResources/'+moduleName+'/JMSResource/'+moduleName+'/Queues/'+qname+'/DeliveryParamsOverrides/'+qname)
	cmo.setRedeliveryDelay(2000)
	print "Assign failed destination to queue"
	cd('/JMSSystemResources/'+moduleName+'/JMSResource/'+moduleName+'/Queues/'+qname+'/DeliveryFailureParams/'+qname)
	cmo.setRedeliveryLimit(3)
	cmo.setExpirationPolicy('Redirect')
	erQueue = getMBean('/JMSSystemResources/'+moduleName+'/JMSResource/'+moduleName+'/Queues/'+dlqName)
	cmo.setErrorDestination(erQueue)
	cd('/JMSSystemResources/'+moduleName+'/JMSResource/'+moduleName+'/Queues/'+qname+'/MessageLoggingParams/'+qname)
	cmo.setMessageLoggingEnabled(true)
	cmo.setMessageLoggingFormat('JMSDestination,JMSMessageID')
	cd('/JMSSystemResources/'+moduleName+'/JMSResource/'+moduleName+'/Queues/'+qname+'/DeliveryParamsOverrides/'+qname)
	cmo.setPriority(-1)
	cmo.setDeliveryMode('Persistent')
	cmo.setTimeToDeliver('-1')
	cmo.setTimeToLive(-1)
	print "createQueue() END"
	def createCF(cfname, cfjndiname, xaEnabled):
	print "createCF() START"
	cd('/JMSSystemResources/'+moduleName+'/JMSResource/'+moduleName)
	cf = create(cfname, "ConnectionFactory")
	cf.JNDIName = cfjndiname
	cf.subDeploymentName = subDeploymentName
	if (xaEnabled == "true"):
	cf.transactionParams.setXAConnectionFactoryEnabled(1)
	print "createCF() END"
	def createJMSModule():
	print "createJMSModule() START"
	cd('/JMSSystemResources')
	jmsModule = create(moduleName, "JMSSystemResource")
	jmsModule.targets = (adminServer,)
	cd(jmsModule.name)
	sd = create(subDeploymentName, "SubDeployment")
	myJMSServer = getMBean('/JMSServers/' + jmsServerName)
	sd.targets = (myJMSServer,)
	print "createJMSModule() END"
	def createJMSServer():
	print "createJMSServer() START"
	startTransaction()
	cd("/JMSServers")
	deleteIgnoringExceptions(jmsServerName)
	cd("/FileStores")
	deleteIgnoringExceptions(fileStoreName)
	cd('/')
	filestore = cmo.createFileStore(fileStoreName)
	filestore.setDirectory(properties['fileStoreDirecory'])
	filestore.targets = (adminServer,)
	endTransaction()
	startTransaction()
	cd("/JMSServers")
	jmsServer = create(jmsServerName, "JMSServer")
	jmsServer.setPersistentStore(filestore)
	jmsServer.targets = (adminServer,)
	endTransaction()
	print "createJMSServer() END"
	moduleName = 'TestJMSSModule'
	subDeploymentName = 'TestJMSSubDeployment'
	fileStoreName = 'TestFileStore'
	jmsServerName = 'TestJMSServer'
	startTransaction()
	cd("/JMSSystemResources")
	deleteIgnoringExceptions(moduleName)
	endTransaction()
	print "Create JMS Server"
	createJMSServer()
	startTransaction()
	print "Create JMS Module"
	createJMSModule()
	dkName1='DefaultDestinationKey'
	print "Create Destinantion Key DefaultDestinationKey"
	createDestinationKey(dkName1)
	queueEDQName1 = 'ApplicationBatchErrorQueue'
	queueEDQJNDIName1 = 'jms/ApplicationBatchErrorQueue'
	print "Create Error Destinantion ApplicationBatchErrorQueue"
	createDLQ(queueEDQName1, queueEDQJNDIName1,dkName1)
	queueName1 = 'ApplicationBatchReplyQueue'
	queueJNDIName1 = 'jms/ApplicationBatchReplyQueue'
	print "Create Queue ApplicationBatchReplyQueue"
	createQueue(queueName1, queueJNDIName1, queueEDQName1,dkName1)
	queueName2 = 'ApplicationBatchRequestQueue'
	queueJNDIName2 = 'jms/ApplicationBatchRequestQueue'
	print "Create Queue ApplicationBatchRequestQueue"
	createQueue(queueName2, queueJNDIName2, queueEDQName1,dkName1)
	queueEDQName3 = 'XMLMarshallerErrorQueue'
	queueEDQJNDIName3 = 'jms/XMLMarshallerErrorQueue'
	print "Create Error Destinantion XMLMarshallerErrorQueue"
	createDLQ(queueEDQName3, queueEDQJNDIName3,dkName1)
	queueName5 = 'XMLMarshallerReplyQueue'
	queueJNDIName5 = 'jms/XMLMarshallerReplyQueue'
	print "Create Queue XMLMarshallerReplyQueue"
	createQueue(queueName5, queueJNDIName5, queueEDQName3,dkName1)
	queueName6 = 'XMLMarshallerRequestQueue'
	queueJNDIName6 = 'jms/XMLMarshallerRequestQueue'
	print "Create Queue XMLMarshallerRequestQueue"
	createQueue(queueName6, queueJNDIName6, queueEDQName3,dkName1)
	myCFName = 'TestConnectionFactory'
	myCFJNDIName = 'jms/TestConnectionFactory'
	print "Create JMS XA Connection Factory TestConnectionFactory"
	createCF(myCFName, myCFJNDIName, "true")
	endTransaction()
	except:
	print "ocurrio un error"
	dumpStack()
	cancelEdit("y")
	print "disconnect"
	disconnect()
	print "exit"
	exit()

view raw createJMSServer.py hosted with ❤ by GitHub

	#Octavio Sanchez
	username=weblogic
	password=weblogic1
	providerURL=t3://localhost:7101
	fileStoreDirecory=/config/jms/TestFileStore

view raw local.properties hosted with ❤ by GitHub

• createJmsServer.py & local.properties

The segment of code we  carry on the next ...

1:    def createDestinationKey(dkname):  
2:        print "createDestinationKey() START"    
3:        cd('/JMSSystemResources/'+moduleName+'/JMSResource/'+moduleName)  
4:        dk1 = create(dkname, "DestinationKey")  
5:        dk1.setProperty("JMSPriority")  
6:        dk1.setKeyType("String")  
7:        dk1.setSortOrder("Descending")  
8:        print "createDestinationKey() END"  

Here we define a part of the XML that is deployed on the server, we pass the property, keytype and sortorder that should be published on Weblogic, this procedure can be executed as a transaction as python script. 

1:            ...  
2:          cd('/JMSSystemResources/'+moduleName+'/JMSResource/'+moduleName)                    
3:            cd('/JMSSystemResources/'+moduleName+'/JMSResource/'+moduleName+'/Queues/'+qname)  
4:            set('DestinationKeys',jarray.array([String(dkName)],String))  
5:          ...  

If you follow the script you will get a declaration of an array on XML, that because if you check Weblogic documentation a Destination Key is an Array of String, so in Python you have to declare your DeclarationKeys as String[], keep in mind that note.

  

5. The comand we need to execute on terminal is:

1:  [root@USER25 bin]# java weblogic.WLST createJmsServer.py  

6. Finally we will see the trace of execution, and veryfing with the Weblogic Console all the script will be create all configuration declarated on python file, this is so much powerfull of course you can create a JNDI or any task that we do over console.

UPDATE 29/05/2016
You could found script uploaded to github on the next link:
https://github.com/osanchezh/weblogicjmsclustered-module  

Best Regards,