FWD » Core Development » Conversion Tools

:: Pass all arguments to PowerShell script, run_powershell.cmd picks the PowerShell which is installed

call "%scriptdir%run_powershell.cmd" "%scriptdir%bootstrap_conversion.ps1" %*

exit /b %ERRORLEVEL%

   <!-- The PowerShell to run the .ps1 scripts with: PowerShell Core when it is installed, otherwise the

        Windows PowerShell which is preinstalled with Windows.  A .cmd wrapper is not used here, ant

        cannot exec a batch file (CreateProcess only runs a real executable), which is also why the .ps1

        scripts are passed to the interpreter instead of being exec'd directly.  Should neither spelling

        of the variable resolve, this falls back to powershell, the one always present on Windows.

        Both env.PATH and env.Path are looked at: ant names these properties after the environment

        variables as the OS reports them, and Windows spells that one "Path".  Checking only the

        uppercase name would silently build on the Windows PowerShell on a machine which does have

        PowerShell Core installed. -->

   <property environment="env" />

   <available file="pwsh.exe" filepath="${env.PATH}" property="havePowerShellCore" />

   <available file="pwsh.exe" filepath="${env.Path}" property="havePowerShellCore" />

   <condition property="ps.executable" value="pwsh" else="powershell">

      <isset property="havePowerShellCore" />

   </condition>

      <pathelement location="${fwd.lib.home}/p2j.jar"/>

      <pathelement location="${fwd.lib.home}/fwdspi.jar"/>

      <pathelement location="${fwd.lib.home}/fwdaopltw.jar"/>

      <pathelement location="${deploy.home}/lib/${appname}.jar"/>

      <pathelement location="${fwd.lib.home}/p2j.jar"/>

      <pathelement location="${fwd.lib.home}/fwdspi.jar"/>

      <pathelement location="${fwd.lib.home}/fwdaopltw.jar"/>

      <pathelement location="${deploy.home}/lib/${appname}.jar"/>

      <pathelement location="${build.home}/lib/${appname}.jar"/>

   <target name="show.classpath" description="Print the classpaths used by the java tasks.">

      <echo message="fwd.lib.home      = ${fwd.lib.home}"/>

      <echo message="deploy lib        = ${deploy.home}/lib"/>

      <echo message="compile.classpath = ${toString:compile.classpath}"/>

      <echo message="app.classpath     = ${toString:app.classpath}"/>

      <echo message="import.classpath  = ${toString:import.classpath}"/>

   </target>

      <!-- Define script path. Windows cannot execute the bash script, it uses the .ps1 counterpart. -->

      <condition property="standard.selector.name"

                 value="select_standard.ps1" else="select_standard.sh">

         <isset property="isWindows"/>

      </condition>

                location="${data.rel}/${standard.selector.name}"/>

                  failonerror="true"

                  osfamily="unix">

                <arg value="${data.rel}"/>

                <arg value="${fwd.lib.home}/p2j.jar"/>

            </exec>

            <!-- CreateProcess cannot run a .ps1 either, the interpreter is launched explicitly -->

            <exec executable="${ps.executable}"

                  outputproperty="standard.selector.result"

                  failonerror="true"

                  osfamily="windows">

                <arg value="-NoProfile"/>

                <arg value="-ExecutionPolicy"/>

                <arg value="Bypass"/>

                <arg value="-File"/>

                <arg value="${standard.selector.script}"/>

          <!-- trim, the PowerShell selector terminates its output with a CRLF -->

          <equals arg1="${standard.selector.result}" arg2="post9950" trim="true"/>

            <equals arg1="${standard.selector.result}" arg2="skip" trim="true"/>

      <exec executable="${ps.executable}" dir="${deploy.home}/server" failonerror="true" osfamily="windows">

      <exec executable="${ps.executable}" dir="." failonerror="true" osfamily="windows">

      <exec executable="${ps.executable}" failonerror="true" osfamily="windows">

   <!-- Run with -Dclasspath.debug=true to have the forked JVMs report every class they load together

        with the jar it came from.  The output is captured by the <record> log of the target.  This is

        the only way to see the jars which the Class-Path manifest of p2j.jar contributes, those are

        resolved by the JVM and never appear in the classpath itself. -->

   <condition property="classpath.log.param" value="-verbose:class" else="-Dignorethis">

      <isset property="classpath.debug"/>

   </condition>

      <echo message="app.classpath = ${toString:app.classpath}"/>

         <jvmarg value="${classpath.log.param}"/>

      <echo message="import.classpath = ${toString:import.classpath}"/>

         <jvmarg value="${classpath.log.param}"/>

#

# The Windows counterpart of select_standard.sh, kept in sync with it: Windows cannot execute the bash

# script, and the policy rules below decide which standard.df the build uses, so the two MUST agree.

#

param (

   [Parameter(Position = 0, Mandatory = $true)] [string]$DataRel,

   [Parameter(Position = 1, Mandatory = $true)] [string]$JarPath

)

Set-StrictMode -Version Latest

$ErrorActionPreference = 'Stop'

# Get version line.  Only stdout is captured, exactly as the "$(java -jar "$jar_path")" of

# select_standard.sh does; whatever java puts on stderr is left to flow into the build log.

#

# The preference is relaxed for the call: Windows PowerShell turns the stderr of a native command

# into an error record, which the $ErrorActionPreference = 'Stop' above would then make terminating,

# and a JVM which merely reports "Picked up JAVA_TOOL_OPTIONS" would fail the build.  PowerShell 7

# does not do this.

$previousPreference = $ErrorActionPreference

$ErrorActionPreference = 'Continue'

try {

   $output = (& java -jar $JarPath | Out-String).Trim()

   $javaExit = $LASTEXITCODE

}

finally {

   $ErrorActionPreference = $previousPreference

}

# the counterpart of the "set -e" of select_standard.sh, which aborts on a failing java

if ($javaExit -ne 0)

{

   [Console]::Error.WriteLine("ERROR: java -jar $JarPath failed with exit code $javaExit")

   exit 1

}

# Expect format: FWD v4.0.0_p2j_<branch>_<revision>

if ($output -notmatch '_p2j_([^_]+)_([0-9]+)')

{

   [Console]::Error.WriteLine("ERROR: Unable to parse p2j output: $output")

   exit 1

}

$branch   = $Matches[1]

$revision = [int]$Matches[2]

# Default to using post9950 update. Add policies for using older standard.df

$usePre = $false

# ---- Policy Rules ----

if ($branch -eq "trunk" -and $revision -lt 16415)

{

   $usePre = $true

}

# Policy example. Any of these should exist only until the branch is rebased to trunk_16415

#if ($branch -eq "9986c")

#{

#   $usePre = $true

#}

# ----------------------

if ($usePre)

{

   Write-Output "pre9950"

   exit 0

}

# Fallback handling uses the in-place standard.df (post9950). Tell ant 'skip'

if (!(Test-Path -LiteralPath (Join-Path $DataRel 'standard_pre9950.df') -PathType Leaf) -and

     (Test-Path -LiteralPath (Join-Path $DataRel 'standard.df') -PathType Leaf))

{

   Write-Output "skip"

   exit 0

}

Write-Output "post9950"

   use_pre=true

:: PowerShell Core when it is installed, otherwise the Windows PowerShell which is preinstalled with

:: Windows.  %%~$PATH:I expands to the full path of the file when it is found on the PATH, and to an

:: empty string when it is not.

set "psexe="

for %%I in (pwsh.exe) do if not "%%~$PATH:I" == "" set "psexe=%%~$PATH:I"

if not defined psexe set "psexe=powershell.exe"

"%psexe%" -NoProfile -ExecutionPolicy Bypass -File "%~dp0client.ps1" %*

exit /b %ERRORLEVEL%

   # an if expression, the ?: ternary operator needs PowerShell 7

   $daddress = if (Test-Path "/.dockerenv") { "0.0.0.0:" + $dport } else { $dport }

   # java writes its version banner to stderr, and Windows PowerShell turns the stderr of a native

   # command into an error record, which the $ErrorActionPreference = 'Stop' of the callers then makes

   # terminating ("NativeCommandError").  PowerShell 7 does not do this.  Relax the preference for the

   # call only, and stringify what comes back: with the streams merged the lines can arrive as error

   # records rather than as strings.

   $previousPreference = $ErrorActionPreference

   $ErrorActionPreference = 'Continue'

   try {

      $versionLines = & $JavaExecutable -version 2>&1 | ForEach-Object { "$_" }

   }

   finally {

      $ErrorActionPreference = $previousPreference

   }

   $output = $versionLines |

               # "${parts[0]}" does not index, it names a variable called 'parts[0]'

               return [int]("$($parts[0])$($parts[1])")

    Write-Host "JVM classpath for ${clientType}: $clientCp"

    Write-Host "JVM args for ${clientType}: $clientArgsStr"

#

# prepare_dir.ps1 - the Windows counterpart of prepare_dir.sh.

#

# Renders server.xml and directory.xml on the deployment machine from prepare_dir.json, which

# json_template.ps1 -d (or json_template.sh -d) produces at build time.

#

# Run this from the directory holding the templates, deploy/server, exactly as prepare_dir.sh is.

#

param (

   [switch]$o,

   [string]$f

)

Set-PSDebug -Trace 0

Set-StrictMode -Version Latest

$ErrorActionPreference = 'Stop'

function Show-Usage

{

   Write-Host "Usage: prepare_dir.ps1 [-o] [-f <json_cfg_file>]"

   Write-Host "Where:"

   Write-Host "   o = Overwrite the specified directory.xml, if it already exists."

   Write-Host "   f = Use <json_cfg_file> instead of prepare_dir.json as input."

}

$utf8NoBom = New-Object System.Text.UTF8Encoding($false)

# Property lookup which tolerates a missing key under Set-StrictMode; $cfg.$Key would throw.

function Get-Node

{

   param (

      $Object,

      [string]$Key

   )

   if ($null -eq $Object) { return $null }

   $prop = $Object.PSObject.Properties[$Key]

   if ($null -eq $prop) { return $null }

   return $prop.Value

}

function Get-Val

{

   param (

      [string]$Key,

      [string]$Default = ""

   )

   $val = Get-Node $script:cfg $Key

   if ($null -eq $val -or "$val" -eq "") { return $Default }

   return "$val"

}

# The per-database values live in a sub-object named after the database, so the lookup is two

# levels.  This used to pass "<db>.<key>" as a single property name to Select-Object, which never

# resolves against nested json and silently handed back every default: with

# prepare_dir_h2_docker.json that turned dbpath into "../db" instead of "/opt/hotel/db", and did the

# same to the collation, the users and their passwords.

function Get-SubVal

{

   param (

      [string]$SubName,

      [string]$Key,

      [string]$Default = ""

   )

   $node = Get-Node $script:cfg $SubName

   $val = Get-Node $node $Key

   if ($null -eq $val -or "$val" -eq "") { return $Default }

   return "$val"

}

# Replaces every {key} of a template with its value and writes the result.  A literal String.Replace

# and not the -replace operator: -replace is a regular expression on both sides, so a value holding

# a $ or a \ would be mangled - a database password is the obvious way to hit that.

function Expand-Template

{

   param (

      [string]$Template,

      [hashtable]$Values,

      [string]$Destination

   )

   if (!(Test-Path -LiteralPath $Template -PathType Leaf))

   {

      throw "Could not create $Destination, the template $Template was not found."

   }

   $content = [System.IO.File]::ReadAllText((Resolve-Path -LiteralPath $Template).Path)

   foreach ($key in $Values.Keys)

   {

      $content = $content.Replace("{$key}", [string]$Values[$key])

   }

   [System.IO.File]::WriteAllText($Destination, $content, $utf8NoBom)

}

if ($args -contains "-?" -or $args -contains "/?" -or $args -contains "-h")

{

   Show-Usage

   exit 1

}

$infile = if ($f) { $f } else { "prepare_dir.json" }

if (!(Test-Path -LiteralPath $infile -PathType Leaf))

{

   Write-Error "Input file not found: $infile"

   Show-Usage

   exit 1

}

$here = (Get-Location).Path

# System.IO and every native command resolve a relative path against the PROCESS working

# directory, which PowerShell's own location does not track; keep the two in step.

[Environment]::CurrentDirectory = $here

$cfg = [System.IO.File]::ReadAllText((Resolve-Path -LiteralPath $infile).Path) | ConvertFrom-Json

# Nothing below carries an application specific default any more: pkgroot used to fall back to

# "com.goldencode.hotel" and dbnames to "hotel", so a deployment whose json was missing either one

# was configured for the sample application instead of failing.

$pkgroot = Get-Val "pkgroot"

$dbnames = Get-Val "dbnames"

if ([string]::IsNullOrEmpty($pkgroot))

{

   Write-Error "No 'pkgroot' in $infile."

   exit 1

}

if ([string]::IsNullOrEmpty($dbnames))

{

   Write-Error "No 'dbnames' in $infile."

   exit 1

}

# dbnames is a comma separated string in prepare_template.json but a real json array in the

# prepare_dir_*_docker.json files; accept either.  Splitting an array on ',' joined its elements

# with a space and yielded a single bogus name.

$dbnamesNode = Get-Node $cfg "dbnames"

if ($dbnamesNode -is [System.Array])

{

   $db_array = @($dbnamesNode | ForEach-Object { "$_".Trim() } | Where-Object { $_ -ne "" })

}

else

{

   $db_array = @($dbnames -split ',' | ForEach-Object { $_.Trim() } | Where-Object { $_ -ne "" })

}

$defdatabase = $db_array[0]

$directory_xml = Get-Val "directory_xml_file" "directory.xml"

$server_xml = Get-Val "server_xml_file" "server.xml"

# The spawner default follows this host, it used to be the Linux "/opt/spawner/spawn".

$spawner_path = Get-Val "spawner_path" (Join-Path $env:ProgramData 'FWD\spawner\spawn.exe')

$client_start_dir = Get-Val "client_start_dir" (Join-Path (Split-Path $here -Parent) 'client')

$client_lib_path = Get-SubVal "appcds" "client_lib_path" "..\lib"

$webclient_appcds_archive = Get-SubVal "appcds" "webclient_appcds_archive" ""

$webclient_appcds_jvmargs = (Get-SubVal "appcds" "webclient_appcds_jvmargs" "").Replace(

                               "{archive}", $webclient_appcds_archive)

$webclient_memory = Get-Val "webclient_memory" "128m"

# The libPath node is emitted only when an AppCDS block is configured, as json_template does.

if ($null -ne (Get-Node $cfg "appcds"))

{

   $libpath_rendered = @"

          <node class="string" name="libPath">

            <node-attribute name="value" value="$client_lib_path"/>

          </node>

"@

}

else

{

   $libpath_rendered = ""

}

# Where the directory.xml ends up; a bare file name has no parent, which Join-Path rejects.

$dirParent = Split-Path -Path $directory_xml -Parent

if ([string]::IsNullOrWhiteSpace($dirParent)) { $dirParent = "." }

if (!(Test-Path -LiteralPath $dirParent -PathType Container))

{

   Write-Error "The directory holding $directory_xml does not exist: $dirParent"

   exit 1

}

$dirfile = Join-Path (Resolve-Path -LiteralPath $dirParent).Path (Split-Path -Path $directory_xml -Leaf)

if ((Test-Path -LiteralPath $dirfile) -and -not $o.IsPresent)

{

   Write-Error "Output file exists: $dirfile, and '-o' not given."

   Show-Usage

   exit 1

}

# prepare_dir.sh reaches for sudo here, and only here, when the destination is not writable.  There

# is no in-place equivalent on Windows, and self-elevating the whole script would restart it in

# system32 where none of the relative template paths below resolve, so the condition is reported

# instead and the operator re-runs from an elevated prompt.

$probe = Join-Path (Split-Path $dirfile -Parent) ".prepare_dir.probe"

try

{

   [System.IO.File]::WriteAllText($probe, "")

   Remove-Item -LiteralPath $probe -Force

}

catch

{

   Write-Error ("Cannot write to $(Split-Path $dirfile -Parent). Re-run this script from an " +

                "elevated prompt, or grant yourself write access to that directory.")

   exit 1

}

# ---------------------------------------------------------------------------------------------------

# server.xml and directory.xml

# ---------------------------------------------------------------------------------------------------

Expand-Template 'server.xml.template' @{ directory_xml_file = $directory_xml } $server_xml

# Every marker of directory.xml.template is listed. client_start_dir, libPath,

# webclient_appcds_jvmargs and webclient_memory used to be absent, so they survived into the

# generated directory.xml verbatim. admin_console_pw is deliberately left alone, json_template does

# not fill it either.

Expand-Template 'directory.xml.template' @{

   spawner_path             = $spawner_path

   client_start_dir         = $client_start_dir

   libPath                  = $libpath_rendered

   dateFormat               = (Get-Val "dateFormat" "mdy")

   numberGroupSep           = (Get-Val "numberGroupSep" ",")

   numberDecimalSep         = (Get-Val "numberDecimalSep" ".")

   p2j_entry                = (Get-Val "p2j_entry" "start.p")

   pkgroot                  = $pkgroot

   propath                  = (Get-Val "propath" ".")

   search_path              = (Get-Val "search_path" ".")

   path_separator           = (Get-Val "path_separator" ";")

   file_separator           = (Get-Val "file_separator" "\")

   case_sensitive           = (Get-Val "case_sensitive" "FALSE")

   os_user                  = (Get-Val "os_user" $env:USERNAME)

   kbd_layout               = (Get-Val "kbd_layout" "US")

   dbname                   = $defdatabase

   server_log               = (Get-Val "server_log" "../logs")

   client_log               = (Get-Val "client_log" "../logs")

   embedded_host            = (Get-Val "embedded_host" "localhost")

   admin_port               = (Get-Val "admin_port" "7443")

   webclient_appcds_jvmargs = $webclient_appcds_jvmargs

   webclient_memory         = $webclient_memory

} 'directory_tmp.xml'

# ---------------------------------------------------------------------------------------------------

# Merge each database into the directory

# ---------------------------------------------------------------------------------------------------

$dbdialect = @{

   h2       = "com.goldencode.p2j.persist.dialect.P2JH2Dialect"

   postgres = "com.goldencode.p2j.persist.dialect.P2JPostgreSQLDialect"

}

$dbdriver = @{

   h2       = "org.h2.Driver"

   postgres = "org.postgresql.Driver"

}

$fwd_lib = if ($env:FWD_LIB) { $env:FWD_LIB } else { "../../p2j" }

$p2j_jar = if (Test-Path -LiteralPath "$fwd_lib/build/lib/p2j.jar") { "$fwd_lib/build/lib/p2j.jar" }

           elseif (Test-Path -LiteralPath "$fwd_lib/lib/p2j.jar")   { "$fwd_lib/lib/p2j.jar" }

           else                                                     { "../../p2j/lib/p2j.jar" }

foreach ($db in $db_array)

{

   $dbtype = Get-SubVal $db "dbtype" "h2"

   if ($dbtype -eq "none")

   {

      Copy-Item -LiteralPath 'directory_nodb.xml.template' -Destination 'directory_nodb.xml' -Force

      continue

   }

   if (-not $dbdialect.ContainsKey($dbtype))

   {

      throw "Unsupported database type '$dbtype' for '$db'."

   }

   $dbhost = Get-SubVal $db "dbhost" "localhost"

   $dbport = Get-SubVal $db "dbport" "5432"

   $dbpath = Get-SubVal $db "dbpath" "../db"

   $pljava = if ($dbtype -eq "h2") { "TRUE" } else { "FALSE" }

   $jdbc_url = if ($dbtype -eq "h2")

               {

                  "h2:$dbpath/$db;DB_CLOSE_DELAY=-1;MV_STORE=FALSE;RTRIM=TRUE"

               }

               else

               {

                  "postgresql://${dbhost}:${dbport}/$db"

               }

   $dbfile = "directory_db.xml.$db"

   Expand-Template 'directory_db.xml.template' @{

      dbhost        = $dbhost

      dbport        = $dbport

      dbname        = $db

      dbuser        = (Get-SubVal $db "dbuser" "fwd_user")

      dbuserpass    = (Get-SubVal $db "dbuserpass" "user")

      dbadmin       = (Get-SubVal $db "dbadmin" "fwd_admin")

      dbadminpass   = (Get-SubVal $db "dbadminpass" "admin")

      dbdialect     = $dbdialect[$dbtype]

      dbdriver      = $dbdriver[$dbtype]

      max_c3p0_pool = (Get-SubVal $db "max_c3p0_pool" "20")

      dbpath        = $dbpath

      jdbc_url      = $jdbc_url

      pljava        = $pljava

      collation     = (Get-SubVal $db "collation" "en_US@iso88591_fwd_basic")

   } $dbfile

   & java -Xmx256m -classpath $p2j_jar com.goldencode.p2j.directory.DirectoryCopy `

          copy $dbfile /server/standard/database/ directory_tmp.xml /server/standard/database/

   if ($LASTEXITCODE -ne 0)

   {

      throw "DirectoryCopy failed for $db with exit code $LASTEXITCODE."

   }

   Remove-Item -LiteralPath $dbfile -Force

}

Move-Item -LiteralPath 'directory_tmp.xml' -Destination $dirfile -Force

Write-Host "Wrote $dirfile"

exit 0

:: PowerShell Core when it is installed, otherwise the Windows PowerShell which is preinstalled with

:: Windows.  %%~$PATH:I expands to the full path of the file when it is found on the PATH, and to an

:: empty string when it is not.

set "psexe="

for %%I in (pwsh.exe) do if not "%%~$PATH:I" == "" set "psexe=%%~$PATH:I"

if not defined psexe set "psexe=powershell.exe"

"%psexe%" -NoProfile -ExecutionPolicy Bypass -File "%~dp0server.ps1" %*

exit /b %ERRORLEVEL%

   # Resolve the directory.xml path relative to the config's directory.  Split-Path returns an empty

   # string when the config was found as a bare name in the current directory, which is what happens

   # when the server is started from within its own directory; Join-Path rejects that.

      $cfgDir = Split-Path $cfgPath -Parent

      if ([string]::IsNullOrWhiteSpace($cfgDir)) {

         $cfgDir = $PWD.Path  # Use current directory if no parent in path

      }

      $dirXmlPath = Join-Path $cfgDir $dirXmlName

         # an if expression, the ?: ternary operator needs PowerShell 7

         $logDirs = if ($arg -match '=') { ($arg -split '=')[1] } else { $default_log_dirs }

:: PowerShell Core when it is installed, otherwise the Windows PowerShell which is preinstalled

set "psexe="

for %%I in (pwsh.exe) do if not "%%~$PATH:I" == "" set "psexe=%%~$PATH:I"

if not defined psexe set "psexe=powershell.exe"

"%psexe%" -NoProfile -ExecutionPolicy Bypass -File "%scriptdir%start_server.ps1" %*

exit /b %ERRORLEVEL%

:: PowerShell Core when it is installed, otherwise the Windows PowerShell which is preinstalled

set "psexe="

for %%I in (pwsh.exe) do if not "%%~$PATH:I" == "" set "psexe=%%~$PATH:I"

if not defined psexe set "psexe=powershell.exe"

"%psexe%" -NoProfile -ExecutionPolicy Bypass -File "%scriptdir%stop_server.ps1" %*

exit /b %ERRORLEVEL%

hotel_gui

*.[fhi]

*.[pPwW]

.:common:

.;common;

hotel

localhost

../db

en_US@iso88591_fwd_basic

20

no

mdy

,

.

start.p

localhost

7443

directory.xml

yes

:: Pass all arguments to PowerShell script, run_powershell.cmd picks the PowerShell which is installed

call "%scriptdir%run_powershell.cmd" "%scriptdir%install_spawner.ps1" %*

exit /b %ERRORLEVEL%

      "Usage: $script_name [-a] [-d] [-s <path to place spawner>] [-p <path to FWD>] [-f <path to slf4j-impl.jar>] [-n <path to native spawner>] [-c <path to srv-certs>] [-t <path to postbuild.ps1 tool>]",

      "n = Location of built native spawner (def=$spawn_prog, unless -p specified, which will change the default location)",

      "t = Location of postbuild.ps1 tool (def=$postbuild, unless -p specified, which will change the default location)"

# Quotes a value for the PowerShell command line assembled for the privileged step below.  A single

# quote is its own escape, so doubling it is all that is needed.

function ConvertTo-PSLiteral

{

   param (

      [string]$Value

   )

   return "'" + ($Value -replace "'", "''") + "'"

}

<#

   The counterpart of the "$mysudo" of install_spawner.sh.

   Windows has no sudo, a single command cannot be elevated in place, so the commands which need the

   rights are grouped into one child process and that process is started elevated.  Everything else

   in this script stays unelevated, exactly as on Linux: elevating the whole script would also run

   the jar copies below as an administrator and leave a deployment the developer cannot overwrite on

   the next build.

   The child is a separate process even when no elevation is needed, because an "exit" of a script

   called in the current session would end this one as well and skip the library copying below.

   An elevated process cannot share this console: UAC always gives it a window of its own, and

   -Verb RunAs cannot be combined with -RedirectStandardOutput.  Its output is therefore written to a

   file and replayed here, otherwise the window closes as soon as the work is done and nothing can be

   read.  The command is handed over with -EncodedCommand, which takes base64 and so needs no

   quoting of its own.

#>

function Invoke-Privileged

{

   param (

      [string]$Command,

      [switch]$Elevate

   )

   # the interpreter running this script, not a hardcoded "pwsh": PowerShell 7 is not necessarily

   # installed, install_spawner.cmd launches the Windows PowerShell 5.1 instead

   $psHost = (Get-Process -Id $PID).Path

   if (-not $Elevate)

   {

      & $psHost -NoProfile -ExecutionPolicy Bypass -Command "& { $Command }; exit `$LASTEXITCODE"

      return $LASTEXITCODE

   }

   Write-Host "Elevation is required for $fspawn, confirm the prompt to continue..."

   $log = Join-Path ([System.IO.Path]::GetTempPath()) "install_spawner_$PID.log"

   # the braces matter, a redirection binds to the last statement only and the command is a list

   $wrapped = "& { $Command } *> $(ConvertTo-PSLiteral $log); exit `$LASTEXITCODE"

   $encoded = [Convert]::ToBase64String([System.Text.Encoding]::Unicode.GetBytes($wrapped))

   try

   {

      $proc = Start-Process -FilePath $psHost `

                            -ArgumentList @('-NoProfile', '-ExecutionPolicy', 'Bypass',

                                            '-EncodedCommand', $encoded) `

                            -Verb RunAs -WorkingDirectory $cwd -Wait -PassThru

   }

   catch

   {

      # declining the UAC prompt lands here, as does a machine with no interactive desktop

      Write-Host "ERROR: the elevated step could not be started: $($_.Exception.Message)"

      return 1

   }

   if (Test-Path -LiteralPath $log)

   {

      Get-Content -LiteralPath $log

      Remove-Item -LiteralPath $log -Force -ErrorAction SilentlyContinue

   }

   return $proc.ExitCode

}

# Default paths.  Note that $pwd is not used to hold the current directory, it is the name of an

# automatic PowerShell variable.

$cwd = (Get-Location).Path

# The Windows counterparts of the /opt/spawner and /opt/fwd-deploy/spawner of install_spawner.sh.

$fspawn = Join-Path $env:ProgramData 'FWD\spawner'

$fwd_deploy = Join-Path $env:ProgramData 'FWD\fwd-deploy\spawner'

$p2j_lib = "$cwd/p2j/build/lib"

$deploy_home = "$cwd/deploy"

$build_home = "$cwd/build"

$p2j_root = "$cwd/p2j"

if (-not $p2j_passed -and -not $spawn_passed -and !(Test-Path $spawn_prog) -and (Test-Path "$fwd_deploy/spawn.exe")) {

   $spawn_prog = "$fwd_deploy/spawn.exe"

if (-not $p2j_passed -and -not $postbuild_passed -and !(Test-Path $postbuild) -and (Test-Path "$fwd_deploy/postbuild.ps1")) {

   $postbuild = "$fwd_deploy/postbuild.ps1"

         $postbuild = "$p2j_root/src/native/postbuild.ps1"

# Elevation is needed only when the destination is outside the user's own profile and this session is

# not elevated already, the same test as the

#    [[ "$fspawn"* != "$HOME"* ]] && [[ $(whoami) != "root" ]]

# of install_spawner.sh.  Installing under -s $env:USERPROFILE\... raises no prompt at all.

$isAdmin = ([Security.Principal.WindowsPrincipal] [Security.Principal.WindowsIdentity]::GetCurrent()

           ).IsInRole([Security.Principal.WindowsBuiltInRole]::Administrator)

$underHome = $fspawn.StartsWith($env:USERPROFILE, [System.StringComparison]::OrdinalIgnoreCase)

$needElevation = -not $isAdmin -and -not $underHome

# The privileged step: the commands install_spawner.sh runs under sudo, grouped so that at most one

# UAC prompt is raised.  The order differs from install_spawner.sh in one respect, the directory ACL

# is applied before postbuild instead of after it: postbuild.ps1 hardens the folder itself and

# honours its own -StrictAcl, so it has to have the last word.  Against an older postbuild.ps1 which

# leaves the folder alone, the grant below is still what gives the ordinary users their access.

$commands = @()

# Create the destination for the spawner, if not already there. postbuild bails out on a missing one,

# creating it is the job of this script, as in install_spawner.sh.

if (!(Test-Path $fspawn)) {

   $commands += "New-Item -Path $(ConvertTo-PSLiteral $fspawn) -ItemType Directory -Force | Out-Null"

}

# The equivalent of the "chmod gou+rx $fspawn" of install_spawner.sh, S-1-5-32-545 is the well known

# SID of the Users group (the group names are localized, the SIDs are not).

$commands += "& icacls $(ConvertTo-PSLiteral $fspawn) /grant '*S-1-5-32-545:(RX)' | Out-Null"

# Position the spawner files

$commands += ("& $(ConvertTo-PSLiteral $postbuild)" +

              " -SpawnDir $(ConvertTo-PSLiteral $fspawn)" +

              " -SpawnProg $(ConvertTo-PSLiteral $spawn_prog)" +

              " -CertFile $(ConvertTo-PSLiteral $srv_certs)" +

              " -FwdLib $(ConvertTo-PSLiteral $p2j_jar)" +

              " -Slf4jImpl $(ConvertTo-PSLiteral $slf4j_impl)")

$privileged = $commands -join '; '

if ($d) {

   Write-Host $privileged

   $rc = Invoke-Privileged -Command $privileged -Elevate:$needElevation

   if ($rc -ne 0) {

      Write-Host "WARNING! The spawner installation failed with exit code $rc."

   }

# java writes its version banner to stderr, which Windows PowerShell reports as an error record of the

# native command; keep the preference relaxed for the call and stringify what the merged streams give.

$previousPreference = $ErrorActionPreference

$ErrorActionPreference = 'Continue'

try {

   $javaVersionLines = & java -version 2>&1 | ForEach-Object { "$_" }

}

finally {

   $ErrorActionPreference = $previousPreference

}

$jver = $javaVersionLines | Select-String 'version' | ForEach-Object {

      if ($parts.Length -eq 1) { return "$($parts[0])0" }

   if ($d) { Write-Host "New-Item -Path $spidir -ItemType Directory -Force" } else { New-Item -Path $spidir -ItemType Directory -Force | Out-Null }

   Write-Host "Copy-Item $fwdSpiJar $spidir -Force"

   Get-ChildItem $p2j_lib -Include *.jar,*.zip -Recurse -File |

         Write-Host "Copy-Item $($_.FullName) $deploy_home/lib -Force"

@echo off

::

:: Wrapper for json_template.ps1, the counterpart of json_template.sh.

::

:: Run this from the project root, the script resolves its templates relative to the current

:: directory exactly as the shell version does.

::

set scriptdir=%~dp0

call "%scriptdir%run_powershell.cmd" "%scriptdir%json_template.ps1" %*

exit /b %ERRORLEVEL%

#

# The Windows counterpart of json_template.sh, kept in sync with it: takes input from

# prepare_template.json and performs configuration of build.properties, zfile_set.txt, p2j.cfg.xml,

# deploy/server/server.xml and the directory.xml file (which can be located anywhere, as it is

# specified in the json file).

#

# Substitution is done with a literal String.Replace and not with the -replace operator: -replace is

# a regular expression on both sides, so a value holding a $ or a \ would be mangled - a database

# password is the obvious way to hit that.

#

param (

   [switch]$a,

   [switch]$d,

   [switch]$o,

   [switch]$n,

   [string]$f

)

Set-PSDebug -Trace 0

Set-StrictMode -Version Latest

$ErrorActionPreference = 'Stop'

function Show-Usage

{

   Write-Host "Usage: json_template.ps1 [-a] [-d] [-o] [-f <json_file>]"

   Write-Host "Takes input from prepare_template.json and performs configuration of build.properties,"

   Write-Host "p2j.cfg.xml, deploy/server/server.xml, and the directory.xml file."

   Write-Host "Where:"

   Write-Host "   a = Only performing Analytics"

   Write-Host "   d = Generate deploy/server/prepare_dir.json output file to be used by prepare_dir.ps1"

   Write-Host "   o = Overwrite the specified directory.xml, if it already exists. Otherwise, leave it alone"

   Write-Host "   f = Use <json_file> instead of prepare_template.json as input."

}

$utf8NoBom = New-Object System.Text.UTF8Encoding($false)

# Property lookup which tolerates a missing key under Set-StrictMode; $cfg.$Key would throw.

function Get-Node

{

   param (

      $Object,

      [string]$Key

   )

   if ($null -eq $Object) { return $null }

   $prop = $Object.PSObject.Properties[$Key]

   if ($null -eq $prop) { return $null }

   return $prop.Value

}

function Get-Val

{

   param (

      [string]$Key,

      [string]$Default = ""

   )

   $val = Get-Node $script:cfg $Key

   if ($null -eq $val -or "$val" -eq "") { return $Default }

   return "$val"

}

# The per-database values live in a sub-object named after the database, so the lookup is two

# levels.  Note prepare_dir.ps1 used to pass "<db>.<key>" as a single property name, which never

# resolved and silently handed back every default.

function Get-SubVal

{

   param (

      [string]$SubName,

      [string]$Key,

      [string]$Default = ""

   )

   $node = Get-Node $script:cfg $SubName

   $val = Get-Node $node $Key

   if ($null -eq $val -or "$val" -eq "") { return $Default }

   return "$val"

}

# Replaces every {key} of a template with its value and writes the result.

function Expand-Template

{

   param (

      [string]$Template,

      [hashtable]$Values,

      [string]$Destination

   )

   if (!(Test-Path -LiteralPath $Template -PathType Leaf))

   {

      throw "Could not create $Destination, the template $Template was not found."

   }

   $content = [System.IO.File]::ReadAllText($Template)

   foreach ($key in $Values.Keys)

   {

      $content = $content.Replace("{$key}", [string]$Values[$key])

   }

   [System.IO.File]::WriteAllText($Destination, $content, $utf8NoBom)

}

# Splits a PROPATH answer.  Both spellings are accepted so the same answer file works either way:

# a ';' separated list is split on ';' (which also keeps a "C:\..." drive letter intact), anything

# else is split on ':'.

function Split-PropathValue

{

   param (

      [string]$Value

   )

   $sep = if ($Value.Contains(';')) { ';' } else { ':' }

   return @($Value -split [regex]::Escape($sep) | ForEach-Object { $_.Trim() } | Where-Object { $_ -ne "" })

}

if ($args -contains "-?" -or $args -contains "/?" -or $args -contains "-h")

{

   Show-Usage

   exit 1

}

$analytics = $a.IsPresent

$overwrite = $o.IsPresent

$json_file = if ($f) { $f } else { "prepare_template.json" }

$prepare_dir = if ($d) { "deploy/server/prepare_dir.json" } else { "" }

if (!(Test-Path -LiteralPath $json_file -PathType Leaf))

{

   Write-Error "Input file not found: $json_file"

   Show-Usage

   exit 1

}

$root = (Get-Location).Path

# System.IO and every native command resolve a relative path against the PROCESS working directory,

# which PowerShell's own location does not track: Push-Location moves the latter and leaves the

# former where the script started.  The two are kept in step here and around the Push-Location

# further down, otherwise the templates under deploy/server are looked for in the project root and

# the files written there land in the root as well.

[Environment]::CurrentDirectory = $root

$cfg = [System.IO.File]::ReadAllText($json_file) | ConvertFrom-Json

# ---------------------------------------------------------------------------------------------------

# Values taken straight from the json

# ---------------------------------------------------------------------------------------------------

$appname = Get-Val "appname"

$projname = Get-Val "projname" $appname

$include_spec = Get-Val "include_spec" "*.[fhi]"

$program_spec = Get-Val "program_spec" "*.[pPwW]"

$pkgroot = if ($analytics) { "com.goldencode.$appname" } else { Get-Val "pkgroot" "com.goldencode.$appname" }

$propath_bld = Get-Val "propath_bld" "."

$propath = Get-Val "propath" "."

$admversion = Get-Val "admversion" "ADM2.2"

$dbnames = Get-Val "dbnames"

$embedded_host = Get-Val "embedded_host" "localhost"

$admin_port = Get-Val "admin_port" "7443"

if ($analytics)

{

   $win_proj = "no"

   $dateFormat = "mdy"

   $numberGroupSep = ","

   $numberDecimalSep = "."