com.ibm.as400.util.AS400ClassPathOptimizer Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of jt400 Show documentation
The Open Source version of the IBM Toolbox for Java
The newest version!

package com.ibm.as400.util;

import com.ibm.as400.access.*;
import com.ibm.as400.resource.*;
import java.io.PrintStream;
import java.util.StringTokenizer;
import java.util.Enumeration;
import java.util.*;



/**
 * This class is used to optimize an AS400 classpath using the CRTJVAPGM command.
 * The original need was a software update/install procedure that needed to make sure
 * all the classes in the classpath were optimized at the appropriate levels.  We
 * needed something that didn't recompile classes if they were already optimized, as
 * our app was large (over 10MB) and it could take several hours and LOTS of cpu to
 * optimize at level 40.  We needed something that did "touch up" optimizations.
 * Here is an example of how you can use it...
 *
 *  *	public static void main(String args[]) throws Exception {
 *
 *		String classpath = "/home/toronto/DEV/:/home/toronto/DEV/server.jar:" +
 *      	"/home/toronto/DEV/preprocessor.jar:/qibm/ProdData/HTTP/Public/jt400/lib/jt400.jar:" +
 *			"/qibm/proddata/java400/jt400ntv.jar:/home/toronto/DEV/collections.jar:" +
 *			"/home/toronto/DEV/antlr.jar:/home/toronto/DEV/crimson.jar:/home/toronto/DEV/xalan.jar:" +
 *			"/home/toronto/DEV/jaxp.jar:";
 *
 *		AS400 as400 = new AS400( "mysystem", "user", "password" );
 *		AS400ClassPathOptimizer cpo = new AS400ClassPathOptimizer( as400, classpath );
 *
 *		cpo.setOptimizationLevel( cpo.LEVEL_40 );
 *		cpo.setLicensedInternalCodeOptions( cpo.LICOPT_NOPRERESOLVEEXTREF );
 *
 *		// submit the optimizations and exit since this could take some time
 *		cpo.setOptimizeInParallel( true );
 *
 *		// so we can see the details of what it is doing...
 *		cpo.setOutputLog( System.out );
 *
 *		// submit the optimizations
 *		cpo.optimize();
 *
 *		System.exit( 0 );
 *	}
 * 
 * @author Glen Marchesani
**/
public class AS400ClassPathOptimizer {

//------------------------------------------------------------------------------
// constants

	public static final int NO_OPTIMIZATION = 0;
	public static final int LEVEL_10 = 10;
	public static final int LEVEL_20 = 20;
	public static final int LEVEL_30 = 30;
	public static final int LEVEL_40 = 40;

	public static final String LICOPT_NOPRERESOLVEEXTREF = "NOPRERESOLVEEXTREF";

//------------------------------------------------------------------------------
// instance variables

	private AS400 as400_;
	private CommandCall commandCall_;
	private String classpath_;

	private boolean wait_ = false;

	private boolean optimizeInParallel_ = false;
	private int optimizationLevel_= NO_OPTIMIZATION;
	private boolean optimizeDirectories_ = false;

	private String licensedInternalCodeOptions_ = LICOPT_NOPRERESOLVEEXTREF;

	private PrintStream out_;

//------------------------------------------------------------------------------
// constructors

	public AS400ClassPathOptimizer() {
		this( null, null );
	}

	public AS400ClassPathOptimizer( AS400 as400 ) {
		this( as400, null );
	}

	public AS400ClassPathOptimizer( AS400 as400, String classpath ) {
		setAS400( as400 );
		setClasspath( classpath );
	}

//------------------------------------------------------------------------------
// methods


	/**
	 *  set the AS400 classpath to opimize.  valid path separators are ; and :
	 *
	 */
	public void setClasspath( String classpath ) {
		classpath_ = classpath;
	}

	public void setAS400( AS400 as400 ) {
		as400_ = as400;
	}

	/**
	 *  if true the optimize() method will wait for all CRTJVAPGM commands to end
	 *  before it returns.  Otherwise
	 *
	 */
	public void setWaitForOptimizations( boolean s ) {
		wait_ = s;
	}

	public boolean isWaitForOptimizations() {
		return wait_;
	}


	/**
	 *  if true run each CRTJVAPGM in a separate job.  Using a value of true setting will ignore the "wait for optimizations" attribute.
	 *  if false will run each CRTJVAPGM in serial waiting for the first to end before the next CRTJBAPGM is run.
	 *
	 */
	public void setOptimizeInParallel( boolean s ) {
		optimizeInParallel_ = s;
	}

	public void setOptimizeDirectories( boolean b ) {
		optimizeDirectories_ = b;
	}

	public boolean isOptimizeInParallel() {
		return optimizeInParallel_;
	}

	public String getLicensedInternalCodeOptions() {
		return licensedInternalCodeOptions_;
	}

	/**
	 * Sets the value to use on the CRTJVAPGM LICOPT parameter
	 */
	public void setLicensedInternalCodeOptions( String s ) {
		licensedInternalCodeOptions_ = s;
	}


	/**
	 *   Set the level to optimize classes to.  Note that if a class/jar/zip is currently
	 *   optimized at say level 30 and you set this at level 20 then no optimization will be done.
	 *
	 *   This is not the case for optimizing a directory.  If you optimize a directory the whole directory
	 *   will be reoptimized to the level set.  This is due to performance of checking the
	 *   optimization level of say 400 classes in a directory versus making a single call
	 *   to the CRTJVAPGM which.  The single call to CRTJVAPGM (to optimize the entire directory) is almost always quicker than
	 *   checking the 400 classes individually plus the time to optimize the classes individually.
	 *
	 */
	public void setOptimizationLevel( int level ) {
		optimizationLevel_ = level;
	}


	public void setOutputLog( PrintStream out ) {
		out_ = out;
	}

	public void optimize() throws Exception {

		if ( optimizeInParallel_ ) {
			wait_ = false;
		}

		run();

	}


	public void run() throws Exception {

		logit( "classpath=" + classpath_ );
		logit( "wait=" + wait_ );
		logit( "optimizationLevel=" + optimizationLevel_ );
		logit( "optimizeDirectories=" + optimizeDirectories_ );
		logit( "optimizeInParallel=" + optimizeInParallel_ );
		logit( "licensedInternalCodeOptions=" + licensedInternalCodeOptions_ );

		StringTokenizer st = new StringTokenizer( classpath_, ";:" );

		while( st.hasMoreTokens() ) {

			String path = st.nextToken();

			IFSFile file = new IFSFile( as400_, path );

			if ( file.isDirectory() && optimizeDirectories_ == false ) {
				logit( path + " is a directory and optimize directories is false." );
			} else if ( file.isAbsolute() && file.exists() == false ) {
				logit( path + " does not exist." );
			} else if ( file.isAbsolute() == false ) {
				logit( path + " must be an absolute path to be optimized." );
			} else {

				int level = retrieveOptimizationLevel( file );

				if ( level < optimizationLevel_ ) {
					optimize( file );
					logit( path + " currently optimized at level " + level + " optimizing to level " + optimizationLevel_ );
				} else {
					logit( path + " currently optimized at level " + level + " not optimizing." );
				}
			}
		}
	}


	private void optimize( IFSFile file ) throws Exception {

		String command = getOptimizationCommand( file );

		if ( wait_ ) {
			runCommand( command );
		} else if ( optimizeInParallel_ ) {
			runCommand( "SBMJOB JOB(CRTJVAPGM) CMD(" + command + ")" );
		}
	}


	void logit( String msg ) {
		if ( out_ != null ) {
			out_.println( msg );
		}
	}


	private String getOptimizationCommand( IFSFile file ) throws Exception {

		StringBuffer sb = new StringBuffer();

		sb.append( "CRTJVAPGM " );
		sb.append( "CLSF(" + file.getAbsolutePath() + ") "  );
		sb.append( "OPTIMIZE(" + optimizationLevel_ + ") " );

		if ( file.isDirectory() && optimizeDirectories_ ) {
			sb.append( "SUBTREE(*ALL) " );
		}

		if ( licensedInternalCodeOptions_ != null ) {
			sb.append( "LICOPT(" + licensedInternalCodeOptions_ + ") " );
		}

		return sb.toString();
	}


	void runCommand( String command ) throws Exception {

		if ( commandCall_ == null ) {
			commandCall_ = new CommandCall( as400_ );
		}

		logit( command );

		boolean status = commandCall_.run( command );

		if ( status == false ) {
			AS400Message[] log = commandCall_.getMessageList();
			logit( "error running command " + command );
			for ( int i=0; i