Index by: file name |
procedure name |
procedure call |
annotation
installApp_proc.tcl
(annotations | original source)
####################################################################
# Install App.
####################################################################
# Patrick Finnegan 15/02/2005. V1.
####################################################################
namespace eval installApp {
proc installApp { propertiesFile earFile } {
global AdminConfig
global AdminTask
global AdminApp
global AdminControl
# display procedure arguments.
set procName [ lindex [ info level 0 ] 0 ]
putsLog "## proc - $procName"
foreach i [ info args $procName ] {
upvar 0 $i ilocal
set propertiesArray($i) $ilocal
}
putsLog "procedure arguments are................."
foreach { a b } [ array get propertiesArray ] {
putsLog [ format "%-35s %s" "$a" "$b" ]
}
# get and display the existing applicatons.
putsLog "existing applications are:............"
set apps [ $AdminApp list ]
if { [ catch { $AdminApp list } r ] == 0 } {
set appList $r
if { $appList == {} } {
putsLog "no existing applications"
set noApps "true"
} else {
set noApps "false"
foreach i $appList {
putsLog [ format "%-5s %s" " " $i ]
}
}
} else {
return -code error $r
}
# call the hashMapList proc which returns a sorted list from the Property object loaded from the properties file.
putsLog "new Application properties are:............"
if { [ catch { hashMapList $propertiesFile } r ] == 0 } {
set propertiesList $r
foreach a $propertiesList {
putsLog [ format "%-5s %-50s %-s" " " [ lindex $a 0 ] [ lindex $a 1 ] ]
}
} else {
return -code error $r
}
# call the hashMap proc which returns a Property object populated with property file values.
if { [ catch { hashMap $propertiesFile } r ] == 0 } {
variable PropertyI $r
} else {
return -code error $r
}
# check if the application already exists. If so delete.
# the application name is set to the root part of the ear file name.
set appName [ file root [ file tail $earFile ] ]
if { $noApps != true } {
if { [ lsearch -glob $apps $appName ] == -1 } {
putsLog "$appName is not installed"
} else {
putsLog "deleting $appName ..............."
if { [ catch { $AdminApp uninstall $appName } r ] == 0 } {
putsLog "$appName deleted successfully"
}
}
}
variable serverName [ string trim [ $PropertyI getProperty serverName ] ]
# determine if the target environmentis a server or cluster.
# Admin config returns null if the server does not exist.
if { [ catch { $AdminConfig getid /ServerCluster:$serverName/ } r ] == 0 } {
if { $r == {} } {
if { [ catch { $AdminConfig getid /Server:$serverName/ } r ] == 0 } {
if { $r == {} } {
putsLog "ERROR: $serverName does not exist as a cluster or server"
return -code error $r
} else {
variable serverIsCluster "false"
putsLog "Deployment target is server: $r"
}
}
} else {
putsLog "Deployment target is cluster: $r"
variable serverIsCluster "true"
}
}
set serverId $r
# check for web module definitions
# 23/04/2007 After running this code on lot's of different installations
# I realized that most apps and their modules are deployed to a single
# virtual host i.e the # virtual host mappings just need to default to
# the cluster/server/virtual host name supplied by the properties file.
# If the deployment is to a cluster the individual web module to server
# mappings are not required but they are required for a single server
# installation. Procs that mapped the individual web modules to virtual
# hosts now just write the output to the log for information only but
# can easily be adapted to explicitly map the modules if required.
# use taskInfo to scan the EAR for mappable resources.
# display virtual host mappings.
set output [ $AdminApp taskInfo $earFile MapWebModToVH ]
set searchString "webModule:"
set matchString "virtualHost"
putsLog "Virtual host modules are ............"
displayModList $output $searchString $matchString
# display server mappings and return the mapping details.
set output [ $AdminApp taskInfo $earFile MapModulesToServers ]
set searchString "module:"
set matchString "server"
putsLog "Web modules are ............"
set resRefList [ displayModList $output $searchString $matchString ]
# if the web module to server mappings exist AND the deployment is to a
# server rather than a cluster set up the server mappings in the correct
# format.
if { $resRefList != {} && $serverIsCluster == "false" } {
set serverModList [ mapServerMod $PropertyI $resRefList ]
}
# display EJB resource references and return the mapping details.
set output [ $AdminApp taskInfo $earFile MapResRefToEJB ]
set searchString "module:"
set matchString "MapResRefToEJB"
putsLog "EJB Resource References are: ............"
set resRefList [ displayModList $output $searchString $matchString ]
# if EJB resource refs exist map the EJB resource references to the datasource JNDI reference.
# NB we assume that the JNDI reference in the EAR will be overridden by the supplied JNDI reference.
# NB the JNDI reference must exist in the DM cell or the deployment will fail with "WASX7111E: Cannot find a match for supplied option"
if { $resRefList == {} } {
set continue true
} else {
set ejbResRefList [ MapResRefToEJB $PropertyI $resRefList ]
}
set groupRoleList [ getRoleMappings $propertiesList ]
# The installApplication proc is called with a variable number of
# arguments depending on the options we set for the install app command.
# Create the install options list using the available options. As
# mentioned above application modules are not individually mapped to
# virtual hosts or servers.
# remove an option by commenting it out.
#-MapModulesToServers $webModList
lappend optionList -appname $appName
# leading or trailing spaces can cause problems during the install. Zap them.
lappend optionList -defaultbinding.virtual.host [ string trim [ $PropertyI getProperty virtualHost ] ]
if { $serverIsCluster == "true" } {
lappend optionList -cluster $serverName
} else {
lappend optionList -server $serverName
}
if { [ info exist serverModList ] == 1 } {
lappend optionList -MapModulesToServers $serverModList
}
if { [ info exist ejbResRefList ] == 1 } {
lappend optionList -MapResRefToEJB $ejbResRefList
}
if { $groupRoleList == {} } {
set continue true
} else {
lappend optionList -MapRolesToUsers $groupRoleList
}
#lappend optionList -contextroot $contextRoot
lappend optionList -noreloadEnabled
#lappend optionList -preCompileJSPs
lappend optionList -verbose
if { [ catch { installApplication $earFile $optionList } r ] == 0 } {
putsLog "$appName installed successfully"
putsLog $r
} else {
putsLog "ERROR: $appName failed to install"
return -code error $r
}
if { [ catch { modifyEnterpriseApp $PropertyI $appName } r ] == 0 } {
putsLog "$appName properties modifiled successfully"
putsLog $r
} else {
putsLog "ERROR: failed to modify $appName proerties"
return -code error $r
}
}
####################################################################
# Set application properties.
####################################################################
proc setAppProperties { PropertyI propertiesList } {
global serverName
global AdminConfig
set procName [ lindex [ info level 0 ] 0 ]
putsLog "## proc - $procName"
foreach i [ info args $procName ] {
upvar 0 $i ilocal
set propertiesArray($i) $ilocal
}
putsLog "properties are.................."
foreach { a b } [ array get propertiesArray ] {
putsLog [ format "%-35s %s" "$a" "$b" ]
}
# build role mapping list.
# the Active Directory roles are keyed on application roles on a many to one relationship.
# extract the unique application roles and then match the Active Directory roles to the keys.
}
####################################################################
# Get the role mappings.
# Some applications may not have role mappings. If so return null.
####################################################################
proc getRoleMappings { propertiesList } {
set procName [ lindex [ info level 0 ] 0 ]
putsLog "## proc - $procName"
foreach i [ info args $procName ] {
upvar 0 $i ilocal
set propertiesArray($i) $ilocal
}
putsLog "properties are.................."
foreach { a b } [ array get propertiesArray ] {
putsLog [ format "%-35s %s" "$a" "$b" ]
}
# build role mapping list.
# the Active Directory roles are keyed on application roles on a many to one relationship.
# extract the unique application roles and then match the Active Directory roles to the keys.
# get the list of the application roles.
foreach i $propertiesList {
# extract the app roles
if { [ lsearch -glob [ string toupper [ join $i ] ] "*ROLE*" ] != -1 } {
lappend appRoles [ lindex [ lindex $i 1 ] 0 ]
}
# extract the user app role to AD user mappings
if { [ lsearch -glob [ string toupper [ join $i ] ] "*USERROLE*" ] != -1 } {
lappend userAppRolesKeyed [ list [ lindex $i 0 ] [ lindex [ lindex $i 1 ] 0 ] [ lindex [ lindex $i 1 ] 1 ] ]
}
# extract the group app roles to AD group mappings
if { [ lsearch -glob [ string toupper [ join $i ] ] "*GROUPROLE*" ] != -1 } {
lappend groupAppRolesKeyed [ list [ lindex $i 0 ] [ lindex [ lindex $i 1 ] 0 ] [ lindex [ lindex $i 1 ] 1 ] ]
}
}
# if there are no roles return.
if { [ info exist appRoles ] == 0 } {
putsLog "***** no roles defined for the application *****"
return
}
# delete the duplicate entries from the app roles list.
set templist {}
foreach item $appRoles {
if { [ lsearch $templist $item ] == -1 } {
lappend templist $item
}
}
# sort roles
set appRoles [ lsort $templist ]
# build the user roles and group roles list.
foreach i $appRoles {
foreach e $userAppRolesKeyed {
if { [ lsearch -glob $e "*$i*" ] != -1 } {
set user [ lindex $e 2 ]
append users $user|
}
}
foreach e $groupAppRolesKeyed {
if { [ lsearch -glob $e "*$i*" ] != -1 } {
set group [ lindex $e 2 ]
append groups $group|
}
}
lappend usersGroupRoleList [ list "$i" no no "$users" "$groups" ]
unset users
unset groups
}
return $usersGroupRoleList
}
####################################################################
# Get the web module list.
####################################################################
proc displayModList { output searchString matchString } {
global AdminConfig
global AdminControl
global AdminApp
variable serverName
variable serverIsCluster
variable PropertyI
set procName [ lindex [ info level 0 ] 0 ]
putsLog "## proc - $procName"
foreach i [ info args $procName ] {
upvar 0 $i ilocal
set propertiesArray($i) $ilocal
}
#putsLog "properties are.................."
#foreach { a b } [ array get propertiesArray ] {
# #putsLog [ format "%-35s %s" "$a" "$b" ]
#}
if { [ string first $searchString $output ] == -1 } {
putsLog "No $matchString host definitions in EarFile"
return
}
#get local mapping targets. These over-ride targets defined in the ear/war.
set localJndi [ string trim [ $PropertyI getProperty jndi ] ]
set localVirtualHost [ string trim [ $PropertyI getProperty virtualHost ] ]
# truncate the leading section of the output string.
set moduleStart [ string first $searchString $output ]
set outputString [ string replace $output 0 [ expr { $moduleStart -1 } ] ]
#chop the output string up into clumps delimited by "module:"
while { 1 } {
if { [ string first $searchString $outputString 8 ] == -1 } {
set moduleBody [ string range $outputString 0 end ]
lappend moduleList $moduleBody
break
} else {
set moduleEnd [ expr [ string first $searchString $outputString 8 ] -1 ]
set moduleBody [ string range $outputString 0 $moduleEnd ]
}
lappend moduleList $moduleBody
set outputString [ string replace $outputString 0 $moduleEnd ]
}
# split the list then flatten by newline.
set moduleList [ eval concat [ split $moduleList \n ] ]
foreach i $moduleList {
switch -exact -- $matchString {
MapResRefToEJB {
regexp {.+: ([^ ]+) EJB:([ ]|[ ][^ ]+[ ])uri: ([^ ]+) .+: ([^ ]+) .+: ([^ ]+) JNDI: ([^ ]+)} $i a module ejb uri referenceBinding resRefType JNDI
putsLog [ format "%-5s %-20s %-s" " " "module:" [ string trim $module ] ]
putsLog [ format "%-10s %-20s %-s" " " "EJB:" [ string trim $ejb ] ]
putsLog [ format "%-10s %-20s %-s" " " "uri:" [ string trim $uri ] ]
putsLog [ format "%-10s %-20s %-s" " " "referenceBinding:" [ string trim $referenceBinding ] ]
putsLog [ format "%-10s %-20s %-s" " " "resRefType:" [ string trim $resRefType ] ]
putsLog [ format "%-10s %-20s %-s" " " "JNDI:" $localJndi ]
# set up the resource ref list for later mapping
set module [ list module [ string trim $module ] ]
set ejb [ list ejb [ string trim $ejb ] ]
set uri [ list uri [ string trim $uri ] ]
set referenceBinding [ list referenceBinding [ string trim $referenceBinding ] ]
set resRefType [ list resRefType [ string trim $resRefType ] ]
set jndi [ list jndi $localJndi ]
lappend resRefList [ list $module $ejb $uri $referenceBinding $resRefType $jndi ]
unset module
unset ejb
unset uri
unset referenceBinding
unset resRefType
unset JNDI
}
virtualHost {
regexp {.+:(.+)uri: ([^ ]+) .+: ([^ ]+)} $i a module uri target
putsLog [ format "%-5s %-10s %-s" " " "module:" [ string trim $module ] ]
putsLog [ format "%-10s %-10s %-s" " " "uri: " [ string trim $uri ] ]
#putsLog [ format "%-10s %-10s %-s" " " "target:" [ string trim $target ] ]
putsLog [ format "%-10s %-10s %-s" " " "target:" $localVirtualHost ]
unset module
unset uri
unset target
}
server {
regexp {.+:(.+)uri: ([^ ]+) .+: ([^ ]+)} $i a module uri target
putsLog [ format "%-5s %-10s %-s" " " "module:" [ string trim $module ] ]
putsLog [ format "%-10s %-10s %-s" " " "uri: " [ string trim $uri ] ]
putsLog [ format "%-10s %-10s %-s" " " "target:" $serverName ]
# if the target deployment environment is a server and not a cluster return the mappings.
if { $serverIsCluster == "true" } {
set continue true
} else {
set module [ list module [ string trim $module ] ]
set uri [ list uri [ string trim $uri ] ]
set target [ list target [ string trim $serverName ] ]
lappend resRefList [ list $module $uri $target ]
}
unset module
unset uri
unset target
}
default {
putsLog [ format "%-5s %-s" " " "####### no match #########" ]
}
}
}
if { [ info exist resRefList ] == 1 } {
return $resRefList
}
}
####################################################################
# Get the map web module to server list.
####################################################################
proc mapServerMod { PropertyI resRefList } {
global AdminControl
global AdminConfig
variable serverName
set procName [ lindex [ info level 0 ] 0 ]
putsLog "## proc - $procName"
foreach i [ info args $procName ] {
upvar 0 $i ilocal
set propertiesArray($i) $ilocal
}
putsLog "properties are.................."
foreach { a b } [ array get propertiesArray ] {
putsLog [ format "%-35s %s" "$a" "$b" ]
}
set cellName [ $AdminControl getCell ]
# get the node name for the target server
if { [ catch { $AdminConfig getid /Server:$serverName/ } r ] == 0 } {
set serverId $r
} else {
putsLog "ERROR: $serverName does not exist"
return -code error $r
}
regexp {(.*nodes\/)(.*)(\/servers.*)} $serverId a b c d
set nodeId [ $AdminConfig getid /Node:$c/ ]
set nodeName [ $AdminConfig showAttribute $nodeId name ]
set serverString "WebSphere:cell=$cellName,node=$nodeName,server=$serverName"
foreach i $resRefList {
array set moduleArray [ eval concat $i ]
lappend resRefReturnList [ list $moduleArray(module) $moduleArray(uri) $serverString ]
}
return $resRefReturnList
}
####################################################################
# Get the resource reference list.
####################################################################
proc MapResRefToEJB { PropertyI resRefList } {
global AdminControl
set procName [ lindex [ info level 0 ] 0 ]
putsLog "## proc - $procName"
foreach i [ info args $procName ] {
upvar 0 $i ilocal
set propertiesArray($i) $ilocal
}
putsLog "properties are.................."
foreach { a b } [ array get propertiesArray ] {
putsLog [ format "%-35s %s" "$a" "$b" ]
}
set jndi [ string trim [ $PropertyI getProperty jndi ] ]
set jndiNet [ string trim [ $PropertyI getProperty jndiNet ] ]
# use the wild card mapping set the
foreach i $resRefList {
#puts " i = $i"
array set moduleArray [ eval concat $i ]
append mappingString $moduleArray(module)
append mappingString " .* .* .* .* "
#append mappingString $moduleArray(jndi)
if { $moduleArray(resRefType) == "javax.sql.DataSource" } {
append mappingString $jndi
} elseif { $moduleArray(resRefType) == "java.net.URL" } {
append mappingString $jndiNet
} else {
append mappingString $moduleArray(jndi)
}
lappend resRefReturnList $mappingString
puts $mappingString
unset mappingString
}
return $resRefReturnList
}
####################################################################
# Install the applicaton.
####################################################################
proc installApplication { earFile optionList } {
global AdminApp
global AdminControl
set procName [ lindex [ info level 0 ] 0 ]
putsLog "## proc - $procName"
foreach i [ info args $procName ] {
upvar 0 $i ilocal
set propertiesArray($i) $ilocal
}
putsLog "properties are.................."
foreach { a b } [ array get propertiesArray ] {
putsLog [ format "%-35s %s" "$a" "$b" ]
}
if { [ catch { $AdminApp install $earFile $optionList } result_var] == 0 } {
putsLog $result_var
#putsLog "$appName deployed sucessfully"
} else {
putsLog $result_var
#putsLog "ERROR: $appName failed to deploy"
return -code error $result_var
}
}
######################################################
# Proc - modify enterprise app.
# Modify the enterprise app settings after the application has been installed.
######################################################
proc modifyEnterpriseApp { PropertyI appName } {
global AdminConfig
global AdminApp
global AdminControl
set procName [ lindex [ info level 0 ] 0 ]
putsLog "## proc - $procName"
foreach i [ info args $procName ] {
upvar 0 $i ilocal
set propertiesArray($i) $ilocal
}
putsLog "properties are.................."
foreach { a b } [ array get propertiesArray ] {
putsLog [ format "%-35s %s" "$a" "$b" ]
}
set appId [ $AdminConfig getid /Deployment:$appName ]
if { $appId == {} } {
putsLog "ERROR: $appName is not installed"
return -code error
}
# get deployed object characteristics.
set depObject [ $AdminConfig showAttribute $appId deployedObject ]
# set new attributes.
set aArray(newWarClassLoaderPolicy) [ $PropertyI getProperty classLoader.newWarClassLoaderPolicy ]
set aArray(newWarClassLoaderMode) [ $PropertyI getProperty classLoader.newWarClassLoaderMode ]
set aArray(reloadEnabled) [ $PropertyI getProperty classLoader.reloadEnabled ]
set aArray(classloaderAttr) [ $PropertyI getProperty classLoader.classloaderAttr ]
set aArray(newAllowSerializedSessionAccess) [ $PropertyI getProperty sessionManagement.newAllowSerializedSessionAccess ]
set aArray(newAccessSessionOnTimeOut) [ $PropertyI getProperty sessionManagement.newAccessSessionOnTimeOut ]
set aArray(newMaxWaitTime) [ $PropertyI getProperty sessionManagement.newMaxWaitTime ]
set aArray(allowOverflow) [ $PropertyI getProperty sessionManagement.allowOverflow ]
set aArray(invalidationTimeout) [ $PropertyI getProperty sessionManagement.invalidationTimeout ]
set aArray(maxInMemorySessionCount) [ $PropertyI getProperty sessionManagement.maxInMemorySessionCount ]
# modify the class loader attributes
set classloaderId [ $AdminConfig showAttribute $depObject classloader ]
if { [ catch { $AdminConfig modify $classloaderId [ list $aArray(classloaderAttr) ] } r ] == 0 } {
putsLog "Class loader properties are............."
set classloaderProps [ $AdminConfig showAttribute $classloaderId mode ]
putsLog [ format "%-5s %s" " " $classloaderProps ]
} else {
putsLog "ERROR: failed to modify class loader properties"
return -code error $r
}
#modify the war classloader proerties
set attributes [ list $aArray(newWarClassLoaderPolicy) \
$aArray(reloadEnabled) \
]
if { [ catch { $AdminConfig modify $depObject $attributes } r ] == 0 } {
# puts $result_var
set warClassLoader [ $AdminConfig showAttribute $depObject warClassLoaderPolicy ]
set reloadEnabled [ $AdminConfig showAttribute $depObject reloadEnabled ]
set reloadInterval [ $AdminConfig showAttribute $depObject reloadInterval ]
putsLog "WAR class loader properties are............."
putsLog [ format "%-5s %s" " " $warClassLoader ]
putsLog [ format "%-5s %s" " " $reloadEnabled ]
putsLog [ format "%-5s %s" " " $reloadInterval ]
} else {
putsLog "ERROR: $appName - Modification failed"
return -code error $r
}
#modify the war classloader mode
# WAS 6.1 only. Commented out for WAS 5.1.
set moduleList [ $AdminConfig showAttribute $depObject modules ]
#foreach i $moduleList {
# if { [ catch { $AdminConfig modify $i [ list $aArray(newWarClassLoaderMode) ] } r ] == 0 } {
# putsLog "new war module classloader mode is............."
# set newWarClassLoaderMode [ $AdminConfig showAttribute $i classloaderMode ]
# putsLog [ format "%-5s %s" " " $newWarClassLoaderMode ]
# } else {
# putsLog "ERROR: failed to modify war classloader mode properties"
# return -code error $r
# }
#}
# modify the session parameters
set tuningParamsList [ list $aArray(allowOverflow) \
$aArray(invalidationTimeout) \
$aArray(maxInMemorySessionCount) \
]
set tuningParams [ list tuningParams $tuningParamsList ]
set sessionManagerAttr [ list $aArray(newAllowSerializedSessionAccess) \
$aArray(newAccessSessionOnTimeOut) \
$aArray(newMaxWaitTime) \
$tuningParams \
]
set newSessionManagement [ list [ list sessionManagement $sessionManagerAttr ] ]
if { [ catch { $AdminConfig create ApplicationConfig $depObject $newSessionManagement } r ] == 0 } {
putsLog "New Session Manager Attributes for $appName are:"
foreach i $sessionManagerAttr {
foreach { a b } $i {
putsLog [ format "%-5s %-30s %s" " " $a $b ]
}
}
} else {
putsLog "ERROR: failed to modify class loader properties"
return -code error $r
}
}
}
Index by: file name |
procedure name |
procedure call |
annotation
File generated 2007-08-07 at 13:42.