pandorafms/pandora_plugins/intel_dcm/IntelDcmPlugin.java

// ______                 __                     _______ _______ _______
//|   __ \.---.-.-----.--|  |.-----.----.---.-. |    ___|   |   |     __|
//|    __/|  _  |     |  _  ||  _  |   _|  _  | |    ___|       |__     |
//|___|   |___._|__|__|_____||_____|__| |___._| |___|   |__|_|__|_______|
//
// ============================================================================
// Copyright (c) 2007-2021 Artica Soluciones Tecnologicas, http://www.artica.es
// This code is NOT free software. This code is NOT licenced under GPL2 licence
// You cannnot redistribute it without written permission of copyright holder.
// ============================================================================

import java.util.*;
import java.net.MalformedURLException;
import java.net.URL;
import javax.xml.datatype.*;
import javax.xml.namespace.QName;
import Intel_Dcm.*; 

public class IntelDcmPlugin {
	private static QName qName = new QName("http://wsdl.intf.dcm.intel.com/", "Dcm");
	private static String result = "";
	private static URL url = null;
	private static boolean retry = true;
	private static int retries = 0;
	private static final int MAX_RETRIES = 10;	
	private static Dcm dcm;
		
	private static String getParam(String key, String[] params) {
		
		key = "--"+key;
		
		for (int i = 0; i < params.length; i++) {  
		
			if (key.equals(params[i])) {
				return params[i+1];
			} 
		}  
		
		return "";
	}
	
	private static QueryType strToQueryType(String str) {
		if (str.equals("max_pwr")) {
			return QueryType.MAX_PWR;
			
		} else if (str.equals("avg_pwr")) {
			return QueryType.AVG_PWR;
			
		} else if (str.equals("min_pwr")) {
			return QueryType.MIN_PWR;
			
		} else if (str.equals("max_avg_pwr")) {
			return QueryType.MAX_AVG_PWR;
			
		} else if (str.equals("total_max_pwr")) {
			return QueryType.TOTAL_MAX_PWR;
			
		} else if (str.equals("total_avg_pwr")) {
			return QueryType.TOTAL_AVG_PWR;
			
		} else if (str.equals("max_avg_pwr_cap")) {
			return QueryType.MAX_AVG_PWR_CAP;
			
		} else if (str.equals("total_max_pwr_cap")) {
			return QueryType.TOTAL_MAX_PWR_CAP;
			
		} else if (str.equals("total_avg_pwr_cap")) {
			return QueryType.TOTAL_AVG_PWR_CAP;
			
		} else if (str.equals("total_min_pwr")) {
			return QueryType.TOTAL_MIN_PWR;
			
		} else if (str.equals("min_avg_pwr")) {
			return QueryType.MIN_AVG_PWR;
			
		} else if (str.equals("max_inlet_temp")) {
			return QueryType.MAX_INLET_TEMP;
			
		} else if (str.equals("avg_inlet_temp")) {
			return QueryType.AVG_INLET_TEMP;
			
		} else if (str.equals("min_inlet_temp")) {
			return QueryType.MIN_INLET_TEMP;
			
		} else if (str.equals("ins_pwr")) {
			return QueryType.INS_PWR;
			
		}
		
		return null;
	}
	
	
	private static MetricType strToMetricType(String str) {
		if (str.equals("mnged_nodes_energy")) {
			return MetricType.MNGED_NODES_ENERGY;
			
		} else if (str.equals("mnged_nodes_energy_bill")) {
			return MetricType.MNGED_NODES_ENERGY_BILL;
			
		} else if (str.equals("it_eqpmnt_energy")) {
			return MetricType.IT_EQPMNT_ENERGY;
			
		} else if (str.equals("it_eqpmnt_energy_bill")) {
			return MetricType.IT_EQPMNT_ENERGY_BILL;

		} else if (str.equals("calc_cooling_energy")) {
			return MetricType.CALC_COOLING_ENERGY;
			
		} else if (str.equals("calc_cooling_energy_bill")) {
			return MetricType.CALC_COOLING_ENERGY_BILL;						
			 
		} else if (str.equals("mnged_nodes_pwr")) {
			return MetricType.MNGED_NODES_PWR;	

		} else if (str.equals("it_eqpmnt_pwr")) {
			return MetricType.IT_EQPMNT_PWR;	

		} else if (str.equals("calc_cooling_pwr")) {
			return MetricType.CALC_COOLING_PWR;	
  
		} else if (str.equals("avg_pwr_per_dimension")) {
			return MetricType.AVG_PWR_PER_DIMENSION;

		} else if (str.equals("derated_pwr")) {
			return MetricType.DERATED_PWR;
			
		} else if (str.equals("inlet_temperature_span")) {
			return MetricType.INLET_TEMPERATURE_SPAN;
			
		}			
	
		return null;
	}

	public static void printUsage () {
		
			System.out.print("\n\n Usage: DcmPlugin --server <server> --port <port> --action <action> [--value <value> and other values or option depending on action]\n\n");
	}
			
	public static XMLGregorianCalendar getEndDate() {

		try {
			GregorianCalendar gcal = new GregorianCalendar();

			return DatatypeFactory.newInstance().newXMLGregorianCalendar(gcal);
		
		} catch (DatatypeConfigurationException e) {
			return null;
		}

	}
	
	public static XMLGregorianCalendar getStartDate(int interval) {
		try {
			GregorianCalendar gcal = new GregorianCalendar();

			//Ge time in milliseconds
			long time = gcal.getTimeInMillis();
			
			//Convert time to seconds
			time = time / 1000;
			
			//Substract interval
			time = time - interval;
			
			//Convert to milliseconds
			time = time * 1000;
			
			//Set calendar to real time
			gcal.setTimeInMillis(time);
			
			XMLGregorianCalendar auxDate = DatatypeFactory.newInstance().newXMLGregorianCalendar(gcal);		
			
			return auxDate;
			
		} catch (DatatypeConfigurationException e) {
			return null;
		}
	}
	
	/**
	* @param args
	*/
	public static void main(String[] args) {
		
		while (retry) {
			
			retry = false;
			retries++;
			
			try{
				
				//Check arguments
				if (args.length < 6) {
					printUsage();
					System.exit(-1);
				}
				
				String server = getParam("server", args);
				String port = getParam("port", args);
				String action = getParam("action", args);
				String value = getParam("value", args);
				
				url = new URL("http://"+server+":"+port+"/DCMWsdl/dcm.wsdl");

				Dcm_Service dcmService = new Dcm_Service(url, qName);
				dcm = dcmService.getDcmPort();

				//Execute actions
				if (action.equals("resume_monitoring")) {
					dcm.setCollectionState(true);

				} else if (action.equals("suspend_monitoring")) {
					dcm.setCollectionState(false);

				} else if (action.equals("status_monitoring")) {
					if (dcm.getCollectionState()) {
						result = "1";
					} else {
						result = "0";
					}

				} else if (action.equals("set_power_sampling")) {
					dcm.setGlobalProperty(GlobalProperty.NODE_POWER_SAMPLING_FREQUENCY, value);

				} else if (action.equals("get_power_sampling")) {
					result = dcm.getGlobalProperty(GlobalProperty.NODE_POWER_SAMPLING_FREQUENCY);

				} else if (action.equals("set_power_granularity")) {				
					dcm.setGlobalProperty(GlobalProperty.NODE_POWER_MEASUREMENT_GRANULARITY, value);

				} else if (action.equals("get_power_granularity")) {
					result = dcm.getGlobalProperty(GlobalProperty.NODE_POWER_MEASUREMENT_GRANULARITY);

				} else if (action.equals("set_thermal_sampling")) {				
					dcm.setGlobalProperty(GlobalProperty.NODE_THERMAL_SAMPLING_FREQUENCY, value);

				} else if (action.equals("get_thermal_sampling")) {
					result = dcm.getGlobalProperty(GlobalProperty.NODE_THERMAL_SAMPLING_FREQUENCY);

				} else if (action.equals("set_thermal_granularity")) {				
					dcm.setGlobalProperty(GlobalProperty.NODE_THERMAL_MEASUREMENT_GRANULARITY, value);

				} else if (action.equals("get_thermal_granularity")) {
					result = dcm.getGlobalProperty(GlobalProperty.NODE_THERMAL_MEASUREMENT_GRANULARITY);

				} else if (action.equals("set_cooling_multiplier")) {				
					dcm.setGlobalProperty(GlobalProperty.COOLING_MULT, value);

				} else if (action.equals("get_cooling_multiplier")) {
					result = dcm.getGlobalProperty(GlobalProperty.COOLING_MULT);

				}  else if (action.equals("set_power_cost")) {				
					dcm.setGlobalProperty(GlobalProperty.COST_PER_KW_HR, value);

				} else if (action.equals("get_power_cost")) {
					result = dcm.getGlobalProperty(GlobalProperty.COST_PER_KW_HR);

				} else if(action.equals("add_entity")) {
					
					Property entityType = new Property();
					entityType.setName(EntityProperty.ENTITY_TYPE);
					entityType.setValue(getParam("type", args));
					
					Property address = new Property(); 
					address.setName(EntityProperty.BMC_ADDRESS);
					address.setValue(getParam("address", args));
					
					Property name = new Property();
					name.setName(EntityProperty.NAME);
					name.setValue(getParam("value", args));
					
					Property deratedPower = new Property();
					deratedPower.setName(EntityProperty.DERATED_PWR);
					deratedPower.setValue(getParam("derated_power", args));
					
					Property connectorName = new Property();
					connectorName.setName(EntityProperty.CONNECTOR_NAME);
					connectorName.setValue(getParam("connector", args));
					
					Property bmcUser = new Property();
					bmcUser.setName(EntityProperty.BMC_USER);
					bmcUser.setValue(getParam("bmc_user", args));

					Property bmcPass = new Property();
					bmcPass.setName(EntityProperty.BMC_PASSWORD);
					bmcPass.setValue(getParam("bmc_pass", args));					
					
					List<Property> properties = new ArrayList<Property>();
					
					properties.add(entityType);
					properties.add(address);
					properties.add(name);
					properties.add(deratedPower);
					properties.add(connectorName);
					properties.add(bmcUser);
					properties.add(bmcPass);
	
					int res = dcm.addEntity(EntityType.NODE, properties, true);
					System.out.print(res);
				} else if (action.equals("connector_list")) {

					List<ConnectorInfo> connectorList = dcm.getConnectorList();
					Iterator iter = connectorList.iterator();

					result = "";
					while (iter.hasNext()) {
						ConnectorInfo connector = (ConnectorInfo) iter.next();
						String name = connector.getDisplayName();
						String uname = connector.getUname();
						result = result+name+":"+uname+"|";
					}
					//Delete last "|"
					int lastIdx = result.length() - 1;
					result = result.substring(0, lastIdx);
				} else if (action.equals("entity_properties")) {
					String entId = getParam("entity_id",args);
					
					List<Property> properties = dcm.getEntityProperties(Integer.parseInt(entId));
					
					Iterator iter = properties.iterator();

					result = "";
					while (iter.hasNext()) {
						Property property = (Property) iter.next();

						EntityProperty name = property.getName();
						String val = property.getValue();
						result = result+name+":"+val+"|";
					}				
					//Delete last "|"
					int lastIdx = result.length() - 1;
					result = result.substring(0, lastIdx);
					
				} else if (action.equals("delete_entity")) {
					String entId = getParam("entity_id",args);
					
					dcm.removeEntity(Integer.parseInt(entId), true);
					
					System.out.println(1);
					
				} else if (action.equals("update_entity")) {
					
					Property address = new Property(); 
					address.setName(EntityProperty.BMC_ADDRESS);
					address.setValue(getParam("address", args));
					
					Property name = new Property();
					name.setName(EntityProperty.NAME);
					name.setValue(getParam("value", args));
					
					Property deratedPower = new Property();
					deratedPower.setName(EntityProperty.DERATED_PWR);
					deratedPower.setValue(getParam("derated_power", args));
									
					List<Property> properties = new ArrayList<Property>();
					
					properties.add(address);
					properties.add(name);
					properties.add(deratedPower);
					
					String entId = getParam("entity_id",args);				
					
					dcm.setEntityProperties(Integer.parseInt(entId), properties, false);
					
					System.out.print(1);
					
				} else if (action.equals("query_data")) {
					String entId = getParam("entity_id", args);

					QueryType queryType = strToQueryType(getParam("value", args));
					
					XMLGregorianCalendar startDate = getStartDate(300);
					XMLGregorianCalendar endDate = getEndDate();
										
					EnumerationRawData query = dcm.dumpMeasurementData(Integer.parseInt(entId), queryType, startDate, endDate);
									 
					List<RawPtData> queryData = query.getQueryData();

					Iterator iter = queryData.iterator();
					
					//Calculate an average
					int numberItems = 0;
					int accValue = 0;
					
					while (iter.hasNext()) {
						RawPtData data = (RawPtData) iter.next();
						
						accValue = accValue + data.getValue();
						numberItems++;
					}
					
					int avg = accValue / numberItems;
									
					result = String.valueOf(avg);
					
				} else if (action.equals("metric_data")) {
					String entId = getParam("entity_id", args);

					MetricType metricType = strToMetricType(getParam("value", args));
					
					XMLGregorianCalendar startDate = getStartDate(360);
					XMLGregorianCalendar endDate = getEndDate();
					
					List<AggregationPeriod> aggList = dcm.getMetricAggregationPeriodList(startDate, endDate, metricType);
					
					Iterator aggIter = aggList.iterator();
					
					int max = 0;
					
					while (aggIter.hasNext()) {
						
						AggregationPeriod aggData = (AggregationPeriod) aggIter.next();
												
						if (aggData.getValue() > max) {
							max = aggData.getValue();
							startDate = aggData.getStart();
							endDate = aggData.getEnd();
						}
					}

					EnumerationData metrics = dcm.getMetricData (Integer.parseInt(entId), metricType, AggregationLevel.SELF, startDate, endDate, -1);

					List<PtData> metricsData = metrics.getQueryData(); 

					Iterator iter = metricsData.iterator();
					
					//Calculate an average
					int numberItems = 0;
					int accValue = 0;
					
					while (iter.hasNext()) {
						
						PtData data = (PtData) iter.next();
						
						accValue = accValue + data.getValue();
						numberItems++;
					}
					
					int avg = accValue / numberItems;					
										
					result = String.valueOf(avg);
				} 
			} catch (Exception_Exception e) {
				System.out.println("Web Service Exception:");
				System.out.println(e);		
									
			} catch	(java.lang.Exception e2) {
				//Only retry if exception is different of MalformedURLException
				if (!(e2 instanceof MalformedURLException)) {
					
					//Only do MAX_RETRIES
					if (retries < MAX_RETRIES) {

						retry = true;
						
						try {
							//Sleep 1 seconds
							Thread.sleep(1000);
						} catch (InterruptedException ie) {
							//TODO InterruptedException handler
						}
					} else {
						System.out.println("Max number of retries reached: Timeout error");
					}
					
				}
				
			} finally{
				
	
				if (!result.equals("")) {
					System.out.print(result);
				}
			}
		}
	}
}