* It includes: * a basic log manager (@see #logger) * a root logger * a basic properties set (@see #prop) * a single script SIM compiler (@see #compiler) * a universe factory (@see #uf) * a LOCAL universe server * a Kernel (uninitialized!) * a root loader (uninitialized!) *
* It requires the root property be set.
*
* @author Erich P. Gatejen
* @version 1.0
* Version History
* EPG - Initial - 25Apr03
*
*/
public class SimpleSystemContext implements SystemContext {
/**
* Primary log manager
*/
public AutohitBasicLogManager logManager;
/**
* Root log injector
*/
public AutohitLogInjectorWrapper logger;
/**
* Script compiler. Keep at least one around.
*/
public SimCompiler compiler;
/**
* Our simple little universe.
*/
public Universe uni;
/**
* The system properties set
*/
public ExtendedProperties prop;
/**
* Invoker properties set
*/
public ExtendedProperties invokerprop;
/**
* Universe factory
*/
public UniverseFactory uf;
/**
* Channel controller
*/
public Controller cc;
/**
* Kernel
*/
public Kernel k;
/**
* Kernel
*/
private VMLoader loader;
/**
* Debugging flag
*/
public boolean debug;
/**
* Root path
*/
public String root;
/**
* Unique number counter -- it will be unique for all instances of SimpleSystemContext.
*/
public static int uniqueN = 0;
/**
* Default Constructor.
*/
public SimpleSystemContext() throws Exception {
// Doesn't do anything
}
/**
* Properties constructor. Give it a full path to the
* properties file.
*/
public void init(ExtendedProperties props) throws Exception {
// save 'em
prop = props;
// defaults
debug = false;
// Make my universe factory
uf = new UniverseFactory();
// Make a channel controller
cc = new Controller();
// BUILD LOG MANAGER ---------------------------------------
int ald_line_size = AutohitProperties.LOGS_LINE_SIZE_DEFAULT;
// LINE SIZE?
String logsize =
(String) Utils.testGetProperty(
AutohitProperties.LOGS_LINE_SIZE,
prop);
if (logsize != null) {
try {
ald_line_size = Integer.parseInt(logsize);
} catch (Exception e) {
// No where to report it anyway
}
}
// If a log type is file, use a file otherwise use console,
// even if not set.
String logprop =
(String) Utils.testGetProperty(
AutohitProperties.LOGS_TYPE_CONTROL,
prop);
String logClientprop =
(String) Utils.testGetProperty(
AutohitProperties.LOGS_TYPE_CLIENT,
prop);
AutohitLogDrain controlDrain;
AutohitLogDrain clientDrain;
// CONTROL DRAIN
if ((logprop == null)
|| (logprop.equals(AutohitProperties.LOGS_TYPE__FILE))) {
try {
logprop =
(String) Utils.testGetProperty(
AutohitProperties.LOGS_LOCATION_CONTROL + AutohitProperties.literal_FS_LOG_EXTENSION,
prop);
FileOutputStream fco = new FileOutputStream(logprop, true);
controlDrain = new AutohitLogDrainDefault();
controlDrain.init(fco, ald_line_size);
} catch (Exception e) {
// If something goes wrong, default to console
controlDrain = new AutohitLogDrainDefault();
controlDrain.init(System.err, ald_line_size);
}
} else {
controlDrain = new AutohitLogDrainDefault(); // drain to stderr
controlDrain.init(System.err, ald_line_size);
}
// CLIENT DRAIN
if ((logClientprop == null)
|| (logClientprop.equals(AutohitProperties.LOGS_TYPE__FILE))) {
try {
logClientprop =
(String) Utils.testGetProperty(
AutohitProperties.LOGS_LOCATION_CLIENT,
prop);
FileOutputStream fco =
new FileOutputStream(logClientprop, true);
AutohitLogDrainRouting rclientDrain = new AutohitLogDrainRouting();
rclientDrain.init(fco, ald_line_size);
rclientDrain.setup(logClientprop);
clientDrain = rclientDrain;
} catch (Exception e) {
// If something goes wrong, default to console
clientDrain = new AutohitLogDrainDefault();
clientDrain.init(System.err, ald_line_size);
System.out.println("SimpleSystemContext:Could not build AutohitLogDrainRouting. Using stderr instead. message=" + e.getMessage());
}
} else {
clientDrain = new AutohitLogDrainDefault(); // drain to stderr
clientDrain.init(System.err, ald_line_size);
}
logManager = new AutohitBasicLogManager(controlDrain, clientDrain);
// CONFIGURE LOGGERS -----------------------------------------
// Get root logger. Set some attributes
logger = logManager.getRootLogger();
// Configure the logger
logger.info(
"Root logger starting.",
AutohitErrorCodes.CODE_INFORMATIONAL_OK_VERBOSE);
logprop =
(String) Utils.testGetProperty(
AutohitProperties.LOGS_PRETTY_PRINT,
prop);
if ((logprop != null) && (logprop.equals("true"))) {
logger.info(
"Root logger pretty-print = true.",
AutohitErrorCodes.CODE_INFORMATIONAL_OK_VERBOSE);
logManager.pretty(true);
}
logprop =
(String) Utils.testGetProperty(
AutohitProperties.LOGS_TIMESTAMP,
prop);
if ((logprop != null) && (logprop.equals("true"))) {
logger.info(
"Root logger timestamp = true.",
AutohitErrorCodes.CODE_INFORMATIONAL_OK_VERBOSE);
logManager.stampit(true);
}
logprop =
(String) Utils.testGetProperty(
AutohitProperties.LOGS_LINE_LIMIT,
prop);
if (logprop != null) {
try {
int ll = Integer.parseInt(logprop);
logger.info(
"Root logger line limit set to " + ll,
AutohitErrorCodes.CODE_INFORMATIONAL_OK_VERBOSE);
logManager.getDrain().setLineLimit(ll);
logManager.getClientDrain().setLineLimit(ll);
} catch (Exception e) {
logger.error(
"Value for "
+ AutohitProperties.LOGS_LINE_LIMIT
+ " cannot be parsed as an integer. Using default. Value="
+ logprop,
AutohitErrorCodes.CODE_CONFIGURATION_ERROR);
}
}
// Are we debugging???
logprop =
(String) Utils.testGetProperty(
AutohitProperties.SYSTEM_DEBUG,
prop);
if ((logprop != null) && (logprop.equals("true"))) {
logger.info(
"DEBUGGING IS ON.",
AutohitErrorCodes.CODE_INFORMATIONAL_OK);
logManager.debugOn();
debug = true;
}
logger.debug(
"DEBUGGING root logger up.",
AutohitErrorCodes.CODE_INFORMATIONAL_OK);
logger.info(
"Root logger up.",
AutohitErrorCodes.CODE_INFORMATIONAL_OK_VERBOSE);
// At this point, log any exceptions and abort
try {
// Check for
root =
(String) Utils.testGetProperty(
AutohitProperties.ROOT_PATH,
prop);
if (root == null) {
logger.error(
"ERROR. Root property not set!",
AutohitErrorCodes.CODE_STARTUP_CONFIGURATION_FAULT);
throw new AutohitException(
"Required root property not set.",
AutohitException.CODE_STARTUP_CONFIGURATION_FAULT);
}
// BUILD COMPILER
compiler = new SimCompiler(this);
// Get universe config
String handle =
(String) Utils.testGetProperty(
AutohitProperties.DEFAULT_UNIVERSE_HANDLE,
prop);
if (handle == null) {
handle = AutohitProperties.literal_DEFAULT_UNIVERSE_HANDLE;
}
String upath =
(String) Utils.testGetProperty(
AutohitProperties.DEFAULT_UNIVERSE_PATH,
prop);
if (upath == null) {
upath = AutohitProperties.literal_DEFAULT_UNIVERSE_PATH;
}
String uprop =
(String) Utils.testGetProperty(
AutohitProperties.DEFAULT_UNIVERSE_PROP,
prop);
if (uprop == null) {
uprop = AutohitProperties.literal_DEFAULT_UNIVERSE_PROP;
}
// INVOKER PROPERTIES
invokerprop = new ExtendedProperties();
// BUILD OUR UNIVERSE
uni = uf.create(handle, root + upath + "/" + uprop);
// BUILD THE ROOT KERNEL
k = new Kernel();
k.init(this);
// BUILD THE LOADER
loader = new VMLoader();
loader.init(this);
} catch (Exception e) {
logger.error(
"ERROR during context instantiation. Aborting. Exception="
+ e.getMessage(),
AutohitErrorCodes.CODE_STARTUP_FAULT);
throw e;
}
}
/**
* Load properties. It will delete any previously loaded properties.
* @param props a properties set
*/
public void loadProperties(ExtendedProperties props) throws Exception {
prop.combine(props);
}
/**
* Get the default universe
* @return Universe service interface
*/
public Universe getUniverse() {
return uni;
}
/**
* Get a universe service by handle. This implementation ignores the
* handle and returns the only universe we have.
* @param handle handle to the universe
* @return Universe service interface
*/
public Universe getUniverse(String handle) {
// ignore the handle. We only have one.
return uni;
}
/**
* Get the XML compiler
* @return XmlCompiler base class
*/
public XmlCompiler getCompiler() {
return compiler;
}
/**
* Get a reference to a generic, root log injector
* @return XmlCompiler base class
*/
public AutohitLogInjectorWrapper getRootLogger() {
return logger;
}
/**
* Cheat. The logger will be our even dispacter
* @return Injector reference
*/
public Injector getEventDispatcher() {
return (Injector) logger;
}
/**
* Get properties set
* @return reference to the properties set
*/
public ExtendedProperties getPropertiesSet() {
return prop;
}
/**
* Get log manager reference
* @return reference to the properties set
*/
public AutohitBasicLogManager getLogManager() {
return logManager;
}
/**
* Get the Kernel
* @return reference to the kernel
*/
public Kernel getKernel() {
return k;
}
/**
* Get the VM Loader
* @return reference to the kernel
*/
public VMLoader getLoader() {
return loader;
}
/**
* Get the command registry as a properties set. It is not cached.
* this implementation will always return the default set.
* @return properties set representing the registry. it will return null if it cannot be loaded
*/
public CommandRegistry getCommandRegistry() {
CommandRegistry rset = null;
try {
rset =
new CommandRegistry(
new FileInputStream(
root + AutohitProperties.COMMAND_DEFAULT_REGISTRY));
} catch (Exception e) {
// don't care. it will return null.
logger.error(
"FAULT! Fauled to create a CommandRegistry! message="
+ e.getMessage(),
AutohitErrorCodes.CODE_COMMAND_REGISTRY_FAULT);
}
return rset;
}
/**
* Unique number
* @return an integer number unique (at least) to this Context
*/
public synchronized int uniqueInteger() {
uniqueN++;
return uniqueN;
}
/**
* Get debugging state
* @return true if debugging active
*/
public boolean debuggingState() {
return debug;
}
/**
* Get a reference to the invoker properties set. Generally, only
* invokers should add anything to the set. It should be safe for anyone
* to read from it. It is up to the invoker to maintain its contents.
* @return reference to the invoker properties set
*/
public ExtendedProperties getInvokerProperties() {
return invokerprop;
}
}