public void createSnapshot() {
try {
ServiceInstance si =
new ServiceInstance(new URL("https://130.65.132.214/sdk"), "root", "12!@qwQW", true);
VirtualMachine vm =
(VirtualMachine)
new InventoryNavigator(si.getRootFolder())
.searchManagedEntity("VirtualMachine", VM_NAME);
Task task =
vm.createSnapshot_Task(
"snapshot1", "Nachu's first snapshot", false /* memory */, false /* quiesce */);
System.out.println("Snapshot created");
} catch (InvalidProperty e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (RuntimeFault e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (RemoteException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (MalformedURLException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
public static void main(String[] args) throws Exception {
ServiceInstance si =
new ServiceInstance(new URL("http://10.20.143.205/sdk"), "root", "password", true);
Folder rootFolder = si.getRootFolder();
ManagedEntity[] vms =
new InventoryNavigator(rootFolder).searchManagedEntities("VirtualMachine");
ManagedEntity[] hosts = new InventoryNavigator(rootFolder).searchManagedEntities("HostSystem");
CacheInstance vicf = new CacheInstance(si);
vicf.watch(vms, new String[] {"name", "runtime.powerState", "summary"});
vicf.watch(hosts, new String[] {"name", "summary"});
vicf.start();
// check if the caching is ready to use; otherwise wait
while (!vicf.isReady()) {
Thread.sleep(1000);
}
Thread[] vrs = new VimReader[2];
for (int i = 0; i < vrs.length; i++) {
vrs[i] = new VimReader("Thread " + i, vicf, vms, hosts);
vrs[i].start();
}
for (int i = 0; i < vrs.length; i++) {
vrs[i].join();
}
si.getServerConnection().logout();
}
public static void main(String[] args) throws Exception {
ServiceInstance si = new ServiceInstance(new URL(VCENTERURL), USERNAME, PASSWORD, true);
Folder rootFolder = si.getRootFolder();
ManagedEntity[] hosts = new InventoryNavigator(rootFolder).searchManagedEntities("HostSystem");
if (hosts == null || hosts.length == 0) {
return;
}
for (int i = 0; i < hosts.length; i++) { // get all vm in Vhost
System.out.println("vHost loop ******************");
System.out.println("HostName: " + hosts[i].getName());
ManagedEntity[] mes =
new InventoryNavigator(rootFolder).searchManagedEntities("VirtualMachine");
for (int j = 0; j < mes.length; j++) {
VirtualMachine vm = (VirtualMachine) mes[j];
VirtualMachineConfigInfo vminfo = vm.getConfig();
vm.getResourcePool();
System.out.println("vHost: " + vm.getParent().getName());
System.out.println("Guest: " + vm.getName());
System.out.println("GuestOS: " + vminfo.getGuestFullName());
System.out.println("GuestState: " + vm.getGuest().guestState);
System.out.println("Guest Ip address: " + vm.getGuest().getIpAddress());
pingByIP(vm.getGuest().getIpAddress()); // ping VM
}
HostSystem newHost = (HostSystem) hosts[i];
String vHost_IP =
newHost.getConfig().getNetwork().getVnic()[0].getSpec().getIp().getIpAddress();
System.out.println("vHost IP address: " + vHost_IP);
// test for ping vHost
pingByIP(vHost_IP); // ping vHost
}
} // end of main
public static void main(String[] args) throws Exception {
if (args.length != 5) {
System.out.println("Usage: java VMpowerOps <url> " + "<username> <password> <vmname> <op>");
System.out.println("op - reboot|poweron|poweroff" + "|reset|standby|suspend|shutdown");
System.exit(0);
}
String vmname = args[3];
String op = args[4];
ServiceInstance si = new ServiceInstance(new URL(args[0]), args[1], args[2], true);
Folder rootFolder = si.getRootFolder();
VirtualMachine vm =
(VirtualMachine)
new InventoryNavigator(rootFolder).searchManagedEntity("VirtualMachine", vmname);
if (vm == null) {
System.out.println("No VM " + vmname + " found");
si.getServerConnection().logout();
return;
}
if ("reboot".equalsIgnoreCase(op)) {
vm.rebootGuest();
System.out.println(vmname + " guest OS rebooted");
} else if ("poweron".equalsIgnoreCase(op)) {
Task task = vm.powerOnVM_Task(null);
if (task.waitForMe() == Task.SUCCESS) {
System.out.println(vmname + " powered on");
}
} else if ("poweroff".equalsIgnoreCase(op)) {
Task task = vm.powerOffVM_Task();
if (task.waitForMe() == Task.SUCCESS) {
System.out.println(vmname + " powered off");
}
} else if ("reset".equalsIgnoreCase(op)) {
Task task = vm.resetVM_Task();
if (task.waitForMe() == Task.SUCCESS) {
System.out.println(vmname + " reset");
}
} else if ("standby".equalsIgnoreCase(op)) {
vm.standbyGuest();
System.out.println(vmname + " guest OS stoodby");
} else if ("suspend".equalsIgnoreCase(op)) {
Task task = vm.suspendVM_Task();
if (task.waitForMe() == Task.SUCCESS) {
System.out.println(vmname + " suspended");
}
} else if ("shutdown".equalsIgnoreCase(op)) {
Task task = vm.suspendVM_Task();
if (task.waitForMe() == Task.SUCCESS) {
System.out.println(vmname + " suspended");
}
} else {
System.out.println("Invalid operation. Exiting...");
}
si.getServerConnection().logout();
}
/** Disconnects from the server. */
public void disconnect() {
if (m_serviceInstance == null) {
// not connected
return;
} else {
ServerConnection serverConnection = m_serviceInstance.getServerConnection();
if (serverConnection == null) {
// not connected
return;
} else {
m_serviceInstance.getServerConnection().logout();
}
}
}
/**
* Retrieves the performance manager for this instance.
*
* @return the performance manager
*/
private PerformanceManager getPerformanceManager() {
if (m_performanceManager == null) {
m_performanceManager = m_serviceInstance.getPerformanceManager();
}
return m_performanceManager;
}
/**
* Returns a managed entitiy for a given managed object Id.
*
* @param managedObjectId the managed object Id
* @return the managed entity
*/
public ManagedEntity getManagedEntityByManagedObjectId(String managedObjectId) {
ManagedObjectReference managedObjectReference = new ManagedObjectReference();
managedObjectReference.setType("ManagedEntity");
managedObjectReference.setVal(managedObjectId);
ManagedEntity managedEntity =
MorUtil.createExactManagedEntity(
m_serviceInstance.getServerConnection(), managedObjectReference);
return managedEntity;
}
/**
* Returns a host system by a given managed object Id.
*
* @param managedObjectId the managed object Id
* @return the host system object
*/
public HostSystem getHostSystemByManagedObjectId(String managedObjectId) {
ManagedObjectReference managedObjectReference = new ManagedObjectReference();
managedObjectReference.setType("HostSystem");
managedObjectReference.setVal(managedObjectId);
HostSystem hostSystem =
(HostSystem)
MorUtil.createExactManagedEntity(
m_serviceInstance.getServerConnection(), managedObjectReference);
return hostSystem;
}
/**
* Returns a virtual machine by a given managed object Id.
*
* @param managedObjectId the managed object Id
* @return the virtual machine object
*/
public VirtualMachine getVirtualMachineByManagedObjectId(String managedObjectId) {
ManagedObjectReference managedObjectReference = new ManagedObjectReference();
managedObjectReference.setType("VirtualMachine");
managedObjectReference.setVal(managedObjectId);
VirtualMachine virtualMachine =
(VirtualMachine)
MorUtil.createExactManagedEntity(
m_serviceInstance.getServerConnection(), managedObjectReference);
return virtualMachine;
}
/**
* Main Constructor Takes a ServiceInstance object created by the login splash
*
* @param ServiceInstance si
* @see LoginSplash
*/
public CommandEngine(ServiceInstance si, Main main) {
super(si);
this.main = main;
vmTemplates = new ArrayList<Template>();
vmRootEntities = new ArrayList<VirtualMachineExt>();
vmFolders = new ArrayList<FolderExt>();
networks = new ArrayList<Network>();
try {
Folder rootFolder = si.getRootFolder();
ManagedEntity[] datacenters = rootFolder.getChildEntity();
for (int i = 0; i < datacenters.length; i++) {
if (datacenters[i] instanceof Datacenter
&& datacenters[i].getName().equalsIgnoreCase(DATACENTER)) {
dc = (Datacenter) datacenters[i];
}
}
// Set the template directory and the project directory
for (ManagedEntity each : dc.getVmFolder().getChildEntity()) {
if (each instanceof Folder && each.getName().equalsIgnoreCase(TEMPLATE_FOLDER)) {
templateDir = (Folder) each;
} else if (each instanceof Folder && each.getName().equalsIgnoreCase(ROOT_FOLDER)) {
rootDir = (Folder) each;
}
}
// Set the target datastore for new VM deployments
for (ManagedEntity each : dc.getDatastoreFolder().getChildEntity()) {
if (each instanceof Datastore && each.getName().equalsIgnoreCase(TARGET_DATASTORE)) {
targetDatastore = (Datastore) each;
}
}
// Get Networks - only happens once per load
for (ManagedEntity each : dc.getNetworkFolder().getChildEntity()) {
if (each instanceof Network) {
networks.add(((Network) each));
}
}
refresh();
} catch (RemoteException e) {
disconnect();
LOG.printStackTrace(e);
} catch (Exception e) {
LOG.printStackTrace(e);
}
}
public void deleteSnapshot() {
try {
ServiceInstance si =
new ServiceInstance(new URL("https://130.65.132.214/sdk"), "root", "12!@qwQW", true);
VirtualMachine vm =
(VirtualMachine)
new InventoryNavigator(si.getRootFolder())
.searchManagedEntity("VirtualMachine", VM_NAME);
vm.removeAllSnapshots_Task();
System.out.println("Snapshot deleted");
} catch (InvalidProperty e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (RuntimeFault e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (RemoteException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (MalformedURLException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
/**
* Sets the timeout for server connections.
*
* @param timeout the timeout to be used for connecting
* @return true, if the operation was successful
*/
public boolean setTimeout(int timeout) {
if (m_serviceInstance != null) {
ServerConnection serverConnection = m_serviceInstance.getServerConnection();
if (serverConnection != null) {
VimPortType vimService = serverConnection.getVimService();
if (vimService != null) {
WSClient wsClient = vimService.getWsc();
if (wsClient != null) {
wsClient.setConnectTimeout(timeout);
wsClient.setReadTimeout(timeout);
return true;
}
}
}
}
return false;
}
/**
* Return the major API version for this management server
*
* @return the major API version
*/
public int getMajorApiVersion() {
if (m_serviceInstance != null) {
String apiVersion = m_serviceInstance.getAboutInfo().getApiVersion();
String arr[] = apiVersion.split("\\.");
if (arr.length > 1) {
int apiMajorVersion = Integer.valueOf(arr[0]);
if (apiMajorVersion < 4) {
apiMajorVersion = 3;
}
return apiMajorVersion;
} else {
logger.error("Cannot parse vCenter API version '{}'", apiVersion);
return 0;
}
} else {
return 0;
}
}
@Override
public void configNetworks(Node node) throws Exception {
VirtualMachine vm = VmUtil.getVirtualMachine(serviceInstance, node.getVmName());
VcNetwork vcNet = null;
String operation = null;
String network = null;
String newNetwork = null;
for (NetworkResource networkResource : node.getTargetHost().getNetworks()) {
// the setting network for Cloudera director exists in Esx hosts netowrk which the node vm is
// located in
if (node.getNetwork().equals(networkResource.getName())) {
vcNet = new VcNetwork();
vcNet.update(
serviceInstance.getRootFolder().getServerConnection(),
networkResource.toVim25Network(serviceInstance));
if (vm.getNetworks().length == 0) {
operation = "add";
network = node.getNetwork();
} else {
operation = "edit";
network = vm.getNetworks()[0].getName();
newNetwork = node.getNetwork();
}
break;
}
}
if (vcNet == null) {
throw new Exception("Network " + node.getNetwork() + " is not defined on ESX hosts");
}
VmNicOperationService vmNicOperationService =
new VmNicOperationService(vm, operation, vcNet, network, newNetwork);
vmNicOperationService.run();
}
public static void main(String[] args)
throws InvalidProperty, RuntimeFault, RemoteException, MalformedURLException {
ServiceInstance si =
new ServiceInstance(
new URL(args[0]),
args[1],
args[2],
true); // Pass 3 argument as vCenterIP/username/password
String ClusterName = "Cluster"; // Cluster Name
String VMToBeRemoved = "VM1";
String VMToBeAdded = "VM3";
Folder rootFolder = si.getRootFolder();
VirtualMachine vm1 =
(VirtualMachine)
new InventoryNavigator(rootFolder).searchManagedEntity("VirtualMachine", VMToBeRemoved);
VirtualMachine vm2 =
(VirtualMachine)
new InventoryNavigator(rootFolder).searchManagedEntity("VirtualMachine", VMToBeAdded);
ManagedObjectReference vmMor1 = vm1.getMOR();
ManagedObjectReference vmMor2 = vm2.getMOR();
ClusterComputeResource cluster = null;
cluster =
(ClusterComputeResource)
new InventoryNavigator(rootFolder)
.searchManagedEntity("ClusterComputeResource", ClusterName);
// Number of rules in a cluster
ClusterRuleInfo[] ruleinfo = ((ClusterConfigInfoEx) cluster.getConfigurationEx()).getRule();
if (ruleinfo == null || ruleinfo.length == 0) {
System.out.println("There is no DRS rule in the cluster:: " + cluster.getName());
}
for (ClusterRuleInfo rule : ruleinfo) {
if (((rule instanceof ClusterAffinityRuleSpec)) && (rule.getName().equals("VM VM Rule"))) {
ManagedObjectReference[] vms = ((ClusterAffinityRuleSpec) rule).getVm();
for (ManagedObjectReference vm : vms) {
if (vm.getVal().equals(vmMor1.getVal())) {
// Removed the VM from rule
vms = (ManagedObjectReference[]) ArrayUtils.removeElement(vms, vm);
break;
}
}
// Added the new VM to the rule
vms = (ManagedObjectReference[]) ArrayUtils.add(vms, vmMor2);
ClusterAffinityRuleSpec cars = (ClusterAffinityRuleSpec) rule;
cars.setVm(vms);
ClusterRuleSpec crs1 = new ClusterRuleSpec();
crs1.setInfo(cars);
crs1.setOperation(ArrayUpdateOperation.edit);
ClusterConfigSpec ccs = new ClusterConfigSpec();
ccs.setRulesSpec(new ClusterRuleSpec[] {crs1});
cluster.reconfigureCluster_Task(ccs, true);
System.out.println("Rule reconfigured successfully ");
si.getServerConnection().logout();
}
}
}
@Override
public void run() {
try {
while (true) {
URL url = new URL(SJSULabConfig.getvCenterURL());
try {
ServiceInstance si =
new ServiceInstance(
url, SJSULabConfig.getvCenterUsername(), SJSULabConfig.getPassword(), true);
HostSystem host =
(HostSystem)
new InventoryNavigator(si.getRootFolder())
.searchManagedEntity("HostSystem", ip); //
System.out.println("host value" + host);
PerformanceManager perfMgr = si.getPerformanceManager();
PerfProviderSummary summary = perfMgr.queryPerfProviderSummary(host); // vm
int perfInterval = summary.getRefreshRate();
PerfMetricId[] queryAvailablePerfMetric =
perfMgr.queryAvailablePerfMetric(host, null, null, perfInterval);
PerfCounterInfo[] pci = perfMgr.getPerfCounter();
ArrayList<PerfMetricId> list = new ArrayList<PerfMetricId>();
for (int i2 = 0; i2 < queryAvailablePerfMetric.length; i2++) {
PerfMetricId perfMetricId = queryAvailablePerfMetric[i2];
if (SELECTED_COUNTER_ID == perfMetricId.getCounterId()) {
list.add(perfMetricId);
}
}
PerfMetricId[] pmis = list.toArray(new PerfMetricId[list.size()]);
PerfQuerySpec qSpec = new PerfQuerySpec();
qSpec.setEntity(host.getMOR());
qSpec.setMetricId(pmis);
qSpec.intervalId = perfInterval;
PerfEntityMetricBase[] pembs = perfMgr.queryPerf(new PerfQuerySpec[] {qSpec});
for (int i = 0; pembs != null && i < pembs.length; i++) {
PerfEntityMetricBase val = pembs[i];
PerfEntityMetric pem = (PerfEntityMetric) val;
PerfMetricSeries[] vals = pem.getValue();
PerfSampleInfo[] infos = pem.getSampleInfo();
Date date1 = new Date();
SimpleDateFormat sdf = new SimpleDateFormat("MM-dd-yyyy h:mm:ss");
String formattedDate = sdf.format(date1);
infoList.put(aName[counter], formattedDate);
for (int j = 0; vals != null && j < vals.length; ++j) {
PerfMetricIntSeries val1 = (PerfMetricIntSeries) vals[j];
long[] longs = val1.getValue();
System.out.println("Host CPU :" + longs[5]);
infoList.put(aName[0], String.valueOf(longs[5]));
/*
for (int k : a) {
infoList.put(aName[counter+1],
String.valueOf(longs[k]));
counter++;
}
counter = 0;
*/
}
}
si.getServerConnection().logout();
} catch (InvalidProperty e) {
e.printStackTrace();
} catch (RuntimeFault e) {
e.printStackTrace();
} catch (RemoteException e) {
e.printStackTrace();
} catch (MalformedURLException e) {
e.printStackTrace();
}
// infoList.put("vmIP", ip);
counter = 0;
try {
StringBuilder sb = new StringBuilder();
sb.append("vmname:" + ip + ",");
int countTest = 0;
for (String str : aName) {
sb.append(aName[countTest] + ":" + infoList.get(str).toString() + ",");
countTest++;
}
String out = sb.toString();
out = out.substring(0, out.length() - 1);
writer.write(out + "\n");
System.out.println(out);
} catch (Exception e) {
e.printStackTrace();
}
Thread.sleep(5000);
}
} catch (Exception e) {
e.printStackTrace();
}
}
@Override
public void run() {
try {
ServiceDetails sd = ServiceDetails.getInstance();
ServiceInstance si = sd.getSi();
Folder rootFolder = si.getRootFolder();
String name = rootFolder.getName();
System.out.println("root:" + name);
System.out.println("\n============ Data Centers ============");
ManagedEntity[] dcs = new InventoryNavigator(rootFolder).searchManagedEntities("Datacenter");
for (int i = 0; i < dcs.length; i++) {
System.out.println("Datacenter[" + i + "]=" + dcs[i].getName());
sd.setDc((Datacenter) dcs[i]);
}
System.out.println("\n\n============ Hosts ============");
ManagedEntity[] hostsArray =
new InventoryNavigator(rootFolder).searchManagedEntities("HostSystem");
for (int i = 0; i < hostsArray.length; i++) {
System.out.println("host[" + i + "]=" + hostsArray[i].getName());
}
System.out.println("\n\n============ Virtual Machines ============");
ManagedEntity[] vms =
new InventoryNavigator(rootFolder).searchManagedEntities("VirtualMachine");
VirtualMachine vm = null;
System.out.println(
" VM Name"
+ "\t\t Guest OS"
+ "\t\t VM Version"
+ "\t\t CPU \t"
+ "\t\t Memory "
+ "\t\t VMware Tools"
+ "\t\t IP Addresses"
+ "\tState");
for (int i = 0; i < vms.length; i++) {
vm = (VirtualMachine) vms[i];
System.out.println(
vms[i].getName()
+ "\t\t"
+ vm.getSummary().getConfig().guestFullName
+ "\t"
+ vm.getConfig().version
+ "\t\t\t"
+ vm.getConfig().getHardware().numCPU
+ "vCPU \t\t\t"
+ vm.getConfig().getHardware().memoryMB
+ " MB \t"
+ "\t"
+ vm.getGuest().toolsRunningStatus
+ "\t"
+ vm.getSummary().getGuest().getIpAddress()
+ "\t \t "
+ vm.getGuest().guestState
+ "\n");
/* System.out.println("VM Version:"+vm.getConfig().version);
System.out.println("CPU:"+vm.getConfig().getHardware().numCPU+" vCPU");
System.out.println("Memory:"+vm.getConfig().getHardware().memoryMB+" MB");
System.out.println("VMware Tools:"+vm.getGuest().toolsRunningStatus);
System.out.println("IP Addresses:"+vm.getSummary().getGuest().getIpAddress());
System.out.println("State:"+vm.getGuest().guestState);*/
}
} catch (Exception e) {
e.printStackTrace();
}
}
/**
* Searches for a managed entity by a given type.
*
* @param type the type string to search for
* @return the list of managed entities found
* @throws RemoteException
*/
public ManagedEntity[] searchManagedEntities(String type) throws RemoteException {
return (new InventoryNavigator(m_serviceInstance.getRootFolder())).searchManagedEntities(type);
}