Thursday, 26 January 2017

WLST script to create JMS Objects  ( JMS servers , Modules , FileStore ,Queue , Topic , Connection factories and so on )

1) Step : Create property file with list of JMS Servers , JMS Module,FileStore ,Queue , Topic , Connection factories needs to configure.  Let us say property file name : jmsObjects.properties.

#  JMS Objects - Properties
#
#
#############################################################
domain.name=soa_domain

wlst.log=soa_domain_jms.log
admin.url=t3://AdminServerURL:7001
admin.username=Weblogic
admin.password=Weblogic1

####################################################################
# PERSISTENT STORES PROPERTIES
####################################################################
persistentstores.list=JMSFileStorePOSIA_auto_1,JMSFileStorePOSIA_auto_2

JMSFileStorePOSIA_auto_1.directory=/u01/admin/soa_domain/soa_cluster/JMSFileStorePOSIA_auto_1
JMSFileStorePOSIA_auto_1.target=wls_soa1
JMSFileStorePOSIA_auto_1.targetType=Server

JMSFileStorePOSIA_auto_2.directory=/u01/admin/soa_domain/soa_cluster/JMSFileStorePOSIA_auto_2
JMSFileStorePOSIA_auto_2.target=wls_soa3
JMSFileStorePOSIA_auto_2.targetType=Server



###################################################################
#
#        JMS SERVERS PROPERTIES
##################################################################
jmsservers.list=JMSServer_auto_1,JMSServer_auto_2

JMSServer_auto_1.filestore=JMSFileStorePOSIA_auto_1
JMSServer_auto_1.target=wls_soa1
JMSServer_auto_1.targetType=Server

JMSServer_auto_2.filestore=JMSFileStorePOSIA_auto_2
JMSServer_auto_2.target=wls_soa3
JMSServer_auto_2.targetType=Server



##################################################################
##
##################################################################
##
##         JMS MODULES
##
#################################################################
jmsmodules.list=JMSModule

JMSModule.targets=soa_cluster:Cluster


JMSModule.subdeployments.list=SUB
JMSModule.SUB.target=JMSServer_auto_1,JMSServer_auto_2
JMSModule.SUB.targetType=JMSServer



JMSModule.connectionFactories.list=QueueConnectionFactory,ErrorConnectionFactory

JMSModule.QueueConnectionFactory.jndiName=jms/jms/QueueConnectionFactory
JMSModule.QueueConnectionFactory.clientID=
JMSModule.QueueConnectionFactory.clientIDPolicy=
JMSModule.QueueConnectionFactory.subscriptionSharingPolicy=
JMSModule.QueueConnectionFactory.messagesMaximun=
JMSModule.QueueConnectionFactory.xaEnabled=true
JMSModule.QueueConnectionFactory.transactionTimeout=
JMSModule.QueueConnectionFactory.serverAffinity=false


JMSModule.uniformDistributedQueues.list=IN_QUEUE_DLQ


Step 2) : create below .py script . let us say file name : JMSObjectsCreation.py

"""
This script starts an edit session, creates two different JMS Servers,
targets the jms servers to the server WLST is connected to and creates
jms topics, jms queues and jms templates in a JMS System module. The
jms queues and topics are targeted using sub-deployments.
"""

def startTransaction():
    edit()
    startEdit()

def endTransaction():
    save()
    activate(block="true")


############################################################################
#  Connect to the domain Administration Server
############################################################################
def connectToAdminServer(conUsername, conPassword, conURL):
    try:
        print 'Connecting to the Admin Server : %s with the user: %s' %(conURL, conUsername)
        connect(conUsername, conPassword, conURL)
        print 'Connected...'
    except:
        print 'Cannot connect to the administration server'
        exit()

def createFilePersistentStore(psname, psDirectoryValue, psTargetValue, psTargetType):
    try:
        print 'Creating Physical Directories on the shared'
        fileStoreDir = File(psDirectoryValue)
        bCreate = fileStoreDir.mkdirs()
        if bCreate == 0:
            if fileStoreDir.delete() == 1:
                bCreate = fileStoreDir.mkdirs()
            else:
                stopExecution("Cannot create a physical directory")
                exit()
        print 'Creating File Persistent Store'
        cmo = cd('/')
        print psname
        cmo.createFileStore(psname)
        psPath = '/FileStores/' + psname
        cmo = cd(psPath)
        cmo.setDirectory(psDirectoryValue)
        targets = createTargetsObj(psTargetValue, psTargetType)
        print targets

        set('Targets',jarray.array(targets, ObjectName))

        save()
        print ' Successful Create File Persistent Store %s' %(psname)

    except Exception, e:
        print 'Cannot Create the File Persistent Store %s' %(psname)
        print e
        cancelEdit('y')
        stopExecution('Cannot Create the File Persistent Store')
        exit()

def createJMSServer(jmsServerName, jmsFileStoreValue, jmsTargetValue,jmsTargetTypePropertyValue):
    try:
        print 'Creating JMS Server'
        cmo = cd('/')
        cmo.createJMSServer(jmsServerName)
        jmsPath = '/Deployments/' + jmsServerName
        cmo = cd(jmsPath)
        fsPath = '/FileStores/' + jmsFileStoreValue
        cmo.setPersistentStore(getMBean(fsPath))

        targets = createTargetsObj(jmsTargetValue, jmsTargetTypePropertyValue)

        set('Targets',jarray.array(targets, ObjectName))

        save()
        print ' Successful Create JMS Server %s' %(jmsServerName)

    except Exception, e:
        print 'Cannot Create the JMS Server %s' %(jmsServerName)
        print e
        cancelEdit('y')
        stopExecution('Cannot Create the JMS Server')
        exit()

def createJMSModule(jmsModuleName,jmsModuleTargets):
    try:
        print 'Creating JMS Module'
        cmo = cd('/')
        cmo.createJMSSystemResource(jmsModuleName)
        modulePath = '/SystemResources/' + jmsModuleName
        cmo = cd(modulePath)
        print "jmsModuleTargets =  "+jmsModuleTargets
        targets = createTargetsObjList(jmsModuleTargets)
        set('Targets',jarray.array(targets, ObjectName))

        save()
        print ' Successful Create JMS Module %s' %(jmsModuleName)

    except Exception, e:
        print 'Cannot Create the JMS Module %s' %(jmsModuleName)
        print e
        cancelEdit('y')
        stopExecution('Cannot Create the JMS Server')
        exit()


def createTargetsObj(targets, targetType):
    listOfTargets = []
    targetList = targets.split(',')
    for target in targetList:
        targetObj = 'com.bea:Name='+ target + ',Type=' + targetType
        print targetObj
        listOfTargets.append(ObjectName(str(targetObj)))

    return listOfTargets

def createTargetsObjList(listOfTargetsStr):
    listOfTargets = []
    targetList = listOfTargetsStr.split(',')
    for targetStr in targetList:
        target = targetStr.split(":")
        targetObj = 'com.bea:Name='+ target[0] + ',Type=' + target[1]
        print targetObj
        listOfTargets.append(ObjectName(str(targetObj)))

    return listOfTargets

def getJMSModulePath(jmsModuleName):
        jmsModulePath = "/JMSSystemResources/"+jmsModuleName+"/JMSResource/"+jmsModuleName
        return jmsModulePath

def createSubDeployment(jmsModuleName, jmsSubDeployName, jmsTargetVal, jmsTargetTypeVal):
    try:
        print 'Creating SubDeployment...' + jmsSubDeployName + ' for Module ...' + jmsModuleName
        cmo = cd('/')
        cmo = cd('/SystemResources/'+jmsModuleName)
        cmo.createSubDeployment(jmsSubDeployName)
        cmo = cd('/SystemResources/'+jmsModuleName+'/SubDeployments/'+subDeployName)
        targets = createTargetsObj(jmsTargetVal, jmsTargetTypeVal)
        set('Targets',jarray.array(targets, ObjectName))

        save()
        print ' Successful Create SubDeployment %s' %(jmsSubDeployName)

    except Exception, e:
        print 'Cannot Create the SubDeployment name %s' %(jmsSubDeployName)
        print e
        cancelEdit('y')
        stopExecution('Cannot Create the JMS Module')
        exit()

def createJMSConnectionFactory(jmsModuleName, cfName, configProps):
    try:
        jmsModulePath = getJMSModulePath(jmsModuleName)
        cmo = cd(jmsModulePath)
        cf = create(cfName,'ConnectionFactory')
        cfPath =jmsModulePath + '/ConnectionFactories/' + cfName
        cmo = cd(cfPath)
        value = configProps.get(jmsModuleName + '.' + cfName + '.jndiName')
        if (value != None and value != ''):
            value = String(value).trim()
            cmo.setJNDIName(value)

        value = configProps.get(jmsModuleName + '.' + cfName + '.subdeploymentName')
        if (value != None and value != ''):
            value = String(value).trim()
            cmo.setSubDeploymentName(value)
            cmo.setDefaultTargetingEnabled(false)
        else:
            cmo.setDefaultTargetingEnabled(true)

        cmo = cd(cfPath + '/ClientParams/' + cfName)

        value = configProps.get(jmsModuleName + '.' + cfName + '.clientID')
        if (value != None and value != ''):
            value = String(value).trim()
            cmo.setClientId(value)

        value = configProps.get(jmsModuleName + '.' + cfName + '.clientIDPolicy')
        if (value != None and value != ''):
            if (value == 'Restricted' or value == 'Unrestricted'):
                cmo.setClientIdPolicy(value)

        value = configProps.get(jmsModuleName + '.' + cfName + '.subscriptionSharingPolicy')
        if (value != None and value != ''):
            if (value == 'Exclusive' or value == 'Sharable'):
                cmo.setSubscriptionSharingPolicy(value)

        value = configProps.get(jmsModuleName + '.' + cfName + '.messagesMaximun')
        if (value != None and value != ''):
            cmo.setMessagesMaximum(value)

        cmo = cd(cfPath+'/TransactionParams/'+ cfName)

        value = configProps.get(jmsModuleName + '.' + cfName + '.xaEnabled')
        if (value == 'true'):
            cmo.setXAConnectionFactoryEnabled(true)
        if (value == 'false'):
            cmo.setXAConnectionFactoryEnabled(false)

        value = configProps.get(jmsModuleName + '.' + cfName + '.transactionTimeout')
        if (value != None and value != ''):
            cmo.setTransactionTimeout(Long(value))

        cmo = cd(cfPath+'/LoadBalancingParams/'+ cfName)

        value = configProps.get(jmsModuleName + '.' + cfName + '.serverAffinity')
        if (value != None and value != ''):
            if (value == 'true'):
                cmo.setServerAffinityEnabled(true)
            if (value == 'false'):
                cmo.setServerAffinityEnabled(false)

        save()
        print ' Successful Create Connection Factory %s' %(cfName)

    except Exception, e:
        print 'Cannot Create the Connection Factory name %s' %(cfName)
        print e
        cancelEdit('y')
        stopExecution('Cannot Create the Connection Factory')
        exit()


def createJMSDistributedQueueUDD(jmsModuleName, distrQName, configProps):
    try:
        jmsModulePath = getJMSModulePath(jmsModuleName)
        cmo = cd(jmsModulePath)
        cmo.createUniformDistributedQueue(distrQName)
        distrQPath = jmsModulePath + '/UniformDistributedQueues/' + distrQName
        cmo = cd(distrQPath)
        value = configProps.get(jmsModuleName + '.' + distrQName + '.jndiName')
        if (value != None and value != ''):
            value = String(value).trim()
            cmo.setJNDIName(value)

        value = configProps.get(jmsModuleName + '.' + distrQName + '.subdeploymentName')
        if (value != None and value != ''):
            value = String(value).trim()
            cmo.setSubDeploymentName(value)

        cmo = cd(distrQPath + '/DeliveryFailureParams/' + distrQName)

        value = configProps.get(jmsModuleName + '.' + distrQName + '.errorDestination')
        if (value != None and value != ''):
            value = String(value).trim()
            errorQPath = '/JMSSystemResources/' + jmsModuleName + '/JMSResource/' + jmsModuleName + '/UniformDistributedQueues/' + value
            cmo.setErrorDestination(getMBean(errorQPath))

        value = configProps.get(jmsModuleName + '.' + distrQName + '.expirationLoggingPolicy')
        if (value != None and value != ''):
            value = String(value).trim()
            cmo.setExpirationLoggingPolicy(value)

        value = configProps.get(jmsModuleName + '.' + distrQName + '.expirationPolicy')
        if (value != None and value != ''):
            value = String(value).trim()
            cmo.setExpirationPolicy(value)

        value = configProps.get(jmsModuleName + '.' + distrQName + '.redeliveryLimit')
        if (value != None and value != ''):
            cmo.setRedeliveryLimit(Integer(value))

        cmo = cd(distrQPath + '/DeliveryParamsOverrides/' + distrQName)

        value = configProps.get(jmsModuleName + '.' + distrQName + '.deliveryMode')
        if (value != None and value != ''):
            value = String(value).trim()
            cmo.setDeliveryMode(value)

        value = configProps.get(jmsModuleName + '.' + distrQName + '.redeliveryDelay')
        if (value != None and value != ''):
            cmo.setRedeliveryDelay(Long(value))

        value = configProps.get(jmsModuleName + '.' + distrQName + '.timeToDeliver')
        if (value != None and value != ''):
            cmo.setTimeToDeliver(value)

        value = configProps.get(jmsModuleName + '.' + distrQName + '.timeToLive')
        if (value != None and value != ''):
            cmo.setTimeToLive(Long(value))

        cd(distrQPath + '/MessageLoggingParams/' + distrQName)

        value = configProps.get(jmsModuleName + '.' + distrQName + '.messageLoggingEnabled')
        if (value == 'true'):
            cmo.setMessageLoggingEnabled(true)
        if (value == 'false'):
            cmo.setMessageLoggingEnabled(false)

        value = configProps.get(jmsModuleName + '.' + distrQName + '.messageLoggingFormat')
        if (value != None and value != ''):
            value = String(value).trim()
            cmo.setMessageLoggingFormat(value)

        save()

    except Exception, e:
        print 'Cannot Create the UUD Queue name %s' %(distrQName)
        print e

def createJMSDistributedTopicUDD(jmsModuleName, distrTopicName, configProps):
    try:
        jmsModulePath = getJMSModulePath(jmsModuleName)
        cmo = cd(jmsModulePath)
        cmo.createUniformDistributedTopic(distrTopicName)
        distrTPath = jmsModulePath + '/UniformDistributedTopics/' + distrTopicName
        cmo = cd(distrTPath)

        value = configProps.get(jmsModuleName + '.' + distrTopicName + '.jndiName')
        cmo.setJNDIName(value)

        value = configProps.get(jmsModuleName + '.' + distrTopicName + '.forwardingPolicy')
        if (value == 'Replicated' or value == 'Partitioned'):
            cmo.setForwardingPolicy(value)

        value = configProps.get(jmsModuleName + '.' + distrTopicName + '.subdeploymentName')
        if (value != None and value != ''):
            value = String(value).trim()
            cmo.setSubDeploymentName(value)

        value = configProps.get(jmsModuleName + '.' + distrTopicName + '.jmscreatedestinationidentifier')
        if (value != None and value != ''):
            value = String(value).trim()
            cmo.setJMSCreateDestinationIdentifier(value)

        cmo = cd(distrTPath + '/DeliveryFailureParams/' + distrTopicName)

        value = configProps.get(jmsModuleName + '.' + distrTopicName + '.errorDestination')
        if (value != None and value != ''):
            value = String(value).trim()
            errorTPath = '/JMSSystemResources/' + jmsModuleName + '/JMSResource/' + jmsModuleName + '/UniformDistributedTopics/' + value
            cmo.setErrorDestination(getMBean(errorTPath))

        value = configProps.get(jmsModuleName + '.' + distrTopicName + '.expirationPolicy')
        if (value == 'None' or value == 'Log' or value == 'Redirect' or value == 'Discard'):
            cmo.setExpirationPolicy(value)

        value = configProps.get(jmsModuleName + '.' + distrTopicName + '.redeliveryLimit')
        if (value != None and value != ''):
            value = String(value).trim()
            cmo.setRedeliveryLimit(Integer(value))

        cmo = cd(distrTPath + '/DeliveryParamsOverrides/' + distrTopicName)

        value = configProps.get(jmsModuleName + '.' + distrTopicName + '.deliveryMode')
        if (value == 'Persistent' or value == 'Non-Persistent' or value == 'No-Delivery'):
            cmo.setDeliveryMode(value)

        value = configProps.get(jmsModuleName + '.' + distrTopicName + '.redeliveryDelay')
        if (value != None and value != ''):
            value = String(value).trim()
            cmo.setRedeliveryDelay(Long(value))

        value = configProps.get(jmsModuleName + '.' + distrTopicName + '.timeToDeliver')
        if (value != None and value != ''):
            value = String(value).trim()
            cmo.setTimeToDeliver(value)

        value = configProps.get(jmsModuleName + '.' + distrTopicName + '.timeToLive')
        if (value != None and value != ''):
            value = String(value).trim()
            cmo.setTimeToLive(Long(value))


        cmo = cd(distrTPath + '/MessageLoggingParams/' + distrTopicName)
        value = configProps.get(jmsModuleName + '.' + distrTopicName + '.messageLoggingEnabled')
        if (value == 'false'):
            cmo.setMessageLoggingEnabled(false)

        if (value == 'true'):
            cmo.setMessageLoggingEnabled(true)
            format = configProps.get(jmsModuleName + '.' + distrTopicName + '.messageLoggingFormat')
            if (format != None and format != ''):
                format = String(format).trim()
                cmo.setMessageLoggingFormat(format)

        save()

    except Exception, e:
        print 'Cannot Create the Distributed Topic Name %s' %(distrTopicName)
        print e


def createJMSTemplates(jmsModuleName, template, configProps):
    try:
        jmsModulePath = getJMSModulePath(jmsModuleName)
        cmo = cd(jmsModulePath)
        cmo.createTemplate(template)
        templatePath = jmsModulePath + '/Templates/' + template
        cmo = cd(templatePath)

        cmo = cd(templatePath + '/DeliveryFailureParams/' + template)

        value = configProps.get(jmsModuleName + '.' + template + '.expirationPolicy')
        if (value == 'None' or value == 'Log' or value == 'Redirect' or value == 'Discard'):
            cmo.setExpirationPolicy(value)

        value = configProps.get(jmsModuleName + '.' + template + '.redeliveryLimit')
        if (value != None and value != ''):
            value = String(value).trim()
            cmo.setRedeliveryLimit(Integer(value))

        cmo = cd(templatePath + '/DeliveryParamsOverrides/' + template)

        value = configProps.get(jmsModuleName + '.' + template + '.deliveryMode')
        if (value == 'Persistent' or value == 'Non-Persistent' or value == 'No-Delivery'):
            cmo.setDeliveryMode(value)

        value = configProps.get(jmsModuleName + '.' + template + '.redeliveryDelay')
        if (value != None and value != ''):
            value = String(value).trim()
            cmo.setRedeliveryDelay(Long(value))

        value = configProps.get(jmsModuleName + '.' + template + '.timeToDeliver')
        if (value != None and value != ''):
            value = String(value).trim()
            cmo.setTimeToDeliver(value)

        value = configProps.get(jmsModuleName + '.' + template + '.timeToLive')
        if (value != None and value != ''):
            value = String(value).trim()
            cmo.setTimeToLive(value)


        cmo = cd(templatePath + '/MessageLoggingParams/' + template)
        value = configProps.get(jmsModuleName + '.' + template + '.messageLoggingEnabled')
        if (value == 'false'):
            cmo.setMessageLoggingEnabled(false)

        if (value == 'true'):
            cmo.setMessageLoggingEnabled(true)
            format = configProps.get(jmsModuleName + '.' + template + '.messageLoggingFormat')
            if (format != None and format != ''):
                format = String(format).trim()
                cmo.setMessageLoggingFormat(format)

        save()

    except Exception, e:
        print 'Cannot Create the template Name %s' %(template)
        print e



def createJMSQuotas(jmsModuleName, quota, configProps):
    try:
        jmsModulePath = getJMSModulePath(jmsModuleName)
        cmo = cd(jmsModulePath)
        cmo.createQuota(quota)
        quotaPath = jmsModulePath + '/Quotas/' + quota
        cmo = cd(quotaPath)

        value = configProps.get(jmsModuleName + '.' + quota + '.bytesMaximum')
        if (value != None and value != ''):
            value = String(value).trim()
            cmo.setBytesMaximum(Long(value))

        value = configProps.get(jmsModuleName + '.' + quota + '.messagesMaximum')
        if (value != None and value != ''):
            value = String(value).trim()
            cmo.setMessagesMaximum(Long(value))

        value = configProps.get(jmsModuleName + '.' + quota + '.policy')
        if (value != None and value != ''):
            value = String(value).trim()
            cmo.setPolicy(value)

        value = configProps.get(jmsModuleName + '.' + quota + '.shared')
        if (value == 'false'):
            cmo.setShared(false)
        if (value == 'true'):
            cmo.setShared(true)

        save()

    except Exception, e:
        print 'Cannot Create the Quota Name %s' %(quota)
        print e



def UpdateJMSServer(jmsServerName, configProps):
    try:
        print 'Updating JMS Server %s' %(jmsServerName)
        jmsPath = '/Deployments/' + jmsServerName
        cmo = cd(jmsPath)

        value = configProps.get(jmsServerName + '.hostingTemporaryDestinations')
        if (value != None and value != ''):
            value = String(value).trim()
            if (value == 'true'):
                cmo.setHostingTemporaryDestinations(true)
                value1 = configProps.get(jmsServerName + '.temporaryTemplateResource')
                if (value1 != None and value1 != ''):
                    value1 = String(value1).trim()
                    cmo.setTemporaryTemplateResource(value1)

                value1 = configProps.get(jmsServerName + '.temporaryTemplateName')
                if (value1 != None and value1 != ''):
                    value1 = String(value1).trim()
                    cmo.setTemporaryTemplateName(value1)
                #end if
            #end if
        #end if

        save()
        print ' Successful Update JMS Server %s' %(jmsServerName)

    except Exception, e:
        print 'Cannot Update the JMS Server %s' %(jmsServerName)
        print e
        cancelEdit('y')
        stopExecution('Cannot Update the JMS Server')
        exit()

def createForeignJNDIProvider(foreignJNDIProviderName,listOfTargetsStr,initialContextFactory,providerURL,user,password):
    try:
        print 'Creating ForeignJNDIProvider'
        cmo = cd('/')
        foreignJNDIInstance=create(foreignJNDIProviderName,"ForeignJNDIProvider")
        foreignJNDIInstance.setInitialContextFactory(initialContextFactory)
        foreignJNDIInstance.setProviderURL(providerURL)
        foreignJNDIInstance.setUser(user)
        foreignJNDIInstance.setPassword(password)

        targetList = listOfTargetsStr.split(',')
        for targetStr in targetList:
                target = targetStr.split(":")
                targetObj = 'com.bea:Name='+ target[0] + ',Type=' + target[1]
                if (target[1]=="Server"):
                        targetMB=getMBean("/Servers/"+target[0])
                if (target[1]=="Cluster"):
                        targetMB=getMBean("/Clusters/"+target[0])
                if targetMB is None:
                        print "@@@ Invalid Foreign JNDI Provider Target '"+target[0]+"'"
                        exit()
                foreignJNDIInstance.addTarget(targetMB)

        save()

    except Exception, e:
        print 'Cannot Create the Foreign JNDI Provider name %s' %(foreignJNDIProviderName)
        print e
        cancelEdit('y')
        stopExecution('Cannot Create the Foreign JNDI Provider')
        exit()

def createForeignJNDIProviderLink(foreignJNDIProviderName,linkName,localJNDI,remoteJNDI):
    try:
        print 'Creating ForeignJNDIProvider link'
        foreignJNDIInstance = getMBean("/ForeignJNDIProviders/"+foreignJNDIProviderName)
        foreignLinkInstance=foreignJNDIInstance.createForeignJNDILink(linkName)
        foreignLinkInstance.setLocalJNDIName(localJNDI)
        foreignLinkInstance.setRemoteJNDIName(remoteJNDI)
        save()

    except Exception, e:
        print 'Cannot Create the Foreign JNDI Provider name %s' %(foreignJNDIProviderName)
        print e
        cancelEdit('y')
        stopExecution('Cannot Create the Foreign JNDI Provider')
        exit()

####################################################################################################
#
#     Main Module
#
####################################################################################################

from java.io import FileInputStream
from wlstModule import *

print 'Starting...'

propertiesFile = sys.argv[1]
if (propertiesFile == None or len(propertiesFile) == 0):
    print 'Usage wlst.sh configureJMSObjects.py JMSPLIS.properties'
    exit()

try:
    propInputStream = FileInputStream(propertiesFile)
    configProps = Properties()
    configProps.load(propInputStream)
    wlstLogFile = configProps.get("wlst.log")
    redirect(wlstLogFile)

    domainName=configProps.get("domain.name")
    adminURL=configProps.get("admin.url")
    adminUserName=configProps.get("admin.username")
    adminPassword=configProps.get("admin.password")
except Exception, e:
    print 'Missing properties in properties file or cannot read properties file'
    print e
    exit()

#    Connect to the Administration Server

print 'Connecting to the Administration server ...'
connectToAdminServer(adminUserName, adminPassword, adminURL)

print 'Starting Edit the domain ' + domainName

#### Starting an edit session

startTransaction()

### Creating file stores
filestores=configProps.get("persistentstores.list")
if (filestores != None and (len(String(filestores).trim()) > 0)):

    print 'Creating Persistent Stores:  %s' %(filestores)

    listofPS = filestores.split(',')
    for psname in listofPS:
        print psname
        psDirectoryProperty = psname + '.directory'
        psDirectoryValue = configProps.get(psDirectoryProperty)
        print psDirectoryValue
        psTargetProperty = psname + '.target'
        psTargetValue = configProps.get(psTargetProperty)
        print psTargetValue
        psTargetTypeProperty = psname + '.targetType'
        psTargetTypeValue = configProps.get(psTargetTypeProperty)
        print psTargetTypeValue

        createFilePersistentStore(psname, psDirectoryValue, psTargetValue, psTargetTypeValue)

# Create JMS Servers
jmsservers=configProps.get("jmsservers.list")
if (jmsservers != None and (len(String(jmsservers).trim()) > 0)):
    print 'Creating JMS Servers:  %s' %(jmsservers)

    listofJMSServers = jmsservers.split(',')
    for jmsServerName in listofJMSServers:
        print jmsServerName
        jmsFileStoreProperty = jmsServerName + '.filestore'
        jmsFileStoreValue = configProps.get(jmsFileStoreProperty)
        print jmsFileStoreValue
        jmsTargetProperty = jmsServerName + '.target'
        jmsTargetValue = configProps.get(jmsTargetProperty)
        print jmsTargetValue
        jmsTargetTypeProperty = jmsServerName + '.targetType'
        jmsTargetTypeValue = configProps.get(jmsTargetTypeProperty)
        print jmsTargetTypeValue

        createJMSServer(jmsServerName, jmsFileStoreValue, jmsTargetValue, jmsTargetTypeValue)

#### Activating the creation of JMS Servers before creating the modules
endTransaction()

startTransaction()

#Create JMS Modules
jmsmodules = configProps.get("jmsmodules.list")
if (jmsmodules != None and (len(String(jmsmodules).trim()) > 0)):
    print 'Creating JMS Modules: %s' %(jmsmodules)
    listofJMSModules = jmsmodules.split(',')
    for jmsModuleName in listofJMSModules:
        print jmsModuleName
        jmsTargetsProp = jmsModuleName + '.targets'
        jmsTargetsPropValue = configProps.get(jmsTargetsProp)
        print jmsTargetsPropValue

        createJMSModule(jmsModuleName,jmsTargetsPropValue)

        ####Create Sub deployment

        subDeploys = configProps.get(jmsModuleName + '.subdeployments.list')
        if (subDeploys != None and (len(String(subDeploys).trim()) > 0)):
            print 'Creating Sub Deployments: %s' %(subDeploys)

          listOfSubDeploys = subDeploys.split(',')
            for subDeployName in listOfSubDeploys:
                print subDeployName
                jmsTargetProperty = jmsModuleName + '.' + subDeployName + '.target'
                jmsTargetTypeProperty = jmsModuleName + '.' + subDeployName + '.targetType'
                jmsTargetVal = configProps.get(jmsTargetProperty)
                jmsTargetTypeVal = configProps.get(jmsTargetTypeProperty)
                createSubDeployment(jmsModuleName, subDeployName, jmsTargetVal, jmsTargetTypeVal)
            #end for
        #end if
        #Create JMS Module Objects - ConnectionFactories
        connFactories = configProps.get(jmsModuleName + '.connectionFactories.list')
        if (connFactories != None and (len(String(connFactories).trim()) > 0)):
            print 'Creating Connection Factories %s for Module: %s' %(connFactories, jmsModuleName)
            listofCfName = connFactories.split(',')
            for cfName in listofCfName:
                print cfName
                createJMSConnectionFactory(jmsModuleName, cfName, configProps)
            # end for connectionFactories
        #end if

        ## Create JMS Templates
        templates = configProps.get(jmsModuleName + '.templates.list')
        if (templates != None and (len(String(templates).trim()) > 0)):
            print 'Creating Templates %s for Module: %s' %(templates, jmsModuleName)
            listofTemplates = templates.split(',')
            for template in listofTemplates:
                print template
                createJMSTemplates(jmsModuleName, template, configProps)
            #end for
        #end if

        ## Create JMS Quotqs
        quotas= configProps.get(jmsModuleName + '.quotas.list')
        if (quotas != None and (len(String(quotas).trim()) > 0)):
            print 'Creating Quotas %s for Module: %s' %(quotas, jmsModuleName)
            listofQuotas = quotas.split(',')
            for quota in listofQuotas:
                print quota
                createJMSQuotas(jmsModuleName, quota, configProps)
            #end for
        #end if

        ## Create JMS Module Objects - Distributed Queue
        distrQueues = configProps.get(jmsModuleName + '.uniformDistributedQueues.list')
        if (distrQueues != None and (len(String(distrQueues).trim()) > 0)):
            print 'Creating Distributed Queues UDD %s for Module: %s' %(distrQueues, jmsModuleName)
            listofDistrQName = distrQueues.split(',')
            for distrQName in listofDistrQName:
                print distrQName
                createJMSDistributedQueueUDD(jmsModuleName, distrQName, configProps)
            #end for
        #end if

        ## Create JMS Module Objects - Distributed Topics
        distrTopics = configProps.get(jmsModuleName + '.uniformDistributedTopics.list')
        if (distrTopics != None and (len(String(distrTopics).trim()) > 0)):
            print 'Creating Distributed Topics UDD %s for Module: %s' %(distrTopics, jmsModuleName)
            listofDistrTName = distrTopics.split(',')
            for distrTName in listofDistrTName:
                print distrTName
                createJMSDistributedTopicUDD(jmsModuleName, distrTName, configProps)
            #end for
        #end if

    #end for
#end if
endTransaction()

startTransaction()
###### Update JMS Servers
jmsservers=configProps.get("update.jmsservers.list")
if (jmsservers != None and (len(String(jmsservers).trim()) > 0)):
    print 'Updating JMS Servers:  %s' %(jmsservers)

    listofJMSServers = jmsservers.split(',')
    for jmsServerName in listofJMSServers:

 print jmsServerName
        UpdateJMSServer(jmsServerName, configProps)


endTransaction()

startTransaction()

#Create Foreign JNDI Providers
foreignJNDIProviders = configProps.get("foreignJNDIProviders.list")
if (foreignJNDIProviders != None and (len(String(foreignJNDIProviders).trim()) > 0)):
    print 'Creating Foreign JNDI Providers: %s' %(foreignJNDIProviders)
    listofForeignJNDIProviders = foreignJNDIProviders.split(',')
    for foreignJNDIProviderName in listofForeignJNDIProviders:
        print foreignJNDIProviderName
        providerTargetsProp = foreignJNDIProviderName + '.targets'
        listOfTargetsStr = configProps.get(providerTargetsProp)
        print listOfTargetsStr
        providerInitialContextFactoryProp = foreignJNDIProviderName + '.initialContextFactory'
        providerInitialContextFactoryPropValue = configProps.get(providerInitialContextFactoryProp)
        print providerInitialContextFactoryPropValue
        providerURLProp = foreignJNDIProviderName + '.providerURL'
        providerURLPropValue = configProps.get(providerURLProp)
        print providerURLPropValue
        providerUserProp = foreignJNDIProviderName + '.user'
        providerUserPropValue = configProps.get(providerUserProp)
        print providerUserPropValue
        providerPasswordProp = foreignJNDIProviderName + '.password'
        providerPasswordPropValue = configProps.get(providerPasswordProp)
        print providerPasswordPropValue

        createForeignJNDIProvider(foreignJNDIProviderName,listOfTargetsStr,providerInitialContextFactoryPropValue,providerURLPropValue,providerUserPropValue,providerPas
swordPropValue)

        ####Create Foreign JNDI Provider Links
        jndiLinks = configProps.get(foreignJNDIProviderName + '.jndi.list')
        if (jndiLinks != None and (len(String(jndiLinks).trim()) > 0)):
            print 'Creating Foreign JNDI Provider Links: %s' %(jndiLinks)
            listOfLinks = jndiLinks.split(',')
            for jndiLinkName in listOfLinks:
                print jndiLinkName
                localJNDIProp = foreignJNDIProviderName + '.jndi.' + jndiLinkName + '.localJNDI'
                localJNDIValue = configProps.get(localJNDIProp)
                remoteJNDIProp = foreignJNDIProviderName + '.jndi.' + jndiLinkName + '.remoteJNDI'
                remoteJNDIValue = configProps.get(remoteJNDIProp)
                createForeignJNDIProviderLink(foreignJNDIProviderName,jndiLinkName,localJNDIValue,remoteJNDIValue)
            #end for
        #end if
    #end for
#end if
endTransaction()

exit()

Step 3) Invoke WLST and run .py script : wlst.sh JMSObjectsCreation.py    jmsObjects.properties

No comments:

Post a Comment