GenerateLegacyProxyOpenClient.java
/*
** Module : GenerateLegacyProxyOpenClient.java
** Abstract : Generate the Java proxy programs for the .xpxg configured programs, associated with legacy
** OpenClient proxies.
**
** Copyright (c) 2022-2025, Golden Code Development Corporation.
**
** -#- -I- --Date-- --------------------------------------Description---------------------------------------
** 001 CA 20220516 Created initial version.
** CA 20220517 Generate proxy OpenClient programs only for programs part of the initial conversion list.
** 002 GBB 20230512 Logging methods replaced by CentralLogger/ConversionStatus.
** 003 CA 20250515 Now parsing pulls all .cls dependencies into conversion - after that, only the proxy
** programs are needed, so filter the ASTs to remove anything else added by parser.
*/
/*
** This program is free software: you can redistribute it and/or modify
** it under the terms of the GNU Affero General Public License as
** published by the Free Software Foundation, either version 3 of the
** License, or (at your option) any later version.
**
** This program is distributed in the hope that it will be useful,
** but WITHOUT ANY WARRANTY; without even the implied warranty of
** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
** GNU Affero General Public License for more details.
**
** You may find a copy of the GNU Affero GPL version 3 at the following
** location: https://www.gnu.org/licenses/agpl-3.0.en.html
**
** Additional terms under GNU Affero GPL version 3 section 7:
**
** Under Section 7 of the GNU Affero GPL version 3, the following additional
** terms apply to the works covered under the License. These additional terms
** are non-permissive additional terms allowed under Section 7 of the GNU
** Affero GPL version 3 and may not be removed by you.
**
** 0. Attribution Requirement.
**
** You must preserve all legal notices or author attributions in the covered
** work or Appropriate Legal Notices displayed by works containing the covered
** work. You may not remove from the covered work any author or developer
** credit already included within the covered work.
**
** 1. No License To Use Trademarks.
**
** This license does not grant any license or rights to use the trademarks
** Golden Code, FWD, any Golden Code or FWD logo, or any other trademarks
** of Golden Code Development Corporation. You are not authorized to use the
** name Golden Code, FWD, or the names of any author or contributor, for
** publicity purposes without written authorization.
**
** 2. No Misrepresentation of Affiliation.
**
** You may not represent yourself as Golden Code Development Corporation or FWD.
**
** You may not represent yourself for publicity purposes as associated with
** Golden Code Development Corporation, FWD, or any author or contributor to
** the covered work, without written authorization.
**
** 3. No Misrepresentation of Source or Origin.
**
** You may not represent the covered work as solely your work. All modified
** versions of the covered work must be marked in a reasonable way to make it
** clear that the modified work is not originating from Golden Code Development
** Corporation or FWD. All modified versions must contain the notices of
** attribution required in this license.
*/
package com.goldencode.p2j.convert;
import java.io.*;
import java.io.IOException;
import java.util.*;
import java.util.logging.*;
import com.goldencode.ast.*;
import com.goldencode.p2j.cfg.*;
import com.goldencode.p2j.pattern.*;
import com.goldencode.p2j.schema.SchemaException;
import com.goldencode.p2j.util.*;
/**
* Given the list of .xpxg files configured in {@code p2j.cfg.xml} under the {@code proxy-programs-cfg}
* parameter, it will parse, annotate and generate the Java proxy programs for all program files configured.
* <p>
* Although the middle front and middle parts are being executed for this sub-set of programs, no other Java
* code is generated, either for the schema or for the 4GL programs configured as 'proxy programs'.
* <p>
* The {@link #back()} processing will generate only the Java code for the proxy programs.
*/
public class GenerateLegacyProxyOpenClient
extends ConversionDriver
{
/** Logger. */
private static final ConversionStatus LOG = ConversionStatus.get(GenerateLegacyProxyOpenClient.class);
/** Job title. */
private static final String TITLE = "FWD Proxy Program Generator";
/** The set of programs for which OpenClient proxies need to be generated. */
private static Set<File> proxyFiles = null;
/**
* Create a new job.
*
* @param job
* The job configuration.
*/
private GenerateLegacyProxyOpenClient(JobDefinition job)
{
super(job);
}
/**
* Using the source name list as input, this method creates duplicate lists with the proper
* <code>.ast</code> or <code>.jast</code> file suffixes on each entry. The results are saved into the
* Progress AST name list.
* <p>
* This also ensures that only the {@link #proxyFiles} ASTs remain to be processed by next phases.
*/
@Override
protected void convertSourceNamesToAstNames()
{
super.convertSourceNamesToAstNames();
// leave only the proxy ASTs
asts = getProxyAsts();
}
/**
* Drive the back end of the conversion process to generate the Java code for the proxy programs.
* This uses the file list of Progress AST files configured in the .xpxg files.
*
* <p>
* This runs the following:
* <ul>
* <li> Proxy Client Programs Annotations, in {@code annotations/legacy_services}. This is an extract
* from annotations_prep and annotation phases, to annotate the ASTs with Java names.
* <li> {@link #generateProxyPrograms};
* </ul>
*
* @throws ConfigurationException If there is problem reading/parsing the configuration.
* @throws AstException If there is an problem processing ASTs.
* @throws SchemaException If there is a problem with the schema.
* @throws IOException If there is a problem with I/O.
*/
@Override
protected void back()
throws AstException,
ConfigurationException
{
processTrees("Proxy Client Programs Annotations",
"annotations/legacy_services",
Configuration.getParameter("codenames"),
false,
asts,
debug);
generateProxyPrograms();
}
/**
* Get the list of {@link TransformDriver#asts all ASTs} which are associated with the {@link #proxyFiles},
* removing anything else.
*
* @return See above.
*/
private FileList getProxyAsts()
{
// keep only the files which were initially in conversion (without the auto-added .cls dependencies)
File[] allAsts = asts.list();
ExplicitFileList proxies = new ExplicitFileList(Configuration.isCaseSensitive());
for (int i = 0; i < allAsts.length; i++)
{
boolean ok = false;
File ast = allAsts[i];
String astname = ast.getPath();
for (File f : proxyFiles)
{
String fname = f.getPath();
if (astname.equals(fname + ".ast"))
{
ok = true;
break;
}
}
if (ok)
{
proxies.add(astname);
}
}
return proxies;
}
/**
* Main method. No arguments are required. The configuration is read from the {@code "proxy-programs-cfg"}
* parameter of {@code p2j.cfg.xml}.
*
* @param args
* None.
*/
public static void main(String[] args)
{
ServiceSupport.initializeProxyConfigurations();
// get all the files configured in the proxy .xpxg files
List<LegacyProxyConfig> cfgs = ServiceSupport.getProxyConfigs();
if (cfgs == null)
{
LOG.log(Level.SEVERE, "No proxy .xpxg file is configured in p2j.cfg.xml, 'proxy-programs-cfg'");
System.exit(-1);
}
ExplicitFileList files = new ExplicitFileList(Configuration.isCaseSensitive());
for (LegacyProxyConfig cfg : cfgs)
{
List<String> programFiles = cfg.getProxyProgramFiles();
for (String program : programFiles)
{
try
{
String pfile = FileOperationsWorker.findFile(program, null);
if (pfile == null)
{
System.out.println("WARNING: Could not find program '" + program + "' for proxy config: " +
cfg.getAppObject() + " in package " + cfg.getPkg());
continue;
}
System.out.println("Adding program '" + pfile + "' for proxy config: " + cfg.getAppObject() +
" in package " + cfg.getPkg());
files.add(pfile);
}
catch (ConfigurationException e)
{
LOG.log(Level.SEVERE, "", e);
System.exit(-2);
}
}
}
proxyFiles = new LinkedHashSet<>(Arrays.asList(files.list()));
int debug = MSG_STATUS;
RunMode run = new CvtRunMode(true, true, true, false, true, false, false, true, true);
JobDefinition job = new JobDefinition(run, null, files, null, 1, true, false, debug);
GenerateLegacyProxyOpenClient gen = new GenerateLegacyProxyOpenClient(job);
gen.executeJob(TITLE);
}
}