/*
* Licensed to the Apache Software Foundation (ASF) under one
* or more contributor license agreements. See the NOTICE file
* distributed with this work for additional information
* regarding copyright ownership. The ASF licenses this file
* to you under the Apache License, Version 2.0 (the
* "License"); you may not use this file except in compliance
* with the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing,
* software distributed under the License is distributed on an
* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
* KIND, either express or implied. See the License for the
* specific language governing permissions and limitations
* under the License.
*/
package org.apache.uima.ducc.sm;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.util.HashMap;
import java.util.Map;
import java.util.Properties;
import java.util.UUID;
import org.apache.uima.ducc.cli.IUiOptions.UiOption;
import org.apache.camel.CamelContext;
import org.apache.uima.ducc.cli.UimaAsPing;
import org.apache.uima.ducc.common.boot.DuccDaemonRuntimeProperties;
import org.apache.uima.ducc.common.boot.DuccDaemonRuntimeProperties.DaemonName;
import org.apache.uima.ducc.common.component.AbstractDuccComponent;
import org.apache.uima.ducc.common.crypto.Crypto;
import org.apache.uima.ducc.common.crypto.Crypto.AccessType;
import org.apache.uima.ducc.common.main.DuccService;
import org.apache.uima.ducc.common.utils.DuccCollectionUtils;
import org.apache.uima.ducc.common.utils.DuccCollectionUtils.DuccMapDifference;
import org.apache.uima.ducc.common.utils.DuccCollectionUtils.DuccMapValueDifference;
import org.apache.uima.ducc.common.utils.DuccLogger;
import org.apache.uima.ducc.common.utils.DuccProperties;
import org.apache.uima.ducc.common.utils.LinuxUtils;
import org.apache.uima.ducc.common.utils.MissingPropertyException;
import org.apache.uima.ducc.common.utils.SystemPropertyResolver;
import org.apache.uima.ducc.common.utils.Version;
import org.apache.uima.ducc.common.utils.id.DuccId;
import org.apache.uima.ducc.common.utils.id.DuccIdFactory;
import org.apache.uima.ducc.transport.dispatcher.DuccEventDispatcher;
import org.apache.uima.ducc.transport.event.AServiceRequest;
import org.apache.uima.ducc.transport.event.ServiceModifyEvent;
import org.apache.uima.ducc.transport.event.ServiceQueryEvent;
import org.apache.uima.ducc.transport.event.ServiceQueryReplyEvent;
import org.apache.uima.ducc.transport.event.ServiceRegisterEvent;
import org.apache.uima.ducc.transport.event.ServiceReplyEvent;
import org.apache.uima.ducc.transport.event.ServiceStartEvent;
import org.apache.uima.ducc.transport.event.ServiceStopEvent;
import org.apache.uima.ducc.transport.event.ServiceUnregisterEvent;
import org.apache.uima.ducc.transport.event.SmStateDuccEvent;
import org.apache.uima.ducc.transport.event.common.DuccWorkJob;
import org.apache.uima.ducc.transport.event.common.DuccWorkMap;
import org.apache.uima.ducc.transport.event.common.IDuccState.JobState;
import org.apache.uima.ducc.transport.event.common.IDuccTypes.DuccType;
import org.apache.uima.ducc.transport.event.common.IDuccWork;
import org.apache.uima.ducc.transport.event.common.IDuccWorkService;
import org.apache.uima.ducc.transport.event.sm.ServiceMap;
/**
* This is the logical "main". The framework instantiates it and calls the (inherited) start() method.
* Start() establishes the class in its own thread and fires up the Handler thread. From then on it
* is a conduit between the Handler and messages to/from the outside world.
*/
public class ServiceManagerComponent
extends AbstractDuccComponent
implements IServiceManager,
SmConstants,
Runnable
{
/**
*
*/
private static final long serialVersionUID = 1L;
private static DuccLogger logger = DuccLogger.getLogger(ServiceManagerComponent.class.getName(), COMPONENT_NAME);
DuccWorkMap localMap = null;
private DuccEventDispatcher eventDispatcher;
private String stateEndpoint;
private ServiceHandler handler = null;
//HashMap<String, BaseUimaAsService> services = new HashMap<String, BaseUimaAsService>();
static int meta_ping_rate = 60000; // interval in ms to ping the service
static int meta_ping_stability = 5; // number of missed pings before we mark the service down
static int meta_ping_timeout = 500; // timeout on ping
static String default_ping_class;
static int failure_max = 5;
private String state_dir = null;
private String state_file = null;
private String descriptor_dir = null;
private DuccProperties sm_props = null;
private String service_seqno = "service.seqno";
private DuccIdFactory idFactory = new DuccIdFactory();
private boolean signature_required = true;
private boolean initialized = false;
private boolean testmode = false;
Map<String, String> administrators = new HashMap<String, String>();
public ServiceManagerComponent(CamelContext context)
{
super("ServiceManager", context);
this.localMap = new DuccWorkMap();
handler = new ServiceHandler(this);
}
public DuccLogger getLogger() {
return logger;
}
/**
* Initialization tasks:
* - read all the service descriptors
* - ping them and update their state
*/
void init()
throws Exception
{
String methodName = "init";
try {
File descdir = new File(serviceFileLocation());
if ( ! descdir.exists() ) {
descdir.mkdirs();
}
File histdir = new File(serviceHistoryLocation());
if ( ! histdir.exists() ) {
histdir.mkdirs();
}
String[] desclist = descdir.list();
for ( String d : desclist) {
if ( d.endsWith(".svc") ) {
int ndx = d.lastIndexOf(".");
String stem = d.substring(0, ndx);
DuccProperties props = new DuccProperties();
String props_filename = serviceFileKey(d);
props.load(props_filename);
DuccProperties metaprops = new DuccProperties();
String meta_filename = serviceFileKey(stem + ".meta");
metaprops.load(meta_filename);
String sc = metaprops.getProperty("service-class");
if ( (sc != null) && ( sc.equals("Implicit") || sc.equals("Submitted") ) ) {
logger.info(methodName, null, "Scrubbing", sc, "service", stem);
deleteProperties(stem, meta_filename, metaprops, props_filename, props);
continue;
}
int friendly = 0;
String uuid = "";
try {
// these gets will throw if the requisite objects aren't found
friendly = metaprops.getIntProperty("numeric_id");
uuid = metaprops.getStringProperty("uuid");
} catch (MissingPropertyException e1) {
// Ugly, but shouldn't have to be fatal
logger.error(methodName, null, "Cannot restore DuccId for", d, "Friendly id:", friendly, "uuid:", uuid);
continue;
}
DuccId id = new DuccId(friendly);
id.setUUID(UUID.fromString(uuid));
logger.debug(methodName, id, "Unique:", id.getUnique());
try {
handler.register(id, props_filename, meta_filename, props, metaprops);
} catch (IllegalStateException e ) { // happens on duplicate service
logger.error(methodName, id, e.getMessage()); // message has all I need.
}
}
}
} catch (Throwable e) {
// If we get here we aren't startable.
logger.error(methodName, null, "Cannot initialize service manger: ", e.getMessage());
System.exit(1);
}
state_dir = System.getProperty("DUCC_HOME") + "/state";
state_file = state_dir + "/sm.properties";
descriptor_dir = state_dir + "/services";
File ddir = new File(descriptor_dir);
if ( ddir.exists() ) {
if ( ! ddir.isDirectory() ) {
throw new IllegalStateException("Service descriptor location is not a directory: " + descriptor_dir);
}
} else {
ddir.mkdirs();
}
sm_props = new DuccProperties();
File sf = new File(state_file);
int seq = 0;
FileInputStream fos;
if ( sf.exists() ) {
fos = new FileInputStream(state_file);
try {
sm_props.load(fos);
String s = sm_props.getProperty(service_seqno);
seq = Integer.parseInt(s) + 1;
} finally {
fos.close();
}
}
idFactory = new DuccIdFactory(seq);
synchronized(this) {
initialized = true;
}
}
void readAdministrators()
{
String methodName = "readAdministrators";
File adminfile = new File(System.getProperty("DUCC_HOME") + "/resources/ducc.administrators");
if ( ! adminfile.exists() ) {
logger.info(methodName, null, "No ducc administrators found.");
return;
}
Properties props = null;
try {
FileInputStream fis = new FileInputStream(adminfile);
props = new Properties();
props.load(fis);
} catch (Exception e) {
logger.warn(methodName, null, "Cannot read administroators file:", e.toString());
return;
}
for ( Object k : props.keySet() ) {
String adm = ((String) k).trim();
administrators.put(adm, adm);
logger.info(methodName, null, "DUCC Administrator registered:", adm);
}
}
@Override
public void start(DuccService service, String[] args) throws Exception
{
String methodName = "start";
super.start(service, args);
DuccDaemonRuntimeProperties.getInstance().boot(DaemonName.ServiceManager,getProcessJmxUrl());
// (UIMA-3397) failure_max = SystemPropertyResolver.getIntProperty("ducc.sm.instance.failure.max", failure_max);
meta_ping_rate = SystemPropertyResolver.getIntProperty("ducc.sm.meta.ping.rate", meta_ping_rate);
meta_ping_timeout = SystemPropertyResolver.getIntProperty("ducc.sm.meta.ping.timeout", meta_ping_timeout);
meta_ping_stability = SystemPropertyResolver.getIntProperty("ducc.sm.meta.ping.stability", meta_ping_stability);
default_ping_class = SystemPropertyResolver.getStringProperty("ducc.sm.default.uima-as.ping.class", UimaAsPing.class.getName());
String rm = SystemPropertyResolver.getStringProperty("ducc.runmode", "");
if ( rm.equals("Test") ) testmode = true;
// yuck
String sig = SystemPropertyResolver.getStringProperty("ducc.signature.required", "on");
signature_required = true;
if ( sig.equals("on") ) signature_required = true;
else if ( sig.equals("off") ) signature_required = false;
else {
logger.warn(methodName, null, "Incorrect value for property ducc.signature.required: " + sig + ". Setting to default of \"on\"");
}
logger.info(methodName, null, "------------------------------------------------------------------------------------");
logger.info(methodName, null, "Service Manager starting:");
logger.info(methodName, null, " DUCC home : ", System.getProperty("DUCC_HOME"));
logger.info(methodName, null, " ActiveMQ URL : ", System.getProperty("ducc.broker.url"));
logger.info(methodName, null, " JVM : ", System.getProperty("java.vendor") +
" "+ System.getProperty("java.version"));
logger.info(methodName, null, " JAVA_HOME : ", System.getProperty("java.home"));
logger.info(methodName, null, " JVM Path : ", System.getProperty("ducc.jvm"));
logger.info(methodName, null, " JMX URL : ", System.getProperty("ducc.jmx.url"));
logger.info(methodName, null, " OS Architecture : ", System.getProperty("os.arch"));
logger.info(methodName, null, " Crypto enabled : ", signature_required);
logger.info(methodName, null, " Test mode enabled : ", testmode);
logger.info(methodName, null, " Service ping rate : ", meta_ping_rate);
logger.info(methodName, null, " Service ping timeout : ", meta_ping_timeout);
logger.info(methodName, null, " Service ping stability : ", meta_ping_stability);
logger.info(methodName, null, " Instance Failure Max : ", failure_max);
logger.info(methodName, null, " DUCC Version : ", Version.version());
logger.info(methodName, null, "------------------------------------------------------------------------------------");
readAdministrators();
// Here is a good place to do any pre-start stuff
// Start the main processing loop
Thread smThread = new Thread(this);
smThread.setDaemon(true);
smThread.start();
Thread handlerThread = new Thread(handler);
handlerThread.setDaemon(true);
handlerThread.start();
}
public void run()
{
String methodName = "run";
logger.info(methodName, null, "Starting Service Manager");
try {
init();
runSm();
} catch ( Throwable t ) {
logger.error(methodName, null, t);
}
logger.info(methodName, null, "Service Manger returns.");
}
public boolean isAdministrator(String user)
{
return administrators.containsKey(user);
}
/**
* At boot only ... pass in the set of all known active services to each service so it can update
* internal state with current published state.
*/
public synchronized void synchronizeHandler(DuccWorkMap work)
{
Map<DuccId, JobState> ids = new HashMap<DuccId, JobState>();
for ( IDuccWork w : work.values() ) {
if ( w.getDuccType() != DuccType.Service ) continue;
DuccWorkJob j = (DuccWorkJob) w;
if ( !j.isActive() ) continue;
ids.put(j.getDuccId(), j.getJobState());
}
handler.synchronizeImplementors(ids);
}
/**
* Split the incoming work into new, deleted, and needs update. This runs under the
* incoming camel thread so don't do anything timeconsuming here.
*
* Also maintain the local workMap so we can diff.
*
* Runs on the incoming thread, do not do anything blocking or timecomsuming here.
*/
public synchronized void processIncoming(DuccWorkMap workMap)
{
String methodName = "processIncoming";
HashMap<DuccId, IDuccWork> newJobs = new HashMap<DuccId, IDuccWork>();
HashMap<DuccId, IDuccWork> newServices = new HashMap<DuccId, IDuccWork>();
HashMap<DuccId, IDuccWork> deletedJobs = new HashMap<DuccId, IDuccWork>();
HashMap<DuccId, IDuccWork> deletedServices = new HashMap<DuccId, IDuccWork>();
HashMap<DuccId, IDuccWork> modifiedJobs = new HashMap<DuccId, IDuccWork>();
HashMap<DuccId, IDuccWork> modifiedServices = new HashMap<DuccId, IDuccWork>();
logger.debug(methodName, null, "---Processing Orchestrator State---");
if ( workMap.size() == 0 ) {
logger.debug(methodName, null, "OR state is empty");
return;
}
@SuppressWarnings("unchecked")
DuccMapDifference<DuccId, IDuccWork> diffmap = DuccCollectionUtils.difference(workMap, localMap);
for ( IDuccWork w : workMap.values() ) {
//IDuccWork j = (IDuccWork) w;
logger.debug(methodName, w.getDuccId(), w.getDuccType(), "Arrives in state =", w.getStateObject());
}
// Stuff on the left is new
Map<DuccId, IDuccWork> work = diffmap.getLeft();
for ( IDuccWork w : work.values() ) {
if ( w.getDuccType() == DuccType.Reservation ) continue;
if ( !((DuccWorkJob)w).isActive() ) continue; // not active, we don't care about it. likely after restart.
logger.debug(methodName, w.getDuccId(), "Reconciling, adding", w.getDuccType());
switch(w.getDuccType()) {
case Job:
localMap.addDuccWork(w);
newJobs.put(w.getDuccId(), w);
break;
case Service:
localMap.addDuccWork(w);
// An arbitrary process is **almost** the same as a service in terms of how most of DUCC
// handles it. To me (SM), however, it is just like any other job so it goes into
// the job map.
switch ( ((IDuccWorkService)w).getServiceDeploymentType() )
{
case uima:
case custom:
newServices.put(w.getDuccId(), w);
break;
case other:
newJobs.put(w.getDuccId(), w);
break;
}
break;
default:
break;
}
}
// Stuff on the right is stuff we have but OR doesn't
work = diffmap.getRight();
for ( IDuccWork w : work.values() ) {
if ( w.getDuccType() == DuccType.Reservation ) continue;
logger.debug(methodName, w.getDuccId(), "Reconciling, deleting", w.getDuccType());
switch(w.getDuccType()) {
case Job:
localMap.removeDuccWork(w.getDuccId());
deletedJobs.put(w.getDuccId(), w);
break;
case Service:
localMap.removeDuccWork(w.getDuccId());
switch ( ((IDuccWorkService)w).getServiceDeploymentType() )
{
case uima:
case custom:
deletedServices.put(w.getDuccId(), w);
break;
case other:
deletedJobs.put(w.getDuccId(), w);
break;
}
break;
default:
break;
}
}
// Now: stuff we both know about
for( DuccMapValueDifference<IDuccWork> jd: diffmap ) {
IDuccWork r = jd.getRight();
IDuccWork l = jd.getLeft();
if ( l.getDuccType() == DuccType.Reservation ) continue;
logger.debug(methodName, l.getDuccId(), "Reconciling, incoming state = ", l.getStateObject(), " my state = ", r.getStateObject());
// Update our own state by replacing the old (right) object with the new (left)
switch(l.getDuccType()) {
case Job:
modifiedJobs.put(l.getDuccId(), l);
localMap.addDuccWork(l);
break;
case Service:
localMap.addDuccWork(l);
switch ( ((IDuccWorkService)l).getServiceDeploymentType() )
{
case uima:
case custom:
modifiedServices.put(l.getDuccId(), l);
break;
case other:
modifiedJobs.put(l.getDuccId(), l);
break;
}
break;
default:
break;
}
}
handler.signalUpdates(
newJobs,
newServices,
deletedJobs,
deletedServices,
modifiedJobs,
modifiedServices
);
}
/**
* Publish the map, called by the ServiceHandler.
*/
public void publish(ServiceMap map)
{
String methodName = "publish";
try {
SmStateDuccEvent ev = new SmStateDuccEvent();
logger.info(methodName, null, "Publishing State, active job count =", map.size());
if (logger.isDebug()) {
logger.debug(methodName, null, map.toPrint());
}
ev.setServiceMap(map);
eventDispatcher.dispatch(stateEndpoint, ev, ""); // tell the world what is scheduled (note empty string)
} catch (Throwable t) {
logger.error(methodName, null, t);
}
}
public void setTransportConfiguration(DuccEventDispatcher eventDispatcher, String endpoint)
{
this.eventDispatcher = eventDispatcher;
this.stateEndpoint = endpoint;
}
int epochCounter = 0;
DuccWorkMap incomingMap = null;
public synchronized void runSm()
{
String methodName = "runSm";
boolean first_update = true;
while ( true ) {
try {
wait();
} catch (InterruptedException e) {
logger.info(methodName, null, "SM wait interrupted, executing out-of-band epoch.");
}
try {
if ( first_update ) {
synchronizeHandler(incomingMap);
first_update = false;
}
processIncoming(incomingMap);
} catch (Throwable e1) {
logger.fatal(methodName, null, e1);
}
}
}
public synchronized void orchestratorStateArrives(DuccWorkMap map)
{
String methodName = "orchestratorStateArrives";
if ( ! initialized ) {
logger.info(methodName, null, "SM not initialized, ignoring Orchestrator state update.");
return;
}
if ( ! map.isJobDriverNodeAssigned() ) {
logger.info(methodName, null, "Orchestrator JD node not assigned, ignoring Orchestrator state update.");
return;
}
epochCounter++;
incomingMap = map;
notify();
}
static String serviceFileLocation()
{
return System.getProperty("DUCC_HOME") + "/state/services";
}
static String serviceHistoryLocation()
{
return System.getProperty("DUCC_HOME") + "/history/services-registry/";
}
private String serviceFileKey(String fn)
{
return serviceFileLocation() + "/" + fn;
}
private boolean check_signature(String user, byte[] auth_block)
throws Throwable
{
String userHome = null;
if ( testmode ) {
userHome = System.getProperty("user.home");
} else {
userHome = LinuxUtils.getUserHome(user);
}
Crypto crypto = new Crypto(user,userHome,AccessType.READER);
String signature = (String)crypto.decrypt(auth_block);
return user.equals(signature);
}
private boolean validate_user(String action, AServiceRequest req)
{
String methodName = "validate_user";
String user = req.getUser();
byte[] auth_block= req.getAuth();
boolean validated = false;
if ( ! signature_required ) return true;
try {
validated = check_signature(user, auth_block);
} catch ( Throwable t ) {
logger.error(methodName, null, "Crypto failure:", t.toString());
}
if ( ! validated ) {
logger.warn(methodName, null, "User", user, "cannot be validated.", action, "rejected.");
req.setReply(new ServiceReplyEvent(false, "User " + user + " cannot be validated. " + action + " rejected.", "NONE", -1));
return false;
}
return true;
}
public synchronized void register(ServiceRegisterEvent ev)
{
String methodName = "register";
DuccProperties props = ev.getDescriptor();
String endpoint = ev.getEndpoint();
int instances = ev.getNinstances();
Trinary autostart = ev.getAutostart();
String user = ev.getUser();
if ( ! validate_user("Register", ev) ) return; // necessary messages emitted in here
DuccId id = null;
try {
id = newId();
} catch ( Exception e ) {
logger.error(methodName, null, e);
ev.setReply(new ServiceReplyEvent(false, "Internal error; unable to generate id", endpoint, -1));
return;
}
logger.debug(methodName, id, "Unique:", id.getUnique());
String logdir = props.getProperty(UiOption.LogDirectory.pname());
if ( !logdir.endsWith("/") ) {
logdir = logdir + "/";
}
logdir = logdir + "S-" + id.toString();
props.put(UiOption.LogDirectory.pname(), logdir);
DuccProperties meta = new DuccProperties();
meta.setProperty("user", user);
meta.setProperty("instances", ""+instances);
meta.setProperty("endpoint", endpoint);
meta.setProperty("numeric_id", id.toString());
meta.setProperty("uuid", id.getUnique());
if ( autostart == Trinary.True ) {
meta.setProperty("autostart", "true");
} else {
meta.setProperty("autostart", "false");
}
String desc_name = descriptor_dir + "/" + id + ".svc";
String meta_name = descriptor_dir + "/" + id + ".meta";
ServiceReplyEvent reply = handler.register(id, desc_name, meta_name, props, meta);
ev.setReply(reply);
// Draw attentipn in the log on registration failures
if ( reply.getReturnCode() ) {
logger.info(methodName, id, ev.toString());
} else {
logger.warn(methodName, id, ev.toString());
}
}
public synchronized void unregister(ServiceUnregisterEvent ev)
{
String methodName = "unregister";
long id = ev.getFriendly();
if ( ! validate_user("Unregister", ev) ) return; // necessary messages emitted in here
logger.info(methodName, null, "De-registering service", id);
ServiceReplyEvent reply = handler.unregister(ev);
ev.setReply(reply);
}
public synchronized void start(ServiceStartEvent ev)
{
String methodName = "startService";
if ( ! validate_user("Start", ev) ) return; // necessary messages emitted in here
logger.info(methodName, null, "Starting service", ev.toString());
ServiceReplyEvent reply = handler.start(ev);
ev.setReply(reply);
//ev.setReply(ServiceCode.OK, "Service not implemented.", "no-endpoint", null);
}
public synchronized void stop(ServiceStopEvent ev)
{
String methodName = "stopService";
if ( ! validate_user("Stop", ev) ) return; // necessary messages emitted in here
logger.info(methodName, null, "Stopping service", ev.toString());
ServiceReplyEvent reply = handler.stop(ev);
ev.setReply(reply);
//ev.setReply(ServiceCode.OK, "Service not implemented.", "no-endpoint", null);
}
public synchronized void query(ServiceQueryEvent ev)
{
String methodName = "query";
if ( ! validate_user("Query", ev) ) return; // necessary messages emitted in here
logger.info(methodName, null, "Query", ev.toString());
ServiceQueryReplyEvent reply = handler.query(ev);
ev.setReply(reply);
//ev.setReply(ServiceCode.OK, "Service not implemented.", "no-endpoint", null);
}
public synchronized void modify(ServiceModifyEvent ev)
{
String methodName = "modify";
if ( ! validate_user("Modify", ev) ) return; // necessary messages emitted in here
logger.info(methodName, null, "Modify", ev.toString());
ServiceReplyEvent reply = handler.modify(ev);
ev.setReply(reply);
//ev.setReply(ServiceCode.OK, "Service not implemented.", "no-endpoint", null);
}
Object idSync = new Object();
public DuccId newId()
throws Exception
{
DuccId id = null;
synchronized(idSync) {
id = idFactory.next();
sm_props.setProperty(service_seqno, id.toString());
FileOutputStream fos = new FileOutputStream(state_file);
sm_props.store(fos, "Service Manager Properties");
fos.close();
}
return id;
}
static void deleteProperties(String id, String meta_filename, Properties meta_props, String props_filename, Properties job_props)
{
// NOTE: During init we may now know the ID as a DuccId so it has to be passed in as a string
String methodName = "deleteProperties";
// Save a copy in history, and then delete the original
String history_dir = serviceHistoryLocation();
if ( meta_filename != null ) {
File mfh = new File(history_dir + id + ".meta");
try {
FileOutputStream fos = new FileOutputStream(mfh);
meta_props.store(fos, "Archived meta descriptor");
fos.close();
} catch (Exception e) {
logger.warn(methodName, null, id + ": Unable to save history to \"" + mfh.toString(), ": ", e.toString() + "\"");
}
File mf = new File(meta_filename);
mf.delete();
}
meta_filename = null;
if ( props_filename != null ) {
File pfh = new File(history_dir + id + ".svc");
try {
FileOutputStream fos = new FileOutputStream(pfh);
job_props.store(fos, "Archived meta descriptor");
fos.close();
} catch (Exception e) {
logger.warn(methodName, null, id + ":Unable to save history to \"" + pfh.toString(), ": ", e.toString() + "\"");
}
File pf = new File(props_filename);
pf.delete();
}
props_filename = null;
}
}