在主环境完成日常维护后，每天从主环境克隆到备用环境

Windows 脚本

通过复制以下 PowerShell 脚本来创建 dailyclone.ps1。

# Clone Environment script
#
# Update the following parameters
# -------------------------------
$users_and_predefined_roles="false"
$daily_maintenance_start_time="true"
$data_management="true"
$app_audit="true"
$job_console="true"
$stored_snapshots_and_files="false"
# -------------------------------

$source_username=$args[0]
$source_password=$args[1]
$source_url=$args[2]
$target_username=$args[3]
$target_password=$args[4]
$target_url=$args[5]

if ($($args.count) -ne 6) {
    echo "Usage: ./dailyclone.ps1 <SOURCE USERNAME> <SOURCE PASSWORD> <SOURCE URL> <TARGET USERNAME> <TARGET PASSWORD> <TARGET URL>"
    exit 1
}

$amw_time=""

function getDailyMaintenanceStartTime {
    $amwstring=$(epmautomate.bat getDailyMaintenanceStartTime)
    $elements=$amwstring.split(' ')
    $amwtime=$elements[0]
    return $amwtime
}

function goToSleep ($amw_time){
    $current_mdy=Get-Date -AsUTC -UFormat "%m/%d/%Y"
    $current_date_time=Get-Date -AsUTC -UFormat "%m/%d/%Y %H:%M:%S"
    $current_epoch=Get-Date -Date $current_date_time -UFormat "%s"
    $target_date_time=[DateTime]"${current_mdy} ${amw_time}"
    $target_epoch=Get-Date -Date $target_date_time -UFormat "%s"
    $sleep_seconds=$target_epoch - $current_epoch

    # Today's AMW start time has already passed, so add 24 hours to sleep_seconds
    if ($sleep_seconds -lt 0) {
        $sleep_seconds=$sleep_seconds + 86400
    }

    $sleep_ts=New-TimeSpan -Seconds ${sleep_seconds}
    $sleep_hms="${sleep_ts}" -replace '^\d+?\.'

    echo "Current time is ${current_date_time}. Sleeping for ${sleep_hms}, until daily maintenance start time of ${amw_time}."
    Start-Sleep -Seconds $sleep_seconds
}

function deleteArtifactSnapshotIfExists {
    if (artifactSnapshotExists) {
        $command_del=$(epmautomate.bat deletefile "Artifact Snapshot")
    }
}

function artifactSnapshotExists {
    $filelist=$(epmautomate.bat listfiles)
    if ("$filelist".contains("Artifact Snapshot")) {
        return $true
    else
        return $false
    }
}

function cloneEnvironment {
    echo "Checking to see if daily maintenance processing has completed ..."
    while ($true) {
        if (artifactSnapshotExists) {
            echo "Daily maintenance processing has completed ..."
            break
        } else {
            echo "Sleeping for 30 seconds before the next check to see if daily maintenance processing has completed ..."
            Start-Sleep -Seconds 30
        }
    }

    echo "Encrypting target password ..."
    epmautomate.bat encrypt "${target_password}" "oracleKey" "target_password.epw"

    echo "Cloning environment ..."
    epmautomate.bat cloneEnvironment "${target_username}" "target_password.epw" "${target_url}" "SnapshotName=Artifact Snapshot" "UsersAndPreDefinedRoles=${users_and_predefined_roles}" "DataManagement=${data_management}" "appAudit=${app_audit}" "jobConsole=${job_console}" "storedSnapshotsAndFiles=${stored_snapshots_and_files}" "dailyMaintenanceStartTime=${daily_maintenance_start_time}"
}

echo "Beginning clone environment script."
echo "Logging into server ..."
epmautomate.bat login ${source_username} ${source_password} ${source_url}
$amwtime=getDailyMaintenanceStartTime
goToSleep ($amwtime)
deleteArtifactSnapshotIfExists
cloneEnvironment
echo "Logging out of server ..."
epmautomate.bat logout
echo "Clone environment script processing has completed."

Linux/UNIX 脚本

通过复制以下脚本来创建 dailyclone.sh。

#!/bin/bash

# Update the following parameters
# -------------------------------
epmautomatescript="LOCATION_EPM_AUTOMATE_EXECUTABLE"
javahome="LOCATION_JAVA_HOME"
users_and_predefined_roles="false"
data_management="true"
app_audit="true"
job_console="true"
stored_snapshots_and_files="false"
daily_maintenance_start_time="true"
# -------------------------------

source_username="$1"
source_password="$2"
source_url="$3"
target_username="$4"
target_password="$5"
target_url="$6"

export JAVA_HOME=${javahome}

if [ "$#" -ne 6 ]; then
    echo "Usage: ./dailyclone.sh SOURCE_USERNAME SOURCE_PASSWORD SOURCE_URL TARGET_USERNAME TARGET_PASSWORD TARGET_URL"
    exit 1
fi

amw_time=""

getDailyMaintenanceStartTime() {
    amw_time=$(${epmautomatescript} getDailyMaintenanceStartTime | cut -d' ' -f1)
}

goToSleep() {
    current_mdy=$(date -u +%m/%d/%Y)
    current_date_time=$(date -u)
    current_epoch=$(date +%s)
    target_epoch=$(date -d "${current_mdy} ${amw_time}" +%s)
    sleep_seconds=$(($target_epoch - $current_epoch))

    # Today's AMW start time has already passed, so add 24 hours to sleep_seconds
    if [[ ${sleep_seconds} -lt 0 ]]
    then
        sleep_seconds=$((sleep_seconds + 86400))
    fi

    sleep_hms=$(date -d@${sleep_seconds} -u +%H:%M:%S)

    echo "Current time is ${current_date_time}. Sleeping for ${sleep_hms}, until daily maintenance start time of ${amw_time}."
    sleep $sleep_seconds
}

deleteArtifactSnapshotIfExists() {
    found=1
    filelist=$(${epmautomatescript} listfiles)
    if [[ ${filelist} == *"Artifact Snapshot"* ]]
    then
        command_del=$(${epmautomatescript} deletefile "Artifact Snapshot")
    fi
}

artifactSnapshotExists() {
    found=1

    filelist=$(${epmautomatescript} listfiles)
    if [[ ${filelist} == *"Artifact Snapshot"* ]]
    then
        found=0
    else
        found=1
    fi

    echo ${found}
}

cloneEnvironment() {
    local found=1

    while true
    do
        found=$(artifactSnapshotExists)
        if [[ ${found} -eq 0 ]]
        then
            echo "Daily maintenance processing has completed ..."
            break
        else
            echo "Sleeping for 30 seconds before the next check to see if daily maintenance processing has completed ..."
            sleep 30
        fi
    done

    echo "Encrypting target password ..."
    ${epmautomatescript} encrypt "${target_password}" "oracleKey" "target_password.epw"

    echo "Cloning environment ..."
    ${epmautomatescript} cloneEnvironment "${target_username}" "target_password.epw" "${target_url}" "SnapshotName=Artifact Snapshot" "UsersAndPreDefinedRoles=${users_and_predefined_roles}" "DataManagement=${data_management}" "appAudit=${app_audit}" "jobConsole=${job_console}" "storedSnapshotsAndFiles=${stored_snapshots_and_files}" "dailyMaintenanceStartTime=${daily_maintenance_start_time}"
}

echo "Beginning clone environment script."
echo "Logging into server ..."
${epmautomatescript} login ${source_username} ${source_password} ${source_url}
getDailyMaintenanceStartTime
goToSleep
deleteArtifactSnapshotIfExists
cloneEnvironment
echo "Logging out of server ..."
${epmautomatescript} logout
echo "Clone environment script processing has completed."

Groovy 脚本

通过复制以下代码来创建 dailyclone groovy 脚本。

// Clone Environment script

// Update the following parameters
String source_username="USERNAME"
String source_password="PASSWORD!"
String source_url="URL OF THE SOURCE ENVIRONMENT"
String target_username="USERNAME"
String target_password="PASSWORD"
String target_url="URL OF THE TARGET ENVIRONMENT"
String snapshot_name="Artifact Snapshot"

// -------------------------------

// Do not update the following parameters
String users_and_predefined_roles="false"
String data_management="true"
String app_audit="true"
String job_console="true"
String stored_snapshots_and_files="false"
String daily_maintenance_start_time="true"
// -------------------------------

def LogMessage(String message) {
    def date = new Date()
    def sdf = new SimpleDateFormat("MM/dd/yyyy HH:mm:ss")
    println('[' + sdf.format(date) + '] ' + message);
}

def LogOperationStatus(EpmAutomateStatus opstatus) {
    def returncode = opstatus.getStatus()
    if (returncode != 0){
        LogMessage(opstatus.getOutput())
    }
    LogMessage('return code: ' + returncode)
}

def getDailyMaintenanceStartTime(EpmAutomate automate) {
    LogMessage("Operation: getDailyMaintenanceStartTime")
    EpmAutomateStatus amwtimestatus = automate.execute('getDailyMaintenanceStartTime')
    LogOperationStatus(amwtimestatus)
    def amwstring=(amwtimestatus.getOutput())
    def elements=amwstring.split(' ')
    def amwtime=elements[0]
    return amwtime
}

def goToSleep(String amw_time){
    def date = new Date()
    def current_mdy = new SimpleDateFormat("MM/dd/yyyy")
    def current_date_time = new SimpleDateFormat("MM/dd/yyyy HH:mm:ss")
    float current_epoch = date.getTime() / 1000
    def pattern = "MM/dd/yyyy HH:mm:ss"
    def input = current_mdy.format(date) + " " + amw_time + ":00"
    def target_date_time = Date.parse(pattern, input)
    float target_epoch = target_date_time.getTime() / 1000
    int sleep_seconds = Math.round(target_epoch - current_epoch)

    //Today's AMW start time has already passed, so add 24 hours to sleep_seconds
    if (sleep_seconds < 0) {
        sleep_seconds = sleep_seconds + 86400
    }
    
    def sleep_milliseconds = sleep_seconds * 1000
    LogMessage("Current time is " + current_date_time.format(date) + ". Sleeping until daily maintenance start time of " + amw_time + ":00.")
    sleep(sleep_milliseconds)
}

boolean artifactSnapshotExists(EpmAutomate automate,String snapshot_name) {
    LogMessage("Operation: listfiles")
    EpmAutomateStatus listfilesstatus = automate.execute('listfiles')
    String filelist=(listfilesstatus.getItemsList())
    LogOperationStatus(listfilesstatus)
    
    if (filelist.contains(snapshot_name)) {
        return true
    } else {
        return false
    }
}

def deleteArtifactSnapshotIfExists(EpmAutomate automate,String snapshot_name){
    if (artifactSnapshotExists(automate,snapshot_name)) {
        LogMessage("Operation: deletefile " + snapshot_name)
        EpmAutomateStatus deletefilestatus = automate.execute('deletefile',snapshot_name)
        LogOperationStatus(deletefilestatus)
    }
}

def waitForDailyMaintenanceToComplete(EpmAutomate automate,String snapshot_name) {
    LogMessage("Checking to see if daily maintenance processing has completed ...")
    while (true) {
        if (artifactSnapshotExists(automate,snapshot_name)) {
            LogMessage("Daily maintenance processing has completed ...")
            break
        } else {
            LogMessage("Sleeping for 30 seconds before the next check to see if daily maintenance processing has completed ...")
            sleep(30000)
        }
    }
}

LogMessage("Clone environment script processing beginning ...")

EpmAutomate automate = getEpmAutomate()

LogMessage("Operation: login " + source_username + " " + source_password + " " + source_url)
EpmAutomateStatus status = automate.execute('login',source_username,source_password,source_url)
LogOperationStatus(status)

String amwtime = getDailyMaintenanceStartTime(automate)
goToSleep (amwtime)
deleteArtifactSnapshotIfExists(automate,snapshot_name)
waitForDailyMaintenanceToComplete(automate,snapshot_name)

LogMessage("Operation: encrypt " + target_password + " oracleKey target_password.epw")
status = automate.execute('encrypt',target_password,'oracleKey','target_password.epw')
LogOperationStatus(status)

LogMessage("Operation: cloneEnvironment " + target_username + " target_password.epw " + target_url + " SnapshotName=" + snapshot_name + " UsersAndPreDefinedRoles=" + users_and_predefined_roles + " DataManagement=" + data_management + " appAudit=" + app_audit + " jobConsole=" + job_console + " storedSnapshotsAndFiles=" + stored_snapshots_and_files + " dailyMaintenanceStartTime=" + daily_maintenance_start_time)
EpmAutomateStatus cloneenvironmentstatus = automate.execute('cloneEnvironment',target_username,"target_password.epw",target_url,"SnapshotName=" + snapshot_name,"UsersAndPreDefinedRoles=" + users_and_predefined_roles,"DataManagement=" + data_management,"appAudit=" + app_audit,"jobConsole=" + job_console,"storedSnapshotsAndFiles=" + stored_snapshots_and_files,"dailyMaintenanceStartTime=" + daily_maintenance_start_time)
LogOperationStatus(cloneenvironmentstatus)

LogMessage("Operation: logout ")
status = automate.execute('logout')
LogOperationStatus(status)

LogMessage ("Clone environment script processing has completed.")

重新运行该脚本

1. 通过复制前面几节之一中的脚本来创建 dailyclone.ps1、dailyclone.sh 或 dailyclone groovy 脚本。
2. 更新脚本：

   dailyclone.sh 的更新：

   • 将 epmautomatescript 更新为 EPM Automate 可执行文件的位置。示例：epmautomatescript="/home/utils/EPMAutomate/bin/epmautomate.sh"
   • 将 javahome 更新为 EPM Automate 使用的 JDK 的安装目录。例如："/home/user1/jdk1.8.0_191"
   dailyclone.ps1 和 dailyclone.sh 的更新：
   • users_and_predefined_roles：将此值设置为 true 以克隆用户及其预定义角色分配（始终克隆访问控制组）。
   • data_management：将此值设置为 false 以不克隆数据集成记录。请注意，仅当源环境和目标环境的每月更新相同或目标环境比源环境多更新一次时，才可以克隆数据集成记录。例如，22.01 数据管理记录可以克隆到其他 22.01 环境，或者仅克隆到 22.02 环境。

     对于 Narrative Reporting 和 Oracle Enterprise Data Management Cloud 环境，忽略此项。

   • app_audit：如果不希望克隆 Planning、自由形式和 Enterprise Profitability and Cost Management 应用程序的应用程序审核数据，请将此值设置为 false。

     始终克隆 Financial Consolidation and Close 和 Tax Reporting 审核信息。

   • job_console：如果不希望克隆作业控制台数据，请将此值设置为 false。
   • stored_snapshots_and_files：如果要克隆源环境的收件箱和发件箱中顶层文件夹的内容（从不克隆子文件夹），请将此值设置为 true。
   • daily_maintenance_start_time：如果不希望将克隆的目标环境的维护开始时间重置为源环境的维护开始时间，请将此值设置为 false。
   dailyclone groovy 脚本的更新：
   • source_username 是服务管理员的用户名。身份域管理员角色是克隆用户和预定义角色所必需的。
   • source_password 是 SOURCE_USERNAME 标识的用户的密码。
   • source_url 是要克隆的环境的 URL。
   • target_username 是服务管理员的用户名。身份域管理员角色是克隆用户和预定义角色所必需的。
   • target_password 是 TARGET_USERNAME 标识的用户的密码。
   • target_URL 是目标环境的 URL。
3. 运行 dailyclone.ps1、dailyclone.sh 或 dailyclone groovy 脚本：

   Windows

   • 在命令窗口中，导航到存储 dailyclone.ps1 的文件夹。
   • 执行命令：./dailyclone.ps1 SOURCE_USERNAME SOURCE_PASSWORD SOURCE_URL TARGET_USERNAME TARGET_PASSWORD TARGET_URL。有关这些值的说明，请参阅下表。

   Table 3-7 参数说明

   参数	说明
   SOURCE_USERNAME	服务管理员的用户名。此外，此用户必须具有身份域管理员角色才能克隆用户和预定义角色。
   SOURCE_PASSWORD	SOURCE_USERNAME 标识的用户的密码。
   SOURCE_URL	要克隆的环境的 URL。
   TARGET_USERNAME	目标环境中的服务管理员的用户名。此外，此用户必须具有身份域管理员角色才能克隆用户和预定义角色。
   TARGET_PASSWORD	TARGET_USERNAME 标识的用户的密码。
   TARGET_URL	目标环境的 URL。

   Linux/UNIX
   • 在 UNIX 或 Linux shell 中，导航到存储 dailyclone.sh 的目录。
   • 执行命令：./dailyclone.sh SOURCE_USERNAME SOURCE_PASSWORD SOURCE_URL TARGET_USERNAME TARGET_PASSWORD TARGET_URL。有关这些值的说明，请参阅上表。
   Groovy

   请参阅“在不安装 EPM Automate 的情况下运行命令”。