One complaint I have about using PeopleSoft Images is that logging in and opening pages is very slow. Behind the scenes, the application server is caching objects as you request them. The initial cache load can take time and that leads to very slow page loads. To eliminate the cache loading and slow performance, we can run the LOADCACHE process to pre-load all of the application cache.
We will solve this problem using a short Puppet manifest that runs after the DPK is finsihed. This lets the delivered DPK build the system, then we follow along and make the performance improvements.
Before we look at the Puppet code, lets look at the LOADCACHE process and configuration.
LOADCACHE
The LOADCACHE process is an App Engine that will pre-build all of the cache files an application server needs. You run the process from the page “PeopleTools > Utilities > Administration > Load App Server Cache”. Depending on the size of your database, this may take a long time. In my HR Image 32 VM, the process only took 10 minutes. In a large Finance production system, the process ran for 3 hours.
The LOADCACHE process will build the cache files in a directory named CACHE/STAGE/stage. The contents of the stage directory can be copied (or symlinked) to your application server domain. (There is an Output Destination box on the run control page, but it does not control the output location.) The pre-built cache files must be stored under a CACHE/STAGE directory. This directory can live anywhere, but it is easiest to store the cache files under the application server domain.
Last, we need to tell our application server to use the shared cache files instead of per-process cache files. In psappsrv.cfg, set ServerCacheMode=1 and reconfigure the application server.
DPK
The steps we want to automate are this:
- Run the LOADCACHE app engine
- Create a symlink from app domain to pre-built cache
- Change
ServerCacheMode in psappsrv.cfg
- Reconfigure and start the app server domain
First, the DPK is built to handle multiple app server domains on a box, so let’s wrap our Puppet code in an appropriate loop. Create the file manifests/loadcache.pp:
#loadcache.pp
$appserver_domain_list = hiera('appserver_domain_list')
$appserver_domain_list.each | $domain_name, $app_domain_info | {
}
This code looks up our app server domains in Hiera and will iterate over each domain.
To run an app engine via the DPK, we could use the exec resource and create a command to run. There is a pt_psae custom Puppet Type that the DPK delivers and we can use this to run App Engines. BUT, there is a bug in pt_psae! It is hard-coded to only run PTEM_CONFIG (the ACM App Engine). We can fix that pretty easily. It just so happens that we the pt_psae type takes a program_id parameter and we can use that instead of the hard-coded value.
In the file production/modules/pt_config/lib/puppet/provider/psae.rb, we change the line
ae_program_name="PTEM_CONFIG"
to
ae_program_name=resource[:program_id]
To make this easier, let’s wrap this bug fix into a separate Puppet manifest so we can fix the bug on the fly. Create the file manifests/fixdpkbug.pp
#fixdpkbug.pp
$dpk_location = hiera('dpk_location')
exec { 'fix-dpk-bug':
command => "sed -i 's/ae_program_name=\"PTEM_CONFIG\"/ae_program_name=resource[:program_id]/' ${dpk_location}/puppet/production/modules/pt_config/lib/puppet/provider/psae.rb",
path => '/usr/bin',
}
Back in our loadcache.pp file, we will use the pt_psae type to call the LOADCACHE program. The type requires the database connection credentials that live in the hash db_settings:. We need to convert the hash into an array of key=value pairs first. Then we can populate the parameters for pt_psae.
#loadcache.pp
$ps_home_dir = hiera('ps_home_location')
$appserver_domain_list = hiera('appserver_domain_list')
$appserver_domain_list.each | $domain_name, $app_domain_info | {
$db_settings = $app_domain_info['db_settings']
$db_settings_array = join_keys_to_values($db_settings, '=')
$ps_cfg_home_dir = $app_domain_info['ps_cfg_home_dir']
pt_psae {"LOADCACHE-${domain_name}":
db_settings => $db_settings_array,
run_control_id => 'BUILD',
program_id => 'LOADCACHE',
os_user => 'psadm2',
logoutput => 'true',
ps_home_dir => $ps_home_dir,
}
}
Next, we need to create the symlink in our app server domain to the location where our CACHE files are created. If you run LOADCACHE through the process scheduler, the files will be built under the PS_FILEDIR specified for the scheduler. Normally, this is stored under the process scheduler domain folder. Since we are running the process through the Puppet Type (aka, command line), it will use the psadm2 user’s PS_FILEDIR location which happens to be /home/psadm2/PS_CACHE.
To create the symlink, we can use the file resource built into Puppet.
#loadcache.pp
$ps_home_dir = hiera('ps_home_location')
$appserver_domain_list = hiera('appserver_domain_list')
$appserver_domain_list.each | $domain_name, $app_domain_info | {
$db_settings = $app_domain_info['db_settings']
$db_settings_array = join_keys_to_values($db_settings, '=')
$ps_cfg_home_dir = $app_domain_info['ps_cfg_home_dir']
pt_psae {"LOADCACHE-${domain_name}":
db_settings => $db_settings_array,
run_control_id => 'BUILD',
program_id => 'LOADCACHE',
os_user => 'psadm2',
logoutput => 'true',
ps_home_dir => $ps_home_dir,
}
-> file {"${ps_cfg_home_dir}/appserv/${domain_name}/CACHE/SHARE":
ensure => link,
target => "/home/psadm2/PS_CACHE/CACHE/STAGE/stage"
}
}
Notice that we use the -> resource chain between pt_psae and file. This tells puppet that the app engine must run first before we create the symlink (so we know the folder exists).
Next, let’s update psappsrv.cfg to set the Server Cache Mode. For that, we will use an exec resource running the sed command. You could use the file_line resource as well. The file_line method would offer better multi-platform support, but the sed command is really easy to use.
#loadcache.pp
$ps_home_dir = hiera('ps_home_location')
$appserver_domain_list = hiera('appserver_domain_list')
$appserver_domain_list.each | $domain_name, $app_domain_info | {
$db_settings = $app_domain_info['db_settings']
$db_settings_array = join_keys_to_values($db_settings, '=')
$ps_cfg_home_dir = $app_domain_info['ps_cfg_home_dir']
pt_psae {"LOADCACHE-${domain_name}":
db_settings => $db_settings_array,
run_control_id => 'BUILD',
program_id => 'LOADCACHE',
os_user => 'psadm2',
logoutput => 'true',
ps_home_dir => $ps_home_dir,
}
-> file {"${ps_cfg_home_dir}/appserv/${domain_name}/CACHE/SHARE":
ensure => link,
target => "/home/psadm2/PS_CACHE/CACHE/STAGE/stage"
}
-> exec { "Set-Cache-Mode-${domain_name}":
command => "sed -i 's/^\;ServerCacheMode=0/ServerCacheMode=1/' ${ps_cfg_home_dir}/appserv/${domain_name}/psappsrv.cfg",
path => '/usr/bin',
}
}
Last, we need to reconfigure the domain. I prefer using psadmin plus to handle domain restarts because it can bundle multiple actions into a single command. We can call psadmin plus from Puppet to do our reconfiguration.
#loadcache.pp
$ps_home_dir = hiera('ps_home_location')
$gem_home = '/opt/puppetlabs/puppet/bin'
exec { 'install-psadmin_plus':
command => "${gem_home}/gem install psadmin_plus",
}
$appserver_domain_list = hiera('appserver_domain_list')
$appserver_domain_list.each | $domain_name, $app_domain_info | {
$db_settings = $app_domain_info['db_settings']
$db_settings_array = join_keys_to_values($db_settings, '=')
$ps_cfg_home_dir = $app_domain_info['ps_cfg_home_dir']
pt_psae {"LOADCACHE-${domain_name}":
db_settings => $db_settings_array,
run_control_id => 'BUILD',
program_id => 'LOADCACHE',
os_user => 'psadm2',
logoutput => 'true',
ps_home_dir => $ps_home_dir,
}
-> file {"${ps_cfg_home_dir}/appserv/${domain_name}/CACHE/SHARE":
ensure => link,
target => "/home/psadm2/PS_CACHE/CACHE/STAGE/stage"
}
-> exec { "Set-Cache-Mode-${domain_name}":
command => "sed -i 's/^\;ServerCacheMode=0/ServerCacheMode=1/' ${ps_cfg_home_dir}/appserv/${domain_name}/psappsrv.cfg",
path => '/usr/bin',
}
-> exec { "Bounce ${domain_name} App Domain":
command => "${gem_home}/psa bounce app ${domain_name}",
require => Exec['install-psadmin_plus'],
}
}
Using the exec resource, we can install psadmin plus using the gem utility. Inside our domain loop we can bounce the app server after we build our cache and reconfigure the domain.
The bounce action for psadmin plus will stop the domain, clear cache, flush the IPC resources, reconfigure the domain, then start the domain from a single command.
Running loadcache.pp
We are ready to test our new manifest. We actually have two manifests to test:
loadcache.ppfixdpkbug.pp
We need to run the fixdpkbug.pp manifest first. Since that manifest changes a line of the underlying Puppet provider code, we have to run it before we compile the Puppet catalog for our loadcache.pp run. Then, we will run the loadcache.pp manifest.
$ DPK_HOME="/opt/oracle/psft/dpk/puppet"
$ cd $DPK_HOME/production
$ sudo /opt/puppetlabs/puppet/bin/puppet apply manifests/fixdpkbug.pp --confdir $DPK_HOME
Notice: Compiled catalog for psvagabond in environment production in 0.09 seconds
Notice: /Stage[main]/Main/Exec[fix-dpk-bug]/returns: executed successfully
Notice: Applied catalog in 1.91 seconds
$ sudo /opt/puppetlabs/puppet/bin/puppet apply manifests/loadcache.pp --confdir $DPK_HOME
Notice: Compiled catalog for psvagabond in environment production in 0.15 seconds
Notice: /Stage[main]/Main/Exec[install-psadmin_plus]/returns: executed successfully
Notice: /Stage[main]/Main/Pt_psae[LOADCACHE-psftdb]/returns: PeopleTools 8.57.08 - Application Engine
Notice: /Stage[main]/Main/Pt_psae[LOADCACHE-psftdb]/returns: Copyright (c) 1988-2019 Oracle and/or its affiliates.
Notice: /Stage[main]/Main/Pt_psae[LOADCACHE-psftdb]/returns: All Rights Reserved
Notice: /Stage[main]/Main/Pt_psae[LOADCACHE-psftdb]/returns:
Notice: /Stage[main]/Main/Pt_psae[LOADCACHE-psftdb]/returns: Application Engine program LOADCACHE ended normally
Notice: /Stage[main]/Main/Pt_psae[LOADCACHE-psftdb]/returns: executed successfully
Notice: /Stage[main]/Main/Exec[Set-Cache-Mode-psftdb]/returns: executed successfully
Notice: /Stage[main]/Main/Exec[Bounce psftdb App Domain]/returns: executed successfully
Notice: Applied catalog in 594.46 seconds
To verify that your application servers are using the shared cache, open your APPSRV_mmdd.LOG file and look for these lines:
Cache Directory being used: /home/psadm2/psft/pt/8.57/appserv/psftdb/CACHE/SHARE/
When you log into your PeopleSoft Image, all of the pages will load faster than before.
Vagabond and Automated Builds
This change as been added to the ps-vagabond project. If you build your PeopleSoft Images with Vagabond, you can pull down the lastest changes in the master branch. If you want to see how to integrate these manifests into your PeopleSoft Image builds, you can look at this provisioning script.
The two files are shared as Gists in Github, you can freely use them:
UPDATE: I created an Idea for this on the PeopleSoft Idea Space. Go vote for this if you want to see this included in future PeopleSoft Images.
