/*
* 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.oodt.cas.resource.system;
//APACHE imports
import org.apache.xmlrpc.CommonsXmlRpcTransportFactory;
import org.apache.xmlrpc.XmlRpcClient;
import org.apache.xmlrpc.XmlRpcException;
//OODTimports
import org.apache.oodt.cas.cli.CmdLineUtility;
import org.apache.oodt.cas.resource.structs.Job;
import org.apache.oodt.cas.resource.structs.JobInput;
import org.apache.oodt.cas.resource.structs.JobStatus;
import org.apache.oodt.cas.resource.structs.ResourceNode;
import org.apache.oodt.cas.resource.structs.exceptions.JobExecutionException;
import org.apache.oodt.cas.resource.structs.exceptions.JobRepositoryException;
import org.apache.oodt.cas.resource.structs.exceptions.MonitorException;
import org.apache.oodt.cas.resource.structs.exceptions.QueueManagerException;
import org.apache.oodt.cas.resource.util.XmlRpcStructFactory;
//JDK imports
import java.net.URL;
import java.util.Hashtable;
import java.util.Iterator;
import java.util.List;
import java.util.Vector;
import java.util.logging.Level;
import java.util.logging.Logger;
import java.io.FileInputStream;
import java.io.File;
import java.io.IOException;
/**
* @author mattmann
* @version $Revision$
*
* <p>
* The XML RPC based resource manager client.
* </p>
*
*/
public class XmlRpcResourceManagerClient {
/* our xml rpc client */
private XmlRpcClient client = null;
/* our log stream */
private static Logger LOG = Logger
.getLogger(XmlRpcResourceManagerClient.class.getName());
/* resource manager url */
private URL resMgrUrl = null;
/**
* <p>
* Constructs a new XmlRpcResourceManagerClient with the given
* <code>url</code>.
* </p>
*
* @param url
* The url pointer to the xml rpc resource manager service.
*/
public XmlRpcResourceManagerClient(URL url) {
// set up the configuration, if there is any
if (System.getProperty("org.apache.oodt.cas.resource.properties") != null) {
String configFile = System
.getProperty("org.apache.oodt.cas.resource.properties");
LOG.log(Level.INFO,
"Loading Resource Manager Configuration Properties from: ["
+ configFile + "]");
try {
System.getProperties().load(
new FileInputStream(new File(configFile)));
} catch (Exception e) {
LOG.log(Level.INFO,
"Error loading configuration properties from: ["
+ configFile + "]");
}
}
CommonsXmlRpcTransportFactory transportFactory = new CommonsXmlRpcTransportFactory(
url);
int connectionTimeoutMins = Integer
.getInteger(
"org.apache.oodt.cas.resource.system.xmlrpc.connectionTimeout.minutes",
20).intValue();
int connectionTimeout = connectionTimeoutMins * 60 * 1000;
int requestTimeoutMins = Integer
.getInteger(
"org.apache.oodt.cas.resource.system.xmlrpc.requestTimeout.minutes",
60).intValue();
int requestTimeout = requestTimeoutMins * 60 * 1000;
transportFactory.setConnectionTimeout(connectionTimeout);
transportFactory.setTimeout(requestTimeout);
client = new XmlRpcClient(url, transportFactory);
resMgrUrl = url;
}
public static void main(String[] args) {
CmdLineUtility cmdLineUtility = new CmdLineUtility();
cmdLineUtility.run(args);
}
public boolean isJobComplete(String jobId) throws JobRepositoryException {
Vector argList = new Vector();
argList.add(jobId);
boolean complete = false;
try {
complete = ((Boolean) client.execute("resourcemgr.isJobComplete",
argList)).booleanValue();
} catch (XmlRpcException e) {
throw new JobRepositoryException(e.getMessage(), e);
} catch (IOException e) {
throw new JobRepositoryException(e.getMessage(), e);
}
return complete;
}
public Job getJobInfo(String jobId) throws JobRepositoryException {
Vector argList = new Vector();
argList.add(jobId);
Hashtable jobHash = null;
try {
jobHash = (Hashtable) client.execute("resourcemgr.getJobInfo",
argList);
} catch (XmlRpcException e) {
throw new JobRepositoryException(e.getMessage(), e);
} catch (IOException e) {
throw new JobRepositoryException(e.getMessage(), e);
}
return XmlRpcStructFactory.getJobFromXmlRpc(jobHash);
}
public boolean isAlive() {
Vector argList = new Vector();
try {
return ((Boolean) client.execute("resourcemgr.isAlive", argList))
.booleanValue();
} catch (XmlRpcException e) {
return false;
} catch (IOException e) {
return false;
}
}
/**
* Gets the number of Jobs in JobQueue
* @return Number of Jobs in JobQueue
* @throws JobRepositoryException On Any Exception
*/
public int getJobQueueSize() throws JobRepositoryException {
try {
Vector argList = new Vector();
return ((Integer) client.execute("resourcemgr.getJobQueueSize", argList));
} catch (Exception e) {
throw new JobRepositoryException("Failed to get JobQueue from server : " + e.getMessage(), e);
}
}
/**
* Gets the max number of Jobs allowed in JobQueue
* @return Max number of Jobs
* @throws JobRepositoryException On Any Exception
*/
public int getJobQueueCapacity() throws JobRepositoryException {
try {
Vector argList = new Vector();
return ((Integer) client.execute("resourcemgr.getJobQueueCapacity", argList));
} catch (Exception e) {
throw new JobRepositoryException("Failed to get JobQueue capacity from server : " + e.getMessage(), e);
}
}
public boolean killJob(String jobId) {
Vector argList = new Vector();
argList.add(jobId);
try {
return ((Boolean) client.execute("resourcemgr.killJob", argList))
.booleanValue();
} catch (XmlRpcException e) {
return false;
} catch (IOException e) {
return false;
}
}
public String getExecutionNode(String jobId) {
Vector argList = new Vector();
argList.add(jobId);
try {
return (String) client.execute("resourcemgr.getExecutionNode", argList);
} catch (XmlRpcException e) {
return null;
} catch (IOException e) {
return null;
}
}
public String submitJob(Job exec, JobInput in) throws JobExecutionException {
Vector argList = new Vector();
argList.add(XmlRpcStructFactory.getXmlRpcJob(exec));
argList.add(in.write());
LOG.log(Level.FINEST, argList.toString());
String jobId = null;
try {
jobId = (String) client.execute("resourcemgr.handleJob", argList);
} catch (XmlRpcException e) {
throw new JobExecutionException(e.getMessage(), e);
} catch (IOException e) {
throw new JobExecutionException(e.getMessage(), e);
}
return jobId;
}
public boolean submitJob(Job exec, JobInput in, URL hostUrl)
throws JobExecutionException {
Vector argList = new Vector();
argList.add(XmlRpcStructFactory.getXmlRpcJob(exec));
argList.add(in.write());
argList.add(hostUrl.toString());
boolean success = false;
try {
success = ((Boolean) client.execute("resourcemgr.handleJob",
argList)).booleanValue();
} catch (XmlRpcException e) {
throw new JobExecutionException(e.getMessage(), e);
} catch (IOException e) {
throw new JobExecutionException(e.getMessage(), e);
}
return success;
}
public List getNodes() throws MonitorException {
Vector argList = new Vector();
Vector nodeVector = null;
try {
nodeVector = (Vector) client.execute("resourcemgr.getNodes",
argList);
} catch (XmlRpcException e) {
throw new MonitorException(e.getMessage(), e);
} catch (IOException e) {
throw new MonitorException(e.getMessage(), e);
}
return XmlRpcStructFactory.getResourceNodeListFromXmlRpc(nodeVector);
}
public ResourceNode getNodeById(String nodeId) throws MonitorException {
Vector argList = new Vector();
argList.add(nodeId);
Hashtable resNodeHash = null;
try {
resNodeHash = (Hashtable) client.execute("resourcemgr.getNodeById",
argList);
} catch (XmlRpcException e) {
throw new MonitorException(e.getMessage(), e);
} catch (IOException e) {
throw new MonitorException(e.getMessage(), e);
}
return XmlRpcStructFactory.getResourceNodeFromXmlRpc(resNodeHash);
}
/**
* @return the resMgrUrl
*/
public URL getResMgrUrl() {
return resMgrUrl;
}
/**
* @param resMgrUrl
* the resMgrUrl to set
*/
public void setResMgrUrl(URL resMgrUrl) {
this.resMgrUrl = resMgrUrl;
}
/**
* Creates a queue with the given name
* @param queueName The name of the queue to be created
* @throws QueueManagerException on any error
*/
public void addQueue(String queueName) throws QueueManagerException {
try {
Vector<Object> argList = new Vector<Object>();
argList.add(queueName);
client.execute("resourcemgr.addQueue", argList);
}catch (Exception e) {
throw new QueueManagerException(e.getMessage(), e);
}
}
/**
* Removes the queue with the given name
* @param queueName The name of the queue to be removed
* @throws QueueManagerException on any error
*/
public void removeQueue(String queueName) throws QueueManagerException {
try {
Vector<Object> argList = new Vector<Object>();
argList.add(queueName);
client.execute("resourcemgr.removeQueue", argList);
}catch (Exception e) {
throw new QueueManagerException(e.getMessage(), e);
}
}
/**
* Adds a node
* @param node The node to be added
* @throws MonitorException on any error
*/
public void addNode(ResourceNode node) throws MonitorException {
try {
Vector<Object> argList = new Vector<Object>();
argList.add(XmlRpcStructFactory.getXmlRpcResourceNode(node));
client.execute("resourcemgr.addNode", argList);
}catch (Exception e) {
throw new MonitorException(e.getMessage(), e);
}
}
/**
* Removes the node with the given id
* @param nodeId The id of the node to be removed
* @throws MonitorException on any error
*/
public void removeNode(String nodeId) throws MonitorException {
try {
Vector<Object> argList = new Vector<Object>();
argList.add(nodeId);
client.execute("resourcemgr.removeNode", argList);
}catch (Exception e) {
throw new MonitorException(e.getMessage(), e);
}
}
public void setNodeCapacity(String nodeId, int capacity) throws MonitorException{
try{
Vector<Object> argList = new Vector<Object>();
argList.add(nodeId);
argList.add(new Integer(capacity));
client.execute("resourcemgr.setNodeCapacity", argList);
}catch (Exception e){
throw new MonitorException(e.getMessage(), e);
}
}
/**
* Addes the node with given id to the queue with the given name
* @param nodeId The id of the node to be added to the given queueName
* @param queueName The name of the queue to add the given node
* @throws QueueManagerException on any error
*/
public void addNodeToQueue(String nodeId, String queueName) throws QueueManagerException {
try {
Vector<Object> argList = new Vector<Object>();
argList.add(nodeId);
argList.add(queueName);
client.execute("resourcemgr.addNodeToQueue", argList);
}catch (Exception e) {
throw new QueueManagerException(e.getMessage(), e);
}
}
/**
* Remove the node with the given id from the queue with the given name
* @param nodeId The id of the node to be remove from the given queueName
* @param queueName The name of the queue from which to remove the given node
* @throws QueueManagerException on any error
*/
public void removeNodeFromQueue(String nodeId, String queueName) throws QueueManagerException {
try {
Vector<Object> argList = new Vector<Object>();
argList.add(nodeId);
argList.add(queueName);
client.execute("resourcemgr.removeNodeFromQueue", argList);
}catch (Exception e) {
throw new QueueManagerException(e.getMessage(), e);
}
}
/**
* Gets a list of currently supported queue names
* @return A list of currently supported queue names
* @throws QueueManagerException on any error
*/
public List<String> getQueues() throws QueueManagerException {
try {
Vector<Object> argList = new Vector<Object>();
return (List<String>) client.execute("resourcemgr.getQueues", argList);
}catch (Exception e) {
throw new QueueManagerException(e.getMessage(), e);
}
}
/**
* Gets a list of ids of the nodes in the given queue
* @param queueName The name of the queue to get node ids from
* @return List of node ids in the given queueName
* @throws QueueManagerException on any error
*/
public List<String> getNodesInQueue(String queueName) throws QueueManagerException {
try {
Vector<Object> argList = new Vector<Object>();
argList.add(queueName);
return (List<String>) client.execute("resourcemgr.getNodesInQueue", argList);
}catch (Exception e) {
throw new QueueManagerException(e.getMessage(), e);
}
}
/**
* Gets a list of queues which contain the node with the given nodeId
* @param nodeId The id of the node to get queues it belongs to
* @return List of queues which contain the give node
* @throws QueueManagerException on any error
*/
public List<String> getQueuesWithNode(String nodeId) throws QueueManagerException {
try {
Vector<Object> argList = new Vector<Object>();
argList.add(nodeId);
return (List<String>) client.execute("resourcemgr.getQueuesWithNode", argList);
}catch (Exception e) {
throw new QueueManagerException(e.getMessage(), e);
}
}
/**
* Report on the load of the requested node
* @param nodeId The id of the node to be polled
* @return A String showing a fraction of the loads node over its capacity
* @throws MonitorException on any error
*/
public String getNodeLoad(String nodeId) throws MonitorException{
try{
Vector<Object> argList = new Vector<Object>();
argList.add(nodeId);
return (String)client.execute("resourcemgr.getNodeLoad", argList);
}catch(Exception e){
throw new MonitorException(e.getMessage(), e);
}
}
private static String getReadableJobStatus(String status) {
if (status.equals(JobStatus.SUCCESS)) {
return "SUCCESS";
} else if (status.equals(JobStatus.FAILURE)) {
return "FAILURE";
} else if (status.equals(JobStatus.EXECUTED)) {
return "EXECUTED";
} else if (status.equals(JobStatus.QUEUED)) {
return "QUEUED";
} else if (status.equals(JobStatus.SCHEDULED)) {
return "SCHEDULED";
} else if (status.equals(JobStatus.KILLED)) {
return "KILLED";
} else
return null;
}
}