WLST script for Weblogic Datasource create , update and delete

1) create a property file with the details of datasources for create , update and delete. Let us property file name : dataSourceCreate_update_delete.properties

admin.url=t3://AdminServerHostName:7001
admin.username=Weblogic
admin.password=Weblogic1

# this value allows main controller to loop over projects to
resources.loop=1,2,3,4

#########################################
# DB Connectionparams for XrsConnectionPool
#########################################
# create,delete,noaction
db.action_1=create
# the format is target1:type1,target2:type2
# the target is cluster name or server nams
# type is either 'Cluster' or 'Server'
db.targets_1=soa_cluster:Cluster
# flag for either 'xa' or 'nonxa'
db.type_1=xa
db.jndiname_1=jdbc/SOA/DEV_SOAINFRA
db.name_1=DEVSOA_INFRA
db.url_1=jdbc:oracle:thin:@DatabaseServerName:dbPort:Schema
db.username_1=DEV_SOAINFRA
db.password_1=XXXXXX
db.transaction_1=
db.test.query_1=SQL SELECT * FROM DUAL
db.maxCapacity_1=32


#########################################
# DB Connectionparams for SOADataSource
#########################################
# create,delete,noaction,update
db.action_2=update
db.name_2=SOADataSource
db.initCapacity_2=10
db.minCapacity_2=10
db.maxCapacity_2=100
db.connectTimeout_2=10000
db.readTimeout_2=30000

#########################################
# DB Connectionparams for SOALocalTxDataSource
#########################################
# create,delete,noaction,update
db.action_3=update
db.name_3=SOALocalTxDataSource
db.initCapacity_3=10
db.minCapacity_3=10
db.maxCapacity_3=100
db.connectTimeout_3=10000
db.readTimeout_3=30000

#########################################
# DB Connectionparams for mds-soa
#########################################
# create,delete,noaction,update
db.action_4=update
db.name_4=mds-soa
db.initCapacity_4=10
db.minCapacity_4=10
db.maxCapacity_4=70
db.connectTimeout_4=10000
db.readTimeout_4=30000

2)  WLST script for datasource creation , update and delete. Let us script name : dataSourceCreate_update_delete.py

from java.io import FileInputStream
from java.util import Properties
from org.apache.log4j import *

PropertyConfigurator.configure("log4j.properties")
logger = Logger.getLogger("JDBCSetup")

# Load the properties file.
def loadProperties(fileName):
        logger.info ("Processing: " + fileName)
        properties = Properties()
        input = FileInputStream(fileName)
        properties.load(input)
        input.close()

        result= {}
        for entry in properties.entrySet(): result[entry.key] = entry.value

        return result

configfile=sys.argv[1]

properties = loadProperties(configfile)
username = properties['admin.username']
password = properties['admin.password']
url = properties['admin.url']
resources_loop = properties['resources.loop']

# Connect to Admin Server
connect(username, password, url)
adminServerName = cmo.adminServerName
logger.info( "Connected to = " + url )
logger.info( "adminServerName = " + adminServerName )

try:
        logger.info ("Give a try ...")
        domainName = cmo.name
        cd("Servers/%s" % adminServerName)
        adminServer = cmo

        def updatedbsource(dsName,dsInitCapacity,dsMinCapacity,dsMaxCapacity,dsReadTimeout,dsConnectTimeout):
          logger.info( 'Begining updatedbsource for ' + dsName )
          startTransaction()
          try:
            startTransaction()
            cd('/JDBCSystemResources/' + dsName + '/JDBCResource/' + dsName + '/JDBCConnectionPoolParams/' + dsName )
            if dsInitCapacity is not None:

              cmo.setInitialCapacity(dsInitCapacity)

            if dsMinCapacity is not None:

              cmo.setMinCapacity(dsMinCapacity)

            if dsMaxCapacity is not None:

              cmo.setMaxCapacity(dsMaxCapacity)

            if dsConnectTimeout is not None:

              cd('/JDBCSystemResources/'+dsName+'/JDBCResource/'+dsName+'/JDBCDriverParams/'+dsName+'/Properties/'+dsName)

              try:

                logger.info ( 'after destroying property oracle.net.CONNECT_TIMEOUT')

                cmo.destroyProperty(getMBean('/JDBCSystemResources/'+dsName+'/JDBCResource/'+dsName+'/JDBCDriverParams/SOADataSource/Properties/'+dsName+'/Properties/or

acle.net.CONNECT_TIMEOUT'))

                logger.info ( 'before destroying property oracle.net.CONNECT_TIMEOUT')

              except:

                pass

              try:

                cmo.createProperty('oracle.net.CONNECT_TIMEOUT')

              except:

                pass

              cd('/JDBCSystemResources/'+dsName+'/JDBCResource/'+dsName+'/JDBCDriverParams/'+dsName+'/Properties/'+dsName+'/Properties/oracle.net.CONNECT_TIMEOUT')

              logger.info ( 'Setting value for oracle.net.CONNECT_TIMEOUT:' + dsConnectTimeout)

              cmo.setValue(dsConnectTimeout)

            if dsReadTimeout is not None:

              cd('/JDBCSystemResources/'+dsName+'/JDBCResource/'+dsName+'/JDBCDriverParams/'+dsName+'/Properties/'+dsName)

              try:

                logger.info ( 'after destroying property oracle.jdbc.ReadTimeout')

                cmo.destroyProperty(getMBean('/JDBCSystemResources/'+dsName+'/JDBCResource/'+dsName+'/JDBCDriverParams/SOADataSource/Properties/'+dsName+'/Properties/or

acle.jdbc.ReadTimeout'))

                logger.info ( 'after destroying property oracle.jdbc.ReadTimeout')

              except:

                pass

              try:

                cmo.createProperty('oracle.jdbc.ReadTimeout')

              except:

                pass

              cd('/JDBCSystemResources/'+dsName+'/JDBCResource/'+dsName+'/JDBCDriverParams/'+dsName+'/Properties/'+dsName+'/Properties/oracle.jdbc.ReadTimeout')

              logger.info ( 'Setting value for oracle.jdbc.ReadTimeout:' +dsReadTimeout)

              cmo.setValue(dsReadTimeout)

            endTransaction()

          except Exception,e:

            logger.info( 'error in updatedbsource for ' + dsName + '\n' + str(e))

            pass

          logger.info( 'Ending updatedbsource for ' + dsName )

        #####################################################################

        #

        #   CsrConnectionPool : jdbc/CsrDataSource : xa

        #   Datasource classname: oracle.jdbc.xa.client.OracleXADataSource

        #   Resource Type: javax.sql.XADataSource

        #   JDBC URL: jdbc:oracle:thin:@ldohsbcmh005.oracleoutsourcing.com:10710:DBCM2O

        #   user: XRS_APP

        #   password: XRS_aPp_HLbrt01

        #

        ####################################################################

        def createdbsource(dsName,dsJNDIName,dsURL,dsPassword,dsUserName,dsTestQuery,xaType,dsTargets,nonxaTransaction,dsMaxCapacity=None,dsInitCapacity=None,dsMinCapac

ity=None,XaSetTransactionTimeout=None):

          try:

            startTransaction()

            cd('/')

            cmo.createJDBCSystemResource(dsName)

            cd('/JDBCSystemResources/' + dsName + '/JDBCResource/' + dsName)

            cmo.setName(dsName)

            cd('/JDBCSystemResources/' + dsName + '/JDBCResource/' + dsName + '/JDBCDataSourceParams/' + dsName )

            set('JNDINames',jarray.array([String('jdbc/' + dsJNDIName )], String))

            cd('/JDBCSystemResources/' + dsName + '/JDBCResource/' + dsName + '/JDBCDriverParams/' + dsName )

            cmo.setUrl(dsURL)

            if  xaType == 'xa':

              cmo.setDriverName("oracle.jdbc.xa.client.OracleXADataSource")

            if  xaType == 'nonxa':

              cmo.setDriverName("oracle.jdbc.OracleDriver")

            cmo.setPassword( dsPassword)

            cd('/JDBCSystemResources/' + dsName + '/JDBCResource/' + dsName + '/JDBCConnectionPoolParams/' + dsName )

            cmo.setTestTableName(dsTestQuery)

            if dsMaxCapacity is not None:

              logger.info ( 'setting cmo.setMaxCapacity: ' + str(dsMaxCapacity) )

              cmo.setMaxCapacity(dsMaxCapacity)

              logger.info( 'retrieved Max ' + str(cmo.getMaxCapacity()) )

            if dsMinCapacity is not None:

              logger.info ( 'setting cmo.setMinCapacity: ' + str(dsMinCapacity) )

              cmo.setMinCapacity(dsMinCapacity)

              logger.info( 'retrieved Min ' + str(cmo.getMinCapacity()) )

            if dsInitCapacity is not None:

              logger.info ( 'setting cmo.setInitialCapacity: ' + str(dsInitCapacity) )

              cmo.setInitialCapacity(dsInitCapacity)

              logger.info( 'retrieved Initial ' + str(cmo.getInitialCapacity()) )

            cd('/JDBCSystemResources/' + dsName + '/JDBCResource/' + dsName + '/JDBCDriverParams/' + dsName + '/Properties/' + dsName )

            cmo.createProperty('user')

            cd('/JDBCSystemResources/' + dsName + '/JDBCResource/' + dsName + '/JDBCDriverParams/' + dsName + '/Properties/' + dsName + '/Properties/user')

            cmo.setValue(dsUserName)

            if  xaType == 'nonxa':

              logger.info( "nonxaTransaction =  "+nonxaTransaction )

              cd('/JDBCSystemResources/' + dsName + '/JDBCResource/' + dsName + '/JDBCDataSourceParams/' + dsName )

              cmo.setGlobalTransactionsProtocol(nonxaTransaction)

            if  xaType == 'xa':

              cd('/JDBCSystemResources/' + dsName + '/JDBCResource/' + dsName + '/JDBCXAParams/' + dsName )

              logger.info( ' In XaSetTransactionTimeout processing: ' + str(XaSetTransactionTimeout) )

              if XaSetTransactionTimeout is not None:

                cmo.setXaSetTransactionTimeout(XaSetTransactionTimeout)

                logger.info( 'setting XaSetTransactionTimeout to: ' + str(XaSetTransactionTimeout) )

            logger.info ( "dsTargets =  "+dsTargets )

            targetListObj = []

            targetListStr = dsTargets.split(',')

            for targetStr in targetListStr:

              targetObj = targetStr.split(":")

              logger.info ( "targetStr="+targetStr )

              targetListObj.append(ObjectName('com.bea:Name=' + targetObj[0] + ',Type=' + targetObj[1]))

              logger.info( "targetName-targetType="+targetObj[0]+"-"+targetObj[1] )

            cd('/SystemResources/' + dsName )

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

            endTransaction()

          except:

            logger.info('Skipping create and rolling backedit')

            cancelEdit(defaultAnswer="true")

            pass

        def startTransaction():

          edit()

          startEdit()

        def endTransaction():

          save()

          activate(block="false")

        def deleteIgnoringExceptions(mbean):

          try: delete(mbean)

          except: pass

        def loopit():

          logger.info ( "loopit called unit test" )

        ########################################################################

        #         Main Controller

        ########################################################################

        #print 'Task = '+resources_loop

        logger.info ('Task = '+resources_loop )

        mylist = resources_loop.split(",")

        num = 0

        while num < len(mylist):

          num = num + 1

          action = properties['db.action'+'_'+str(num)]

          #print "Action to Perform "+action

          logger.info( "Action to Perform "+action )

          if action == 'delete':

            dbName = properties['db.name'+'_'+str(num)]

            #print "Deleting "+dbName

            logger.info( "Deleting "+dbName )

            startTransaction()

            cd("/JDBCSystemResources")

            deleteIgnoringExceptions(dbName)

            endTransaction()

            logger.info ( "Done Deleting "+dbName )

          elif action == 'update':

            dbName = properties['db.name'+'_'+str(num)]

            logger.info ("START Updating "+dbName)

            try:

                logger.info( 'processing db.initCapacity_'+str(num) )

                dbInitCapacity = int(properties['db.initCapacity'+'_'+str(num)])

                logger.info( dbInitCapacity )

            except KeyError:

                dbInitCapacity = None

                logger.info( 'no Key db.InitCapacity'+'_'+str(num) )

            try:

                logger.info( 'processing db.maxCapacity_'+str(num) )

                dbMaxCapacity = int(properties['db.maxCapacity'+'_'+str(num)])

                logger.info( dbMaxCapacity )

            except KeyError:

                dbMaxCapacity = None

                logger.info( 'no Key db.maxCapacity'+'_'+str(num) )

            try:

                logger.info( 'processing db.minCapacity_'+str(num) )

                dbMinCapacity = int(properties['db.minCapacity'+'_'+str(num)])

                logger.info( dbMinCapacity )

            except KeyError:

                dbMinCapacity = None

                logger.info( 'no Key db.minCapacity'+'_'+str(num) )

            try:

                logger.info( 'processing db.connectTimeout_'+str(num) )

                dbconnectTimeout = properties['db.connectTimeout'+'_'+str(num)]

                logger.info( dbconnectTimeout )

            except KeyError:

                dbconnectTimeout = None

                logger.info( 'no Key db.connectTimeout'+'_'+str(num) )

            try:

                logger.info( 'processing db.readTimeout_'+str(num) )

                dbreadTimeout = properties['db.readTimeout'+'_'+str(num)]

                logger.info( dbreadTimeout )

            except KeyError:

                dbreadTimeout = None

                logger.info( 'no Key db.readTimeout'+'_'+str(num))

            updatedbsource(dsName=dbName,

              dsInitCapacity=dbInitCapacity,

              dsMinCapacity=dbMinCapacity,

              dsMaxCapacity=dbMaxCapacity,

              dsReadTimeout=dbreadTimeout,

              dsConnectTimeout=dbconnectTimeout);

            exit()

            logger.info ( "END   Updating "+dbName)

          elif action == 'create':

            dbTargets = properties['db.targets'+'_'+str(num)]

            dbType = properties['db.type'+'_'+str(num)]

            jndiName = properties['db.jndiname'+'_'+str(num)]

            dbName = properties['db.name'+'_'+str(num)]

            dbURL = properties['db.url'+'_'+str(num)]

            dbUserName = properties['db.username'+'_'+str(num)]

            dbPassWord = properties['db.password'+'_'+str(num)]

            dbTransaction = properties['db.transaction'+'_'+str(num)]

            dbTest = properties['db.test.query'+'_'+str(num)]

            logger.info( "Creating "+dbName )

            try:

                logger.info ('processing db.maxCapacity_'+str(num) )

                dbMaxCapacity = int(properties['db.maxCapacity'+'_'+str(num)])

                logger.info ( dbMaxCapacity )

            except KeyError:

                dbMaxCapacity = None

                logger.info ( 'no Key db.maxCapacity'+'_'+str(num) )

            try:

                logger.info( 'processing db.initCapacity_'+str(num) )

                dbInitCapacity = int(properties['db.initCapacity'+'_'+str(num)])

                logger.info( dbInitCapacity )

            except KeyError:

                dbInitCapacity = None

                logger.info( 'no Key db.InitCapacity'+'_'+str(num) )

            try:

                logger.info( 'processing db.minCapacity_'+str(num) )

                dbMinCapacity = int(properties['db.minCapacity'+'_'+str(num)])

                logger.info( dbMinCapacity )

            except KeyError:

                dbMinCapacity = None

                logger.info( 'no Key db.minCapacity'+'_'+str(num) )

          try:

                logger.info ( 'processing db.transactionTimeout_'+str(num) )

                dbXaSetTransactionTimeout = (properties['db.xatransactionTimeout'+'_'+str(num)].lower() == "true")

                logger.info ( dbXaSetTransactionTimeout )

            except KeyError:

                dbXaSetTransactionTimeout = None

                logger.info ( 'no Key db.transactionTimeout'+'_'+str(num) )

            createdbsource(dsName=dbName,

              dsJNDIName=jndiName,

              dsURL=dbURL,

              dsPassword=dbPassWord,

              dsUserName=dbUserName,

              dsTestQuery=dbTest,

              xaType=dbType,

              dsTargets=dbTargets,

              nonxaTransaction=dbTransaction,

              dsMaxCapacity=dbMaxCapacity,

              dsInitCapacity=dbInitCapacity,

              dsMinCapacity=dbMinCapacity,

              XaSetTransactionTimeout=dbXaSetTransactionTimeout);

            logger.info( "Done Creating DataSource "+dbName )

          else:

            logger.info ( "Not Deleting or Create iteration="+str(num)+" action="+action )

except NameError, e:

        logger.info ( "Please check there is: ", sys.exc_info()[0], sys.exc_info()[1] )

        cancelEdit("n")

        raise

except:

        dumpStack()

        cancelEdit("n")

        raise

logger.info ("Disconnecting")

disconnect(force="True")

print "exit"

exit()

3) Run WLST script by invoking wlst.sh  :  wlst.sh   dataSourceCreate_update_delete.py

dataSourceCreate_update_delete.properties