| /******************************************************************************* |
| * Copyright (c) 2006 The Regents of the University of California. |
| * This material was produced under U.S. Government contract W-7405-ENG-36 |
| * for Los Alamos National Laboratory, which is operated by the University |
| * of California for the U.S. Department of Energy. The U.S. Government has |
| * rights to use, reproduce, and distribute this software. NEITHER THE |
| * GOVERNMENT NOR THE UNIVERSITY MAKES ANY WARRANTY, EXPRESS OR IMPLIED, OR |
| * ASSUMES ANY LIABILITY FOR THE USE OF THIS SOFTWARE. If software is modified |
| * to produce derivative works, such modified software should be clearly marked, |
| * so as not to confuse it with the version available from LANL. |
| * |
| * Additionally, this program and the accompanying materials |
| * are made available under the terms of the Eclipse Public License v1.0 |
| * which accompanies this distribution, and is available at |
| * http://www.eclipse.org/legal/epl-v10.html |
| * |
| * LA-CC 04-115 |
| *******************************************************************************/ |
| package org.eclipse.ptp.rtsystem; |
| |
| import java.io.IOException; |
| import java.math.BigInteger; |
| import java.text.DateFormat; |
| import java.text.ParseException; |
| import java.util.ArrayList; |
| import java.util.Collections; |
| import java.util.Date; |
| import java.util.HashMap; |
| import java.util.Locale; |
| import java.util.Map; |
| |
| import org.eclipse.core.runtime.CoreException; |
| import org.eclipse.core.runtime.IStatus; |
| import org.eclipse.core.runtime.Status; |
| import org.eclipse.ptp.core.PTPCorePlugin; |
| import org.eclipse.ptp.core.attributes.AttributeDefinitionManager; |
| import org.eclipse.ptp.core.attributes.AttributeManager; |
| import org.eclipse.ptp.core.attributes.IAttribute; |
| import org.eclipse.ptp.core.attributes.IAttributeDefinition; |
| import org.eclipse.ptp.core.attributes.IllegalValueException; |
| import org.eclipse.ptp.core.attributes.IntegerAttribute; |
| import org.eclipse.ptp.core.attributes.StringAttribute; |
| import org.eclipse.ptp.core.elements.IPJob; |
| import org.eclipse.ptp.core.elements.attributes.ElementAttributeManager; |
| import org.eclipse.ptp.core.elements.attributes.ElementAttributes; |
| import org.eclipse.ptp.core.elements.attributes.ErrorAttributes; |
| import org.eclipse.ptp.core.elements.attributes.JobAttributes; |
| import org.eclipse.ptp.core.elements.attributes.MessageAttributes.Level; |
| import org.eclipse.ptp.core.util.RangeSet; |
| import org.eclipse.ptp.internal.rtsystem.events.RuntimeAttributeDefinitionEvent; |
| import org.eclipse.ptp.internal.rtsystem.events.RuntimeConnectedStateEvent; |
| import org.eclipse.ptp.internal.rtsystem.events.RuntimeErrorStateEvent; |
| import org.eclipse.ptp.internal.rtsystem.events.RuntimeJobChangeEvent; |
| import org.eclipse.ptp.internal.rtsystem.events.RuntimeMachineChangeEvent; |
| import org.eclipse.ptp.internal.rtsystem.events.RuntimeMessageEvent; |
| import org.eclipse.ptp.internal.rtsystem.events.RuntimeNewJobEvent; |
| import org.eclipse.ptp.internal.rtsystem.events.RuntimeNewMachineEvent; |
| import org.eclipse.ptp.internal.rtsystem.events.RuntimeNewNodeEvent; |
| import org.eclipse.ptp.internal.rtsystem.events.RuntimeNewProcessEvent; |
| import org.eclipse.ptp.internal.rtsystem.events.RuntimeNewQueueEvent; |
| import org.eclipse.ptp.internal.rtsystem.events.RuntimeNodeChangeEvent; |
| import org.eclipse.ptp.internal.rtsystem.events.RuntimeProcessChangeEvent; |
| import org.eclipse.ptp.internal.rtsystem.events.RuntimeQueueChangeEvent; |
| import org.eclipse.ptp.internal.rtsystem.events.RuntimeRemoveAllEvent; |
| import org.eclipse.ptp.internal.rtsystem.events.RuntimeRemoveJobEvent; |
| import org.eclipse.ptp.internal.rtsystem.events.RuntimeRemoveMachineEvent; |
| import org.eclipse.ptp.internal.rtsystem.events.RuntimeRemoveNodeEvent; |
| import org.eclipse.ptp.internal.rtsystem.events.RuntimeRemoveProcessEvent; |
| import org.eclipse.ptp.internal.rtsystem.events.RuntimeRemoveQueueEvent; |
| import org.eclipse.ptp.internal.rtsystem.events.RuntimeRunningStateEvent; |
| import org.eclipse.ptp.internal.rtsystem.events.RuntimeShutdownStateEvent; |
| import org.eclipse.ptp.internal.rtsystem.events.RuntimeStartupErrorEvent; |
| import org.eclipse.ptp.internal.rtsystem.events.RuntimeSubmitJobErrorEvent; |
| import org.eclipse.ptp.internal.rtsystem.events.RuntimeTerminateJobErrorEvent; |
| import org.eclipse.ptp.rtsystem.proxy.IProxyRuntimeClient; |
| import org.eclipse.ptp.rtsystem.proxy.IProxyRuntimeEventListener; |
| import org.eclipse.ptp.rtsystem.proxy.event.IProxyRuntimeAttributeDefEvent; |
| import org.eclipse.ptp.rtsystem.proxy.event.IProxyRuntimeConnectedStateEvent; |
| import org.eclipse.ptp.rtsystem.proxy.event.IProxyRuntimeErrorStateEvent; |
| import org.eclipse.ptp.rtsystem.proxy.event.IProxyRuntimeJobChangeEvent; |
| import org.eclipse.ptp.rtsystem.proxy.event.IProxyRuntimeMachineChangeEvent; |
| import org.eclipse.ptp.rtsystem.proxy.event.IProxyRuntimeMessageEvent; |
| import org.eclipse.ptp.rtsystem.proxy.event.IProxyRuntimeNewJobEvent; |
| import org.eclipse.ptp.rtsystem.proxy.event.IProxyRuntimeNewMachineEvent; |
| import org.eclipse.ptp.rtsystem.proxy.event.IProxyRuntimeNewNodeEvent; |
| import org.eclipse.ptp.rtsystem.proxy.event.IProxyRuntimeNewProcessEvent; |
| import org.eclipse.ptp.rtsystem.proxy.event.IProxyRuntimeNewQueueEvent; |
| import org.eclipse.ptp.rtsystem.proxy.event.IProxyRuntimeNodeChangeEvent; |
| import org.eclipse.ptp.rtsystem.proxy.event.IProxyRuntimeProcessChangeEvent; |
| import org.eclipse.ptp.rtsystem.proxy.event.IProxyRuntimeQueueChangeEvent; |
| import org.eclipse.ptp.rtsystem.proxy.event.IProxyRuntimeRemoveAllEvent; |
| import org.eclipse.ptp.rtsystem.proxy.event.IProxyRuntimeRemoveJobEvent; |
| import org.eclipse.ptp.rtsystem.proxy.event.IProxyRuntimeRemoveMachineEvent; |
| import org.eclipse.ptp.rtsystem.proxy.event.IProxyRuntimeRemoveNodeEvent; |
| import org.eclipse.ptp.rtsystem.proxy.event.IProxyRuntimeRemoveProcessEvent; |
| import org.eclipse.ptp.rtsystem.proxy.event.IProxyRuntimeRemoveQueueEvent; |
| import org.eclipse.ptp.rtsystem.proxy.event.IProxyRuntimeRunningStateEvent; |
| import org.eclipse.ptp.rtsystem.proxy.event.IProxyRuntimeShutdownStateEvent; |
| import org.eclipse.ptp.rtsystem.proxy.event.IProxyRuntimeStartupErrorEvent; |
| import org.eclipse.ptp.rtsystem.proxy.event.IProxyRuntimeSubmitJobErrorEvent; |
| import org.eclipse.ptp.rtsystem.proxy.event.IProxyRuntimeTerminateJobErrorEvent; |
| |
| /* |
| * ProxyAttributeDefEvents are formatted as follows: |
| * |
| * EVENT_HEADER NUM_DEFS ATTR_DEF ... ATTR_DEF |
| * |
| * where: |
| * |
| * EVENT_HEADER is the event message header |
| * NUM_DEFS is the number of attribute definitions to follow |
| * ATTR_DEF is an attribute definition of the form: |
| * |
| * NUM_ARGS ID TYPE NAME DESCRIPTION DISPLAY DEFAULT [ADDITIONAL_PARAMS] |
| * |
| * where: |
| * |
| * NUM_ARGS is the number of arguments in the attribute definition |
| * ID is a unique definition ID |
| * TYPE is the type of the attribute. Legal types are: |
| * 'BOOLEAN', 'DATE', 'DOUBLE', 'ENUMERATED', 'INTEGER', 'STRING', 'ARRAY' |
| * NAME is the short name of the attribute |
| * DESCRIPTION is the long name of the attribute |
| * DISPLAY is true if the attribute should be displayed in a UI |
| * DEFAULT is the default value of the attribute |
| * ADDITIONAL_PARAMS are optional parameters depending on the attribute type: |
| * BOOLEAN - none |
| * DATE - DATE_STYLE TIME_STYLE LOCALE [MIN MAX] |
| * DOUBLE - [MIN MAX] |
| * ENUMERATED - VAL ... VAL |
| * INTEGER - [MIN MAX] |
| * STRING - none |
| * ARRAY - none |
| * MIN is the minimum allowable value for the attribute |
| * MAX is the maximum allowable value for the attribute |
| * DATE_STYLE is the date format: SHORT, MEDIUM, LONG, or FULL |
| * TIME_STYLE is the time format: SHORT, MEDIUM, LONG, or FULL |
| * LOCALE is the country (see java.lang.Local) |
| * NUM_VALS is the number of enumerated values |
| * VAL is the enumerated value |
| * |
| * ProxyNew*Events are formatted as follows: |
| * |
| * EVENT_HEADER PARENT_ID NUM_RANGES ID_RANGE NUM_ATTRS KEY=VALUE ... KEY=VALUE ... |
| * |
| * where: |
| * |
| * EVENT_HEADER is the event message header |
| * PARENT_ID is the model element ID of the parent element |
| * NUM_RANGES is the number of ID_RANGEs to follow |
| * ID_RANGE is a range of model element ID's in RangeSet notation |
| * NUM_ATTRS is the number of attributes to follow |
| * KEY=VALUE are key/value pairs, where KEY is the attribute ID and VALUE is the attribute value |
| * |
| * Proxy*ChangeEvents are formatted as follows: |
| * |
| * EVENT_HEADER NUM_RANGES ID_RANGE NUM_ATTRS KEY=VALUE ... KEY=VALUE |
| * |
| * where: |
| * |
| * EVENT_HEADER is the event message header |
| * NUM_RANGES is the number of ID_RANGEs to follow |
| * ID_RANGE is a range of model element ID's in RangeSet notation |
| * NUM_ATTRS is the number of attributes to follow |
| * KEY=VALUE are key/value pairs, where KEY is the attribute ID and VALUE is the new attribute value |
| * |
| * ProxyRemove*Events (apart from ProxyRemoveAllEvent) are formatted as follows: |
| * |
| * EVENT_HEADER ID_RANGE |
| * |
| * where: |
| * |
| * EVENT_HEADER is the event message header |
| * ID_RANGE is a range of model element ID's in RangeSet notation. |
| * |
| * The ProxyRemoveAllEvent is formatted as follows: |
| * |
| * EVENT_HEADER |
| * |
| * where: |
| * |
| * EVENT_HEADER is the event message header |
| */ |
| |
| public abstract class AbstractProxyRuntimeSystem extends AbstractRuntimeSystem implements IProxyRuntimeEventListener { |
| |
| private final static int ATTR_MIN_LEN = 5; |
| protected IProxyRuntimeClient proxy = null; |
| private AttributeDefinitionManager attrDefManager; |
| private int jobSubIdCount = 0; |
| private Map<String, AttributeManager> jobSubs = Collections.synchronizedMap(new HashMap<String, AttributeManager>()); |
| |
| public AbstractProxyRuntimeSystem(IProxyRuntimeClient proxy, AttributeDefinitionManager manager) { |
| this.proxy = proxy; |
| this.attrDefManager = manager; |
| proxy.addProxyRuntimeEventListener(this); |
| } |
| |
| /* (non-Javadoc) |
| * @see org.eclipse.ptp.rtsystem.proxy.event.IProxyRuntimeEventListener#handleProxyRuntimeAttributeDefEvent(org.eclipse.ptp.rtsystem.proxy.event.IProxyRuntimeAttributeDefEvent) |
| */ |
| public void handleEvent(IProxyRuntimeAttributeDefEvent e) { |
| String[] attrs = e.getAttributes(); |
| |
| if (attrs.length >= ATTR_MIN_LEN + 2) { |
| try { |
| int numDefs = Integer.parseInt(attrs[0]); |
| |
| ArrayList<IAttributeDefinition<?,?,?>> attrDefs = |
| new ArrayList<IAttributeDefinition<?,?,?>>(numDefs); |
| |
| int pos = 1; |
| |
| for (int i = 0; i < numDefs; i++) { |
| int numArgs = Integer.parseInt(attrs[pos]); |
| |
| if (numArgs >= ATTR_MIN_LEN && pos + numArgs < attrs.length) { |
| IAttributeDefinition<?,?,?> attrDef = |
| parseAttributeDefinition(attrs, pos + 1, pos + numArgs); |
| if (attrDef != null) { |
| attrDefs.add(attrDef); |
| } |
| pos += numArgs + 1; |
| } else { |
| fireRuntimeMessageEvent(new RuntimeMessageEvent(Level.ERROR, "Bad proxy event: bad arg count")); |
| return; |
| } |
| } |
| |
| fireRuntimeAttributeDefinitionEvent(new RuntimeAttributeDefinitionEvent(attrDefs.toArray(new IAttributeDefinition[attrDefs.size()]))); |
| } catch (NumberFormatException ex) { |
| fireRuntimeMessageEvent(new RuntimeMessageEvent(Level.ERROR, "Bad proxy event: could not convert arg to integer")); |
| } |
| } else { |
| fireRuntimeMessageEvent(new RuntimeMessageEvent(Level.ERROR, "Bad proxy event: not enough arguments")); |
| } |
| } |
| |
| /* (non-Javadoc) |
| * @see org.eclipse.ptp.rtsystem.proxy.IProxyRuntimeEventListener#handleProxyRuntimeErrorStateEvent(org.eclipse.ptp.rtsystem.proxy.event.IProxyRuntimeErrorStateEvent) |
| */ |
| public void handleEvent(IProxyRuntimeErrorStateEvent e) { |
| fireRuntimeErrorStateEvent(new RuntimeErrorStateEvent()); |
| } |
| |
| /* (non-Javadoc) |
| * @see org.eclipse.ptp.rtsystem.proxy.event.IProxyRuntimeEventListener#handleProxyRuntimeErrorEvent(org.eclipse.ptp.rtsystem.proxy.event.IProxyRuntimeErrorEvent) |
| */ |
| public void handleEvent(IProxyRuntimeMessageEvent e) { |
| String[] attrs = e.getAttributes(); |
| |
| if (attrs.length > 0) { |
| AttributeManager mgr = getAttributeManager(attrs, 0, attrs.length - 1); |
| fireRuntimeMessageEvent(new RuntimeMessageEvent(mgr)); |
| } else { |
| fireRuntimeMessageEvent(new RuntimeMessageEvent(Level.ERROR, "AbstractProxyRuntimeSystem: could not parse message")); |
| } |
| } |
| |
| /* (non-Javadoc) |
| * @see org.eclipse.ptp.rtsystem.proxy.event.IProxyRuntimeEventListener#handleProxyRuntimeJobChangeEvent(org.eclipse.ptp.rtsystem.proxy.event.IProxyRuntimeJobChangeEvent) |
| */ |
| public void handleEvent(IProxyRuntimeJobChangeEvent e) { |
| String[] attrs = e.getAttributes(); |
| |
| if (attrs.length < 1) { |
| fireRuntimeMessageEvent(new RuntimeMessageEvent(Level.ERROR, "AbstractProxyRuntimeSystem: not enough arguments")); |
| return; |
| } |
| |
| ElementAttributeManager eMgr = getElementAttributeManager(attrs, 0); |
| if (eMgr != null) { |
| fireRuntimeJobChangeEvent(new RuntimeJobChangeEvent(eMgr)); |
| } else { |
| fireRuntimeMessageEvent(new RuntimeMessageEvent(Level.ERROR, "AbstractProxyRuntimeSystem: could not parse message")); |
| } |
| } |
| |
| /* (non-Javadoc) |
| * @see org.eclipse.ptp.rtsystem.proxy.event.IProxyRuntimeEventListener#handleProxyRuntimeMachineChangeEvent(org.eclipse.ptp.rtsystem.proxy.event.IProxyRuntimeMachineChangeEvent) |
| */ |
| public void handleEvent(IProxyRuntimeMachineChangeEvent e) { |
| String[] attrs = e.getAttributes(); |
| |
| if (attrs.length < 1) { |
| fireRuntimeMessageEvent(new RuntimeMessageEvent(Level.ERROR, "AbstractProxyRuntimeSystem: not enough arguments")); |
| return; |
| } |
| |
| ElementAttributeManager eMgr = getElementAttributeManager(attrs, 0); |
| if (eMgr != null) { |
| fireRuntimeMachineChangeEvent(new RuntimeMachineChangeEvent(eMgr)); |
| } else { |
| fireRuntimeMessageEvent(new RuntimeMessageEvent(Level.ERROR, "AbstractProxyRuntimeSystem: could not parse message")); |
| } |
| } |
| |
| /* (non-Javadoc) |
| * @see org.eclipse.ptp.rtsystem.proxy.event.IProxyRuntimeEventListener#handleProxyRuntimeNewJobEvent(org.eclipse.ptp.rtsystem.proxy.event.IProxyRuntimeNewJobEvent) |
| */ |
| public void handleEvent(IProxyRuntimeNewJobEvent e) { |
| String[] attrs = e.getAttributes(); |
| |
| if (attrs.length < 2) { |
| fireRuntimeMessageEvent(new RuntimeMessageEvent(Level.ERROR, "AbstractProxyRuntimeSystem: not enough arguments")); |
| return; |
| } |
| |
| ElementAttributeManager eMgr = getElementAttributeManager(attrs, 1); |
| |
| if (eMgr != null) { |
| /* |
| * Find any job submission attributes and add to the jobs |
| */ |
| for (Map.Entry<RangeSet, AttributeManager> entry : eMgr.getEntrySet()) { |
| StringAttribute subIdAttr = entry.getValue().getAttribute(JobAttributes.getSubIdAttributeDefinition()); |
| if (subIdAttr != null) { |
| String subId = subIdAttr.getValueAsString(); |
| AttributeManager mgr = jobSubs.get(subId); |
| if (mgr != null) { |
| entry.getValue().addAttributes(mgr.getAttributes()); |
| } |
| jobSubs.remove(subId); |
| } |
| } |
| |
| fireRuntimeNewJobEvent(new RuntimeNewJobEvent(attrs[0], eMgr)); |
| } else { |
| fireRuntimeMessageEvent(new RuntimeMessageEvent(Level.ERROR, "AbstractProxyRuntimeSystem: could not parse message")); |
| } |
| } |
| |
| /* (non-Javadoc) |
| * @see org.eclipse.ptp.rtsystem.proxy.event.IProxyRuntimeEventListener#handleProxyRuntimeNewMachineEvent(org.eclipse.ptp.rtsystem.proxy.event.IProxyRuntimeNewMachineEvent) |
| */ |
| public void handleEvent(IProxyRuntimeNewMachineEvent e) { |
| String[] attrs = e.getAttributes(); |
| |
| if (attrs.length < 2) { |
| fireRuntimeMessageEvent(new RuntimeMessageEvent(Level.ERROR, "AbstractProxyRuntimeSystem: not enough arguments")); |
| return; |
| } |
| |
| ElementAttributeManager eMgr = getElementAttributeManager(attrs, 1); |
| if (eMgr != null) { |
| fireRuntimeNewMachineEvent(new RuntimeNewMachineEvent(attrs[0], eMgr)); |
| } else { |
| fireRuntimeMessageEvent(new RuntimeMessageEvent(Level.ERROR, "AbstractProxyRuntimeSystem: could not parse message")); |
| } |
| } |
| |
| /* (non-Javadoc) |
| * @see org.eclipse.ptp.rtsystem.proxy.event.IProxyRuntimeEventListener#handleProxyRuntimeNewNodeEvent(org.eclipse.ptp.rtsystem.proxy.event.IProxyRuntimeNewNodeEvent) |
| */ |
| public void handleEvent(IProxyRuntimeNewNodeEvent e) { |
| String[] attrs = e.getAttributes(); |
| |
| if (attrs.length < 2) { |
| fireRuntimeMessageEvent(new RuntimeMessageEvent(Level.ERROR, "AbstractProxyRuntimeSystem: not enough arguments")); |
| return; |
| } |
| |
| ElementAttributeManager eMgr = getElementAttributeManager(attrs, 1); |
| if (eMgr != null) { |
| fireRuntimeNewNodeEvent(new RuntimeNewNodeEvent(attrs[0], eMgr)); |
| } else { |
| fireRuntimeMessageEvent(new RuntimeMessageEvent(Level.ERROR, "AbstractProxyRuntimeSystem: could not parse message")); |
| } |
| } |
| |
| /* (non-Javadoc) |
| * @see org.eclipse.ptp.rtsystem.proxy.event.IProxyRuntimeEventListener#handleProxyRuntimeNewProcessEvent(org.eclipse.ptp.rtsystem.proxy.event.IProxyRuntimeNewProcessEvent) |
| */ |
| public void handleEvent(IProxyRuntimeNewProcessEvent e) { |
| String[] attrs = e.getAttributes(); |
| |
| if (attrs.length < 2) { |
| fireRuntimeMessageEvent(new RuntimeMessageEvent(Level.ERROR, "AbstractProxyRuntimeSystem: not enough arguments")); |
| return; |
| } |
| |
| ElementAttributeManager eMgr = getElementAttributeManager(attrs, 1); |
| if (eMgr != null) { |
| fireRuntimeNewProcessEvent(new RuntimeNewProcessEvent(attrs[0], eMgr)); |
| } else { |
| fireRuntimeMessageEvent(new RuntimeMessageEvent(Level.ERROR, "AbstractProxyRuntimeSystem: could not parse message")); |
| } |
| } |
| |
| /* (non-Javadoc) |
| * @see org.eclipse.ptp.rtsystem.proxy.event.IProxyRuntimeEventListener#handleProxyRuntimeNewQueueEvent(org.eclipse.ptp.rtsystem.proxy.event.IProxyRuntimeNewQueueEvent) |
| */ |
| public void handleEvent(IProxyRuntimeNewQueueEvent e) { |
| String[] attrs = e.getAttributes(); |
| |
| if (attrs.length < 2) { |
| fireRuntimeMessageEvent(new RuntimeMessageEvent(Level.ERROR, "AbstractProxyRuntimeSystem: not enough arguments")); |
| return; |
| } |
| |
| ElementAttributeManager eMgr = getElementAttributeManager(attrs, 1); |
| if (eMgr != null) { |
| fireRuntimeNewQueueEvent(new RuntimeNewQueueEvent(attrs[0], eMgr)); |
| } else { |
| fireRuntimeMessageEvent(new RuntimeMessageEvent(Level.ERROR, "AbstractProxyRuntimeSystem: could not parse message")); |
| } |
| } |
| |
| /* (non-Javadoc) |
| * @see org.eclipse.ptp.rtsystem.proxy.event.IProxyRuntimeEventListener#handleProxyRuntimeNodeChangeEvent(org.eclipse.ptp.rtsystem.proxy.event.IProxyRuntimeNodeChangeEvent) |
| */ |
| public void handleEvent(IProxyRuntimeNodeChangeEvent e) { |
| String[] attrs = e.getAttributes(); |
| |
| if (attrs.length < 1) { |
| fireRuntimeMessageEvent(new RuntimeMessageEvent(Level.ERROR, "AbstractProxyRuntimeSystem: not enough arguments")); |
| return; |
| } |
| |
| ElementAttributeManager eMgr = getElementAttributeManager(attrs, 0); |
| if (eMgr != null) { |
| fireRuntimeNodeChangeEvent(new RuntimeNodeChangeEvent(eMgr)); |
| } else { |
| fireRuntimeMessageEvent(new RuntimeMessageEvent(Level.ERROR, "AbstractProxyRuntimeSystem: could not parse message")); |
| } |
| } |
| |
| /* (non-Javadoc) |
| * @see org.eclipse.ptp.rtsystem.proxy.event.IProxyRuntimeEventListener#handleProxyRuntimeProcessChangeEvent(org.eclipse.ptp.rtsystem.proxy.event.IProxyRuntimeProcessChangeEvent) |
| */ |
| public void handleEvent(IProxyRuntimeProcessChangeEvent e) { |
| String[] attrs = e.getAttributes(); |
| |
| if (attrs.length < 1) { |
| fireRuntimeMessageEvent(new RuntimeMessageEvent(Level.ERROR, "AbstractProxyRuntimeSystem: not enough arguments")); |
| return; |
| } |
| |
| ElementAttributeManager eMgr = getElementAttributeManager(attrs, 0); |
| if (eMgr != null) { |
| fireRuntimeProcessChangeEvent(new RuntimeProcessChangeEvent(eMgr)); |
| } else { |
| fireRuntimeMessageEvent(new RuntimeMessageEvent(Level.ERROR, "AbstractProxyRuntimeSystem: could not parse message")); |
| } |
| } |
| |
| /* (non-Javadoc) |
| * @see org.eclipse.ptp.rtsystem.proxy.event.IProxyRuntimeEventListener#handleProxyRuntimeQueueChangeEvent(org.eclipse.ptp.rtsystem.proxy.event.IProxyRuntimeQueueChangeEvent) |
| */ |
| public void handleEvent(IProxyRuntimeQueueChangeEvent e) { |
| String[] attrs = e.getAttributes(); |
| |
| if (attrs.length < 1) { |
| fireRuntimeMessageEvent(new RuntimeMessageEvent(Level.ERROR, "AbstractProxyRuntimeSystem: not enough arguments")); |
| return; |
| } |
| |
| ElementAttributeManager eMgr = getElementAttributeManager(attrs, 0); |
| if (eMgr != null) { |
| fireRuntimeQueueChangeEvent(new RuntimeQueueChangeEvent(eMgr)); |
| } else { |
| fireRuntimeMessageEvent(new RuntimeMessageEvent(Level.ERROR, "AbstractProxyRuntimeSystem: could not parse message")); |
| } |
| } |
| |
| /* (non-Javadoc) |
| * @see org.eclipse.ptp.rtsystem.proxy.event.IProxyRuntimeEventListener#handleProxyRuntimeConnectedStateEvent(org.eclipse.ptp.rtsystem.proxy.event.IProxyRuntimeConnectedStateEvent) |
| */ |
| public void handleEvent(IProxyRuntimeConnectedStateEvent e) { |
| fireRuntimeConnectedStateEvent(new RuntimeConnectedStateEvent()); |
| } |
| |
| /* (non-Javadoc) |
| * @see org.eclipse.ptp.rtsystem.proxy.IProxyRuntimeEventListener#handleProxyRuntimeRemoveAllEvent(org.eclipse.ptp.rtsystem.proxy.event.IProxyRuntimeRemoveAllEvent) |
| */ |
| public void handleEvent(IProxyRuntimeRemoveAllEvent e) { |
| fireRuntimeRemoveAllEvent(new RuntimeRemoveAllEvent()); |
| } |
| |
| /* (non-Javadoc) |
| * @see org.eclipse.ptp.rtsystem.proxy.event.IProxyRuntimeEventListener#handleProxyRuntimeRemoveJobEvent(org.eclipse.ptp.rtsystem.proxy.event.IProxyRuntimeRemoveJobEvent) |
| */ |
| public void handleEvent(IProxyRuntimeRemoveJobEvent e) { |
| String[] attrs = e.getAttributes(); |
| |
| if (attrs.length < 1) { |
| fireRuntimeMessageEvent(new RuntimeMessageEvent(Level.ERROR, "AbstractProxyRuntimeSystem: not enough arguments")); |
| return; |
| } |
| |
| fireRuntimeRemoveJobEvent(new RuntimeRemoveJobEvent(new RangeSet(attrs[0]))); |
| } |
| |
| /* (non-Javadoc) |
| * @see org.eclipse.ptp.rtsystem.proxy.event.IProxyRuntimeEventListener#handleProxyRuntimeRemoveMachineEvent(org.eclipse.ptp.rtsystem.proxy.event.IProxyRuntimeRemoveMachineEvent) |
| */ |
| public void handleEvent(IProxyRuntimeRemoveMachineEvent e) { |
| String[] attrs = e.getAttributes(); |
| |
| if (attrs.length < 1) { |
| fireRuntimeMessageEvent(new RuntimeMessageEvent(Level.ERROR, "AbstractProxyRuntimeSystem: not enough arguments")); |
| return; |
| } |
| |
| fireRuntimeRemoveMachineEvent(new RuntimeRemoveMachineEvent(new RangeSet(attrs[0]))); |
| } |
| |
| /* (non-Javadoc) |
| * @see org.eclipse.ptp.rtsystem.proxy.event.IProxyRuntimeEventListener#handleProxyRuntimeRemoveNodeEvent(org.eclipse.ptp.rtsystem.proxy.event.IProxyRuntimeRemoveNodeEvent) |
| */ |
| public void handleEvent(IProxyRuntimeRemoveNodeEvent e) { |
| String[] attrs = e.getAttributes(); |
| |
| if (attrs.length < 1) { |
| fireRuntimeMessageEvent(new RuntimeMessageEvent(Level.ERROR, "AbstractProxyRuntimeSystem: not enough arguments")); |
| return; |
| } |
| |
| fireRuntimeRemoveNodeEvent(new RuntimeRemoveNodeEvent(new RangeSet(attrs[0]))); |
| } |
| |
| /* (non-Javadoc) |
| * @see org.eclipse.ptp.rtsystem.proxy.event.IProxyRuntimeEventListener#handleProxyRuntimeRemoveProcessEvent(org.eclipse.ptp.rtsystem.proxy.event.IProxyRuntimeRemoveProcessEvent) |
| */ |
| public void handleEvent(IProxyRuntimeRemoveProcessEvent e) { |
| String[] attrs = e.getAttributes(); |
| |
| if (attrs.length < 1) { |
| fireRuntimeMessageEvent(new RuntimeMessageEvent(Level.ERROR, "AbstractProxyRuntimeSystem: not enough arguments")); |
| return; |
| } |
| |
| fireRuntimeRemoveProcessEvent(new RuntimeRemoveProcessEvent(new RangeSet(attrs[0]))); |
| } |
| |
| /* (non-Javadoc) |
| * @see org.eclipse.ptp.rtsystem.proxy.event.IProxyRuntimeEventListener#handleProxyRuntimeRemoveQueueEvent(org.eclipse.ptp.rtsystem.proxy.event.IProxyRuntimeRemoveQueueEvent) |
| */ |
| public void handleEvent(IProxyRuntimeRemoveQueueEvent e) { |
| String[] attrs = e.getAttributes(); |
| |
| if (attrs.length < 1) { |
| fireRuntimeMessageEvent(new RuntimeMessageEvent(Level.ERROR, "AbstractProxyRuntimeSystem: not enough arguments")); |
| return; |
| } |
| |
| fireRuntimeRemoveQueueEvent(new RuntimeRemoveQueueEvent(new RangeSet(attrs[0]))); |
| } |
| |
| /* (non-Javadoc) |
| * @see org.eclipse.ptp.rtsystem.proxy.event.IProxyRuntimeEventListener#handleProxyRuntimeRunningStateEvent(org.eclipse.ptp.rtsystem.proxy.event.IProxyRuntimeRunningStateEvent) |
| */ |
| public void handleEvent(IProxyRuntimeRunningStateEvent e) { |
| fireRuntimeRunningStateEvent(new RuntimeRunningStateEvent()); |
| } |
| |
| /* (non-Javadoc) |
| * @see org.eclipse.ptp.rtsystem.proxy.event.IProxyRuntimeEventListener#handleProxyRuntimeShutdownStateEvent(org.eclipse.ptp.rtsystem.proxy.event.IProxyRuntimeShutdownStateEvent) |
| */ |
| public void handleEvent(IProxyRuntimeShutdownStateEvent e) { |
| fireRuntimeShutdownStateEvent(new RuntimeShutdownStateEvent()); |
| } |
| |
| /* (non-Javadoc) |
| * @see org.eclipse.ptp.rtsystem.proxy.event.IProxyRuntimeEventListener#handleProxyRuntimeStartupErrorEvent(org.eclipse.ptp.rtsystem.proxy.event.IProxyRuntimeStartupErrorEvent) |
| */ |
| public void handleEvent( |
| IProxyRuntimeStartupErrorEvent e) { |
| String[] attrs = e.getAttributes(); |
| |
| if (attrs.length > 0) { |
| AttributeManager mgr = getAttributeManager(attrs, 0, attrs.length - 1); |
| IntegerAttribute codeAttr = mgr.getAttribute(ErrorAttributes.getCodeAttributeDefinition()); |
| StringAttribute msgAttr = mgr.getAttribute(ErrorAttributes.getMsgAttributeDefinition()); |
| if (codeAttr == null || msgAttr == null) { |
| fireRuntimeMessageEvent(new RuntimeMessageEvent(Level.ERROR, "StartupErrorEvent: missing attibutes")); |
| } else { |
| fireRuntimeStartupErrorEvent(new RuntimeStartupErrorEvent(codeAttr.getValue(), msgAttr.getValue())); |
| } |
| } else { |
| fireRuntimeMessageEvent(new RuntimeMessageEvent(Level.ERROR, "StartupErrorEvent: could not parse message")); |
| } |
| } |
| |
| /* (non-Javadoc) |
| * @see org.eclipse.ptp.rtsystem.proxy.event.IProxyRuntimeEventListener#handleProxyRuntimeSubmitJobErrorEvent(org.eclipse.ptp.rtsystem.proxy.event.IProxyRuntimeSubmitJobErrorEvent) |
| */ |
| public void handleEvent( |
| IProxyRuntimeSubmitJobErrorEvent e) { |
| String[] attrs = e.getAttributes(); |
| |
| if (attrs.length > 0) { |
| AttributeManager mgr = getAttributeManager(attrs, 0, attrs.length - 1); |
| IntegerAttribute codeAttr = (IntegerAttribute) mgr.getAttribute(ErrorAttributes.getCodeAttributeDefinition()); |
| StringAttribute msgAttr = (StringAttribute) mgr.getAttribute(ErrorAttributes.getMsgAttributeDefinition()); |
| StringAttribute jobSubIdAttr = (StringAttribute) mgr.getAttribute(JobAttributes.getSubIdAttributeDefinition()); |
| if (codeAttr == null || msgAttr == null || jobSubIdAttr == null) { |
| fireRuntimeMessageEvent(new RuntimeMessageEvent(Level.ERROR, "SubmitJobErrorEvent: missing attibutes")); |
| } else { |
| fireRuntimeSubmitJobErrorEvent(new RuntimeSubmitJobErrorEvent(codeAttr.getValue(), msgAttr.getValue(), jobSubIdAttr.getValue())); |
| } |
| } else { |
| fireRuntimeMessageEvent(new RuntimeMessageEvent(Level.ERROR, "SubmitJobErrorEvent: could not parse message")); |
| } |
| } |
| |
| /* (non-Javadoc) |
| * @see org.eclipse.ptp.rtsystem.proxy.event.IProxyRuntimeEventListener#handleProxyRuntimeTerminateJobErrorEvent(org.eclipse.ptp.rtsystem.proxy.event.IProxyRuntimeTerminateJobErrorEvent) |
| */ |
| public void handleEvent( |
| IProxyRuntimeTerminateJobErrorEvent e) { |
| String[] attrs = e.getAttributes(); |
| |
| if (attrs.length > 0) { |
| AttributeManager mgr = getAttributeManager(attrs, 0, attrs.length - 1); |
| IntegerAttribute codeAttr = (IntegerAttribute) mgr.getAttribute(ErrorAttributes.getCodeAttributeDefinition()); |
| StringAttribute msgAttr = (StringAttribute) mgr.getAttribute(ErrorAttributes.getMsgAttributeDefinition()); |
| StringAttribute jobIdAttr = (StringAttribute) mgr.getAttribute(ElementAttributes.getIdAttributeDefinition()); |
| if (codeAttr == null || msgAttr == null || jobIdAttr == null) { |
| fireRuntimeMessageEvent(new RuntimeMessageEvent(Level.ERROR, "TerminateJobErrorEvent: missing attibutes")); |
| } else { |
| fireRuntimeTerminateJobErrorEvent(new RuntimeTerminateJobErrorEvent(codeAttr.getValue(), msgAttr.getValue(), jobIdAttr.getValue())); |
| } |
| } else { |
| fireRuntimeMessageEvent(new RuntimeMessageEvent(Level.ERROR, "TerminateJobErrorEvent: could not parse message")); |
| } |
| } |
| |
| /* (non-Javadoc) |
| * @see org.eclipse.ptp.rtsystem.IRuntimeSystem#shutdown() |
| */ |
| public void shutdown() { |
| proxy.shutdown(); |
| } |
| |
| /* (non-Javadoc) |
| * @see org.eclipse.ptp.rtsystem.IRuntimeSystem#startup() |
| */ |
| public boolean startup() throws CoreException { |
| return proxy.startup(); |
| } |
| |
| public String submitJob(AttributeManager attrMgr) throws CoreException { |
| try { |
| /* |
| * Add the job submission ID to the attributes. This is done here to force the |
| * use of the ID. |
| */ |
| String id = getJobSubmissionID(); |
| StringAttribute jobSubAttr = JobAttributes.getSubIdAttributeDefinition().create(id); |
| attrMgr.addAttribute(jobSubAttr); |
| proxy.submitJob(attrMgr.toStringArray()); |
| jobSubs.put(id, attrMgr); |
| return id; |
| } catch(IOException e) { |
| throw new CoreException(new Status(IStatus.ERROR, PTPCorePlugin.getUniqueIdentifier(), IStatus.ERROR, |
| "Control system is shut down, proxy exception. The proxy may have crashed or been killed.", null)); |
| } |
| } |
| |
| /* (non-Javadoc) |
| * @see org.eclipse.ptp.rtsystem.IControlSystem#terminateJob(org.eclipse.ptp.core.elements.IPJob) |
| */ |
| public void terminateJob(IPJob job) throws CoreException { |
| if(job == null) { |
| System.err.println("ERROR: Tried to abort a null job."); |
| return; |
| } |
| |
| try { |
| proxy.terminateJob(job.getID()); |
| } catch(IOException e) { |
| throw new CoreException(new Status(IStatus.ERROR, PTPCorePlugin.getUniqueIdentifier(), IStatus.ERROR, |
| "Control system is shut down, proxy exception. The proxy may have crashed or been killed.", null)); |
| } |
| } |
| |
| /* (non-Javadoc) |
| * @see org.eclipse.ptp.rtsystem.IMonitoringSystem#startEvents() |
| */ |
| public void startEvents() throws CoreException { |
| try { |
| proxy.startEvents(); |
| } catch (IOException e) { |
| throw new CoreException(new Status(IStatus.ERROR, PTPCorePlugin.getUniqueIdentifier(), IStatus.ERROR, |
| e.getMessage(), e)); |
| } |
| } |
| |
| /* (non-Javadoc) |
| * @see org.eclipse.ptp.rtsystem.IMonitoringSystem#stopEvents() |
| */ |
| public void stopEvents() throws CoreException { |
| try { |
| proxy.stopEvents(); |
| } catch (IOException e) { |
| throw new CoreException(new Status(IStatus.ERROR, PTPCorePlugin.getUniqueIdentifier(), IStatus.ERROR, |
| e.getMessage(), e)); |
| } |
| } |
| |
| /** |
| * @param kvs |
| * @param start |
| * @param end |
| * @return |
| */ |
| private AttributeManager getAttributeManager(String[] kvs, int start, int end) { |
| AttributeManager mgr = new AttributeManager(); |
| |
| for (int i = start; i <= end; i++) { |
| String[] kv = kvs[i].split("="); |
| if (kv.length == 2) { |
| try { |
| IAttributeDefinition<?,?,?> attrDef = attrDefManager.getAttributeDefinition(kv[0]); |
| if(attrDef != null) { |
| IAttribute<?,?,?> attr = attrDef.create(kv[1]); |
| mgr.addAttribute(attr); |
| } else { |
| System.out.println("AbstractProxyRuntimSystem: unknown attribute definition"); |
| } |
| } catch (IllegalValueException e1) { |
| System.out.println("AbstractProxyRuntimSystem: invalid attribute for definition"); |
| } |
| } |
| } |
| |
| return mgr; |
| } |
| |
| /** |
| * @param attrs |
| * @param pos |
| * @return |
| */ |
| private ElementAttributeManager getElementAttributeManager(String[] attrs, int pos) { |
| ElementAttributeManager eMgr = new ElementAttributeManager(); |
| |
| try { |
| int numRanges = Integer.parseInt(attrs[pos++]); |
| |
| for (int i = 0; i < numRanges; i++) { |
| if (pos >= attrs.length) { |
| return null; |
| } |
| |
| RangeSet ids = new RangeSet(attrs[pos++]); |
| int numAttrs = Integer.parseInt(attrs[pos++]); |
| |
| int start = pos; |
| int end = pos + numAttrs - 1; |
| |
| if (end >= attrs.length) { |
| return null; |
| } |
| |
| eMgr.setAttributeManager(ids, getAttributeManager(attrs, start, end)); |
| |
| pos = end + 1; |
| } |
| } catch (NumberFormatException e1) { |
| return null; |
| } |
| |
| return eMgr; |
| } |
| |
| /** |
| * Parse and extract an attribute definition. |
| * |
| * On entry, we know that end < attrs.length and end - start >= ATTR_MIN_LEN |
| * |
| */ |
| private IAttributeDefinition<?,?,?> parseAttributeDefinition(String[] attrs, int start, int end) { |
| int pos = start; |
| IAttributeDefinition<?,?,?> attrDef = null; |
| |
| String attrId = attrs[pos++]; |
| String attrType = attrs[pos++]; |
| String attrName = attrs[pos++]; |
| String attrDesc = attrs[pos++]; |
| boolean attrDisplay; |
| |
| try { |
| attrDisplay = Boolean.parseBoolean(attrs[pos++]); |
| } catch (NumberFormatException ex) { |
| fireRuntimeMessageEvent(new RuntimeMessageEvent(Level.ERROR, |
| "Bad proxy event: could not convert attr to boolean")); |
| return null; |
| } |
| |
| String attrDefault = attrs[pos++]; |
| |
| if (attrType.equals("BOOLEAN")) { |
| try { |
| Boolean defVal = Boolean.parseBoolean(attrDefault); |
| attrDef = attrDefManager.createBooleanAttributeDefinition(attrId, attrName, attrDesc, attrDisplay, defVal); |
| } catch (NumberFormatException ex) { |
| fireRuntimeMessageEvent(new RuntimeMessageEvent(Level.ERROR, |
| "Bad proxy event: could not convert attrs to boolean")); |
| } |
| } else if (attrType.equals("DATE")) { |
| if (end - pos > 2) { |
| try { |
| int dateStyle = toDateStyle(attrs[pos++]); |
| int timeStyle = toDateStyle(attrs[pos++]); |
| Locale locale = toLocale(attrs[pos++]); |
| |
| DateFormat fmt = DateFormat.getDateTimeInstance(dateStyle, timeStyle, locale); |
| Date defVal = fmt.parse(attrDefault); |
| |
| if (end - pos > 1) { |
| Date min = fmt.parse(attrs[pos++]); |
| Date max = fmt.parse(attrs[pos++]); |
| attrDef = attrDefManager.createDateAttributeDefinition(attrId, attrName, attrDesc, attrDisplay, defVal, fmt, min, max); |
| } else { |
| attrDef = attrDefManager.createDateAttributeDefinition(attrId, attrName, attrDesc, attrDisplay, defVal, fmt); |
| } |
| } catch (ParseException ex) { |
| fireRuntimeMessageEvent(new RuntimeMessageEvent(Level.ERROR, |
| "Bad proxy event: could not parse date")); |
| } catch (IllegalValueException ex) { |
| fireRuntimeMessageEvent(new RuntimeMessageEvent(Level.ERROR, |
| "Bad proxy event: could not create attribute definition, " |
| + ex.getMessage())); |
| } |
| } else { |
| fireRuntimeMessageEvent(new RuntimeMessageEvent(Level.ERROR, |
| "Bad proxy event: missing date format")); |
| } |
| } else if (attrType.equals("DOUBLE")) { |
| try { |
| Double defVal = Double.parseDouble(attrDefault); |
| if (end - pos > 0) { |
| Double min = Double.parseDouble(attrs[pos++]); |
| Double max = Double.parseDouble(attrs[pos++]); |
| attrDef = attrDefManager.createDoubleAttributeDefinition(attrId, attrName, attrDesc, attrDisplay, defVal, min, max); |
| } else { |
| attrDef = attrDefManager.createDoubleAttributeDefinition(attrId, attrName, attrDesc, attrDisplay, defVal); |
| } |
| } catch (NumberFormatException ex) { |
| fireRuntimeMessageEvent(new RuntimeMessageEvent(Level.ERROR, |
| "Bad proxy event: could not convert args to double")); |
| } catch (IllegalValueException ex) { |
| fireRuntimeMessageEvent(new RuntimeMessageEvent(Level.ERROR, |
| "Bad proxy event: could not create attribute definition, " |
| + ex.getMessage())); |
| } |
| } else if (attrType.equals("ENUMERATED")) { |
| ArrayList<String> values = new ArrayList<String>(); |
| while (pos <= end) { |
| values.add(attrs[pos++]); |
| } |
| try { |
| attrDef = attrDefManager.createStringSetAttributeDefinition(attrId, attrName, |
| attrDesc, attrDisplay, attrDefault, values.toArray(new String[values.size()])); |
| } catch (IllegalValueException ex) { |
| fireRuntimeMessageEvent(new RuntimeMessageEvent(Level.ERROR, |
| "Bad proxy event: could not create attribute definition, " |
| + ex.getMessage())); |
| } |
| } else if (attrType.equals("INTEGER")) { |
| try { |
| Integer defVal = Integer.parseInt(attrDefault); |
| if (end - pos > 0) { |
| Integer min = Integer.parseInt(attrs[pos++]); |
| Integer max = Integer.parseInt(attrs[pos++]); |
| attrDef = attrDefManager.createIntegerAttributeDefinition(attrId, attrName, attrDesc, attrDisplay, defVal, min, max); |
| } else { |
| attrDef = attrDefManager.createIntegerAttributeDefinition(attrId, attrName, attrDesc, attrDisplay, defVal); |
| } |
| } catch (NumberFormatException ex) { |
| fireRuntimeMessageEvent(new RuntimeMessageEvent(Level.ERROR, |
| "Bad proxy event: could not convert args to integer")); |
| } catch (IllegalValueException ex) { |
| fireRuntimeMessageEvent(new RuntimeMessageEvent(Level.ERROR, |
| "Bad proxy event: could not create attribute definition, " |
| + ex.getMessage())); |
| } |
| } else if (attrType.equals("BIGINTEGER")) { |
| try { |
| BigInteger defVal = new BigInteger(attrDefault); |
| if (end - pos > 0) { |
| BigInteger min = new BigInteger(attrs[pos++]); |
| BigInteger max = new BigInteger(attrs[pos++]); |
| attrDef = attrDefManager.createBigIntegerAttributeDefinition(attrId, |
| attrName, attrDesc, attrDisplay, defVal, min, max); |
| } else { |
| attrDef = attrDefManager.createBigIntegerAttributeDefinition(attrId, attrName, |
| attrDesc, attrDisplay, defVal); |
| } |
| } catch (NumberFormatException ex) { |
| fireRuntimeMessageEvent(new RuntimeMessageEvent(Level.ERROR, |
| "Bad proxy event: could not convert args to BigInteger")); |
| } catch (IllegalValueException ex) { |
| fireRuntimeMessageEvent(new RuntimeMessageEvent(Level.ERROR, |
| "Bad proxy event: could not create attribute definition, " |
| + ex.getMessage())); |
| } |
| } else if (attrType.equals("STRING")) { |
| attrDef = attrDefManager.createStringAttributeDefinition(attrId, attrName, attrDesc, attrDisplay, attrDefault); |
| } else { |
| fireRuntimeMessageEvent(new RuntimeMessageEvent(Level.ERROR, |
| "Bad proxy event: unknown attribute type")); |
| } |
| |
| return attrDef; |
| } |
| |
| /** |
| * @param val |
| * @return |
| */ |
| private int toDateStyle(String val) { |
| if (val.equals("SHORT")) { |
| return DateFormat.SHORT; |
| } else if (val.equals("MEDIUM")) { |
| return DateFormat.MEDIUM; |
| } else if (val.equals("LONG")) { |
| return DateFormat.LONG; |
| } else if (val.equals("FULL")) { |
| return DateFormat.FULL; |
| } else { |
| return DateFormat.DEFAULT; |
| } |
| } |
| |
| /** |
| * @param val |
| * @return |
| */ |
| private Locale toLocale(String val) { |
| if (val.equals("CANADA")) { |
| return Locale.CANADA; |
| } else if (val.equals("CHINA")) { |
| return Locale.CHINA; |
| } else if (val.equals("FRANCE")) { |
| return Locale.FRANCE; |
| } else if (val.equals("GERMANY")) { |
| return Locale.GERMANY; |
| } else if (val.equals("ITALY")) { |
| return Locale.ITALY; |
| } else if (val.equals("JAPAN")) { |
| return Locale.JAPAN; |
| } else if (val.equals("TAIWAN")) { |
| return Locale.TAIWAN; |
| } else if (val.equals("UK")) { |
| return Locale.UK; |
| } else if (val.equals("US")) { |
| return Locale.US; |
| } else { |
| return Locale.US; |
| } |
| } |
| |
| private String getJobSubmissionID() { |
| long time = System.currentTimeMillis(); |
| return "JOB_" + Long.toString(time) + Integer.toString(jobSubIdCount++); |
| } |
| } |
