use of org.opennms.netmgt.provision.persist.requisition.RequisitionAsset in project opennms by OpenNMS.
the class VmwareImporter method getRequisition.
public Requisition getRequisition() {
logger.debug("Getting existing requisition (if any) for VMware management server {}", request.getHostname());
Requisition curReq = request.getExistingRequisition();
logger.debug("Building new requisition for VMware management server {}", request.getHostname());
Requisition newReq = buildVMwareRequisition();
logger.debug("Finished building new requisition for VMware management server {}", request.getHostname());
if (curReq == null) {
if (newReq == null) {
// FIXME Is this correct ? This is the old behavior
newReq = new Requisition(request.getForeignSource());
}
} else {
if (newReq == null) {
// If there is a requisition and the vCenter is not responding for some reason, it is better to use the old requisition,
// instead of returning an empty one, which can cause the lost of all the nodes from the DB.
newReq = curReq;
} else {
// The VMWare related assets and categories will be preserved.
for (RequisitionNode newNode : newReq.getNodes()) {
for (RequisitionNode curNode : curReq.getNodes()) {
if (newNode.getForeignId().equals(curNode.getForeignId())) {
// Add existing custom assets
for (RequisitionAsset asset : curNode.getAssets()) {
if (!asset.getName().startsWith("vmware")) {
newNode.putAsset(asset);
}
}
// Add existing custom categories
for (RequisitionCategory cat : curNode.getCategories()) {
if (!cat.getName().startsWith("VMWare")) {
newNode.putCategory(cat);
}
}
/*
* For each interface on the new requisition,
* - Retrieve the list of custom services from the corresponding interface on the existing requisition,
* matching the interface by the IP address
* - If the list of services is not empty, add them to the new interface
*/
for (RequisitionInterface intf : curNode.getInterfaces()) {
List<RequisitionMonitoredService> services = getManualyConfiguredServices(intf);
if (!services.isEmpty()) {
RequisitionInterface newIntf = getRequisitionInterface(newNode, intf.getIpAddr());
if (newIntf != null) {
newIntf.getMonitoredServices().addAll(services);
}
}
}
}
}
}
}
}
return newReq;
}
use of org.opennms.netmgt.provision.persist.requisition.RequisitionAsset in project opennms by OpenNMS.
the class VmwareImporter method createRequisitionNode.
/**
* Creates a requisition node for the given managed entity and type.
*
* @param ipAddresses the set of Ip addresses
* @param managedEntity the managed entity
* @return the generated requisition node
*/
private RequisitionNode createRequisitionNode(Set<String> ipAddresses, ManagedEntity managedEntity, int apiVersion, VmwareViJavaAccess vmwareViJavaAccess) {
RequisitionNode requisitionNode = new RequisitionNode();
// Setting the node label
requisitionNode.setNodeLabel(managedEntity.getName());
// Foreign Id consisting of managed entity Id
requisitionNode.setForeignId(managedEntity.getMOR().getVal());
/*
* Original version:
*
* Foreign Id consisting of VMware management server's hostname and managed entity id
*
* requisitionNode.setForeignId(m_hostname + "/" + managedEntity.getMOR().getVal());
*/
logger.debug("Start primary interface search for managed entity '{}' (ID: {})", managedEntity.getName(), managedEntity.getMOR().getVal());
if (managedEntity instanceof VirtualMachine) {
boolean firstInterface = true;
// add all given interfaces
for (String ipAddress : ipAddresses) {
try {
if ((request.isPersistIPv4() && InetAddressUtils.isIPv4Address(ipAddress)) || (request.isPersistIPv6() && InetAddressUtils.isIPv6Address(ipAddress))) {
InetAddress inetAddress = InetAddress.getByName(ipAddress);
if (!inetAddress.isLoopbackAddress()) {
RequisitionInterface requisitionInterface = new RequisitionInterface();
requisitionInterface.setIpAddr(ipAddress);
// the first one will be primary
if (firstInterface) {
requisitionInterface.setSnmpPrimary(PrimaryType.PRIMARY);
for (String service : request.getVirtualMachineServices()) {
requisitionInterface.insertMonitoredService(new RequisitionMonitoredService(service.trim()));
}
firstInterface = false;
} else {
requisitionInterface.setSnmpPrimary(PrimaryType.SECONDARY);
}
requisitionInterface.setManaged(Boolean.TRUE);
requisitionInterface.setStatus(Integer.valueOf(1));
requisitionNode.putInterface(requisitionInterface);
}
}
} catch (UnknownHostException unknownHostException) {
logger.warn("Invalid IP address '{}'", unknownHostException.getMessage());
}
}
} else {
if (managedEntity instanceof HostSystem) {
boolean reachableInterfaceFound = false, firstInterface = true;
List<RequisitionInterface> requisitionInterfaceList = new ArrayList<>();
RequisitionInterface primaryInterfaceCandidate = null;
// add all given interfaces
for (String ipAddress : ipAddresses) {
try {
if ((request.isPersistIPv4() && InetAddressUtils.isIPv4Address(ipAddress)) || (request.isPersistIPv6() && InetAddressUtils.isIPv6Address(ipAddress))) {
InetAddress inetAddress = InetAddress.getByName(ipAddress);
if (!inetAddress.isLoopbackAddress()) {
RequisitionInterface requisitionInterface = new RequisitionInterface();
requisitionInterface.setIpAddr(ipAddress);
if (firstInterface) {
primaryInterfaceCandidate = requisitionInterface;
firstInterface = false;
}
if (!reachableInterfaceFound && reachableCimService(vmwareViJavaAccess, (HostSystem) managedEntity, ipAddress)) {
primaryInterfaceCandidate = requisitionInterface;
reachableInterfaceFound = true;
}
requisitionInterface.setManaged(Boolean.TRUE);
requisitionInterface.setStatus(Integer.valueOf(1));
requisitionInterface.setSnmpPrimary(PrimaryType.SECONDARY);
requisitionInterfaceList.add(requisitionInterface);
}
}
} catch (UnknownHostException unknownHostException) {
logger.warn("Invalid IP address '{}'", unknownHostException.getMessage());
}
}
if (primaryInterfaceCandidate != null) {
if (reachableInterfaceFound) {
logger.warn("Found reachable primary interface '{}'", primaryInterfaceCandidate.getIpAddr());
} else {
logger.warn("Only non-reachable interfaces found, using first one for primary interface '{}'", primaryInterfaceCandidate.getIpAddr());
}
primaryInterfaceCandidate.setSnmpPrimary(PrimaryType.PRIMARY);
for (String service : request.getHostSystemServices()) {
if (reachableInterfaceFound || !"VMwareCim-HostSystem".equals(service)) {
primaryInterfaceCandidate.insertMonitoredService(new RequisitionMonitoredService(service.trim()));
}
}
} else {
logger.warn("No primary interface found");
}
for (RequisitionInterface requisitionInterface : requisitionInterfaceList) {
requisitionNode.putInterface(requisitionInterface);
}
} else {
logger.error("Undefined type of managedEntity '{}'", managedEntity.getMOR().getType());
return null;
}
}
/*
* For now we use displaycategory, notifycategory and pollercategory for storing
* the vcenter Ip address, the username and the password
*/
String powerState = "unknown";
final StringBuilder vmwareTopologyInfo = new StringBuilder();
// putting parents to topology information
ManagedEntity parentEntity = managedEntity.getParent();
do {
if (vmwareTopologyInfo.length() > 0) {
vmwareTopologyInfo.append(", ");
}
try {
if (parentEntity != null && parentEntity.getMOR() != null) {
vmwareTopologyInfo.append(parentEntity.getMOR().getVal() + "/" + URLEncoder.encode(parentEntity.getName(), StandardCharsets.UTF_8.name()));
} else {
logger.warn("Can't add topologyInformation because either the parentEntity or the MOR is null for " + managedEntity.getName());
}
} catch (UnsupportedEncodingException e) {
logger.warn("Unsupported encoding '{}'", e.getMessage());
}
parentEntity = parentEntity == null ? null : parentEntity.getParent();
} while (parentEntity != null);
if (managedEntity instanceof HostSystem) {
HostSystem hostSystem = (HostSystem) managedEntity;
HostRuntimeInfo hostRuntimeInfo = hostSystem.getRuntime();
if (hostRuntimeInfo == null) {
logger.debug("hostRuntimeInfo=null");
} else {
HostSystemPowerState hostSystemPowerState = hostRuntimeInfo.getPowerState();
if (hostSystemPowerState == null) {
logger.debug("hostSystemPowerState=null");
} else {
powerState = hostSystemPowerState.toString();
}
}
try {
if (request.isTopologyDatastores()) {
for (Datastore datastore : hostSystem.getDatastores()) {
if (vmwareTopologyInfo.length() > 0) {
vmwareTopologyInfo.append(", ");
}
try {
vmwareTopologyInfo.append(datastore.getMOR().getVal() + "/" + URLEncoder.encode(datastore.getSummary().getName(), StandardCharsets.UTF_8.name()));
} catch (UnsupportedEncodingException e) {
logger.warn("Unsupported encoding '{}'", e.getMessage());
}
}
}
} catch (RemoteException e) {
logger.warn("Cannot retrieve datastores for managedEntity '{}': '{}'", managedEntity.getMOR().getVal(), e.getMessage());
}
try {
if (request.isTopologyNetworks()) {
for (Network network : hostSystem.getNetworks()) {
if (vmwareTopologyInfo.length() > 0) {
vmwareTopologyInfo.append(", ");
}
try {
if (network instanceof DistributedVirtualPortgroup ? request.isTopologyPortGroups() : true) {
vmwareTopologyInfo.append(network.getMOR().getVal() + "/" + URLEncoder.encode(network.getSummary().getName(), StandardCharsets.UTF_8.name()));
}
} catch (UnsupportedEncodingException e) {
logger.warn("Unsupported encoding '{}'", e.getMessage());
}
}
}
} catch (RemoteException e) {
logger.warn("Cannot retrieve networks for managedEntity '{}': '{}'", managedEntity.getMOR().getVal(), e.getMessage());
}
} else {
if (managedEntity instanceof VirtualMachine) {
VirtualMachine virtualMachine = (VirtualMachine) managedEntity;
VirtualMachineRuntimeInfo virtualMachineRuntimeInfo = virtualMachine.getRuntime();
if (virtualMachineRuntimeInfo == null) {
logger.debug("virtualMachineRuntimeInfo=null");
} else {
VirtualMachinePowerState virtualMachinePowerState = virtualMachineRuntimeInfo.getPowerState();
if (virtualMachinePowerState == null) {
logger.debug("virtualMachinePowerState=null");
} else {
powerState = virtualMachinePowerState.toString();
}
}
try {
if (request.isTopologyDatastores()) {
for (Datastore datastore : virtualMachine.getDatastores()) {
if (vmwareTopologyInfo.length() > 0) {
vmwareTopologyInfo.append(", ");
}
try {
vmwareTopologyInfo.append(datastore.getMOR().getVal() + "/" + URLEncoder.encode(datastore.getSummary().getName(), StandardCharsets.UTF_8.name()));
} catch (UnsupportedEncodingException e) {
logger.warn("Unsupported encoding '{}'", e.getMessage());
}
}
}
} catch (RemoteException e) {
logger.warn("Cannot retrieve datastores for managedEntity '{}': '{}'", managedEntity.getMOR().getVal(), e.getMessage());
}
try {
if (request.isTopologyNetworks()) {
for (Network network : virtualMachine.getNetworks()) {
if (vmwareTopologyInfo.length() > 0) {
vmwareTopologyInfo.append(", ");
}
try {
if (network instanceof DistributedVirtualPortgroup ? request.isTopologyPortGroups() : true) {
vmwareTopologyInfo.append(network.getMOR().getVal() + "/" + URLEncoder.encode(network.getSummary().getName(), StandardCharsets.UTF_8.name()));
}
} catch (UnsupportedEncodingException e) {
logger.warn("Unsupported encoding '{}'", e.getMessage());
}
}
}
} catch (RemoteException e) {
logger.warn("Cannot retrieve networks for managedEntity '{}': '{}'", managedEntity.getMOR().getVal(), e.getMessage());
}
if (vmwareTopologyInfo.length() > 0) {
vmwareTopologyInfo.append(", ");
}
try {
if (m_hostSystemMap.get(virtualMachine.getRuntime().getHost().getVal()) != null) {
vmwareTopologyInfo.append(virtualMachine.getRuntime().getHost().getVal() + "/" + URLEncoder.encode(m_hostSystemMap.get(virtualMachine.getRuntime().getHost().getVal()), StandardCharsets.UTF_8.name()));
} else {
logger.warn("Problem building topology information for virtual machine '{}' with power state '{}' running on host system '{}'", virtualMachine.getMOR().getVal(), powerState, virtualMachine.getRuntime().getHost().getVal());
}
} catch (UnsupportedEncodingException e) {
logger.warn("Unsupported encoding '{}'", e.getMessage());
}
} else {
logger.error("Undefined type of managedEntity '{}'", managedEntity.getMOR().getType());
return null;
}
}
RequisitionAsset requisitionAssetHostname = new RequisitionAsset("vmwareManagementServer", request.getHostname());
requisitionNode.putAsset(requisitionAssetHostname);
RequisitionAsset requisitionAssetType = new RequisitionAsset("vmwareManagedEntityType", (managedEntity instanceof HostSystem ? "HostSystem" : "VirtualMachine"));
requisitionNode.putAsset(requisitionAssetType);
RequisitionAsset requisitionAssetId = new RequisitionAsset("vmwareManagedObjectId", managedEntity.getMOR().getVal());
requisitionNode.putAsset(requisitionAssetId);
RequisitionAsset requisitionAssetTopologyInfo = new RequisitionAsset("vmwareTopologyInfo", vmwareTopologyInfo.toString());
requisitionNode.putAsset(requisitionAssetTopologyInfo);
RequisitionAsset requisitionAssetState = new RequisitionAsset("vmwareState", powerState);
requisitionNode.putAsset(requisitionAssetState);
requisitionNode.putCategory(new RequisitionCategory("VMware" + apiVersion));
return requisitionNode;
}
use of org.opennms.netmgt.provision.persist.requisition.RequisitionAsset in project opennms by OpenNMS.
the class VmwareImporter method iterateHostSystems.
/**
* Iterates through the host systems and adds them to the requisition object.
*
* @param vmwareViJavaAccess the access/connection to use
*/
private void iterateHostSystems(VmwareViJavaAccess vmwareViJavaAccess, int apiVersion) {
ManagedEntity[] managedEntities = null;
logger.debug("Starting to iterate Host Systems on VMware host {} ...", request.getHostname());
try {
managedEntities = vmwareViJavaAccess.searchManagedEntities("HostSystem");
} catch (RemoteException e) {
logger.error("Error iterating Host Systems on VMware host {}", request.getHostname());
logger.error("Exception thrown while iterating for Host Systems: ", e);
}
if (managedEntities != null) {
Arrays.stream(managedEntities).map(m -> (HostSystem) m).forEach(hostSystem -> {
synchronized (m_hostSystemMap) {
m_hostSystemMap.put(hostSystem.getMOR().getVal(), hostSystem.getName());
}
});
final ExecutorService executor = Executors.newFixedThreadPool(Math.min(managedEntities.length, 10));
final List<CompletableFuture<Optional<RequisitionNode>>> completableFutures = Arrays.stream(managedEntities).map(managedEntity -> (HostSystem) managedEntity).filter(hostSystem -> checkHostPowerState(hostSystem)).filter(hostSystem -> checkForAttribute(hostSystem)).map(hostSystem -> CompletableFuture.supplyAsync(() -> {
logger.debug("Adding Host System '{}' (ID: {})", hostSystem.getName(), hostSystem.getMOR().getVal());
TreeSet<String> ipAddresses = vmwareViJavaAccess.getHostSystemIpAddresses(hostSystem);
logger.debug("Found {} IP addresses for Host System '{}' (ID: {}): {}", ipAddresses.size(), hostSystem.getName(), hostSystem.getMOR().getVal(), ipAddresses);
RequisitionNode node = createRequisitionNode(ipAddresses, hostSystem, apiVersion, vmwareViJavaAccess);
try {
node.putAsset(new RequisitionAsset("cpu", hostSystem.getHardware().getCpuInfo().getNumCpuCores() + " cores"));
} catch (Exception e) {
logger.debug("Can't find CPU information for '{}' (ID: {})", hostSystem.getName(), hostSystem.getMOR().getVal());
}
try {
node.putAsset(new RequisitionAsset("ram", Math.round(hostSystem.getHardware().getMemorySize() / 1000000f) + " MB"));
} catch (Exception e) {
logger.debug("Can't find Memory information for '{}' (ID: {})", hostSystem.getName(), hostSystem.getMOR().getVal());
}
return request.isPersistHosts() ? Optional.of(node) : Optional.<RequisitionNode>empty();
}, executor)).collect(Collectors.toList());
completableFutures.stream().map(CompletableFuture::join).filter(Optional::isPresent).forEach(m -> {
synchronized (m_requisition) {
m_requisition.insertNode(m.get());
}
});
executor.shutdown();
}
}
use of org.opennms.netmgt.provision.persist.requisition.RequisitionAsset in project opennms by OpenNMS.
the class VmwareImporter method iterateVirtualMachines.
/**
* Iterates through the virtual machines and adds them to the requisition object.
*
* @param vmwareViJavaAccess the access/connection to use
*/
private void iterateVirtualMachines(VmwareViJavaAccess vmwareViJavaAccess, int apiVersion) {
ManagedEntity[] managedEntities = null;
logger.debug("Starting to iterate Virtual Machines on VMware host {} ...", request.getHostname());
try {
managedEntities = vmwareViJavaAccess.searchManagedEntities("VirtualMachine");
} catch (RemoteException e) {
logger.error("Error iterating Virtual Machines on VMware host {}", request.getHostname());
logger.error("Exception thrown while iterating for Virtual Machines: ", e);
}
if (managedEntities != null) {
final ExecutorService executor = Executors.newFixedThreadPool(Math.min(managedEntities.length, 10));
final List<CompletableFuture<Optional<RequisitionNode>>> completableFutures = Arrays.stream(managedEntities).map(managedEntity -> (VirtualMachine) managedEntity).filter(virtualMachine -> checkVMPowerState(virtualMachine)).filter(virtualMachine -> checkForAttribute(virtualMachine)).map(virtualMachine -> CompletableFuture.supplyAsync(() -> {
logger.debug("Adding Virtual Machine '{}' (ID: {})", virtualMachine.getName(), virtualMachine.getMOR().getVal());
TreeSet<String> ipAddresses = vmwareViJavaAccess.getVirtualMachineIpAddresses(virtualMachine);
logger.debug("Found {} IP addresses for Virtual Machine '{}' (ID: {}): {}", ipAddresses.size(), virtualMachine.getName(), virtualMachine.getMOR().getVal(), ipAddresses);
RequisitionNode node = createRequisitionNode(ipAddresses, virtualMachine, apiVersion, vmwareViJavaAccess);
if (virtualMachine.getGuest().getGuestFullName() != null) {
node.putAsset(new RequisitionAsset("operatingSystem", virtualMachine.getGuest().getGuestFullName()));
}
try {
node.putAsset(new RequisitionAsset("cpu", virtualMachine.getConfig().getHardware().getNumCPU() + " vCPU"));
} catch (Exception e) {
logger.debug("Can't find CPU information for {} (ID: {})", virtualMachine.getName(), virtualMachine.getMOR().getVal());
}
try {
node.putAsset(new RequisitionAsset("ram", virtualMachine.getConfig().getHardware().getMemoryMB() + " MB"));
} catch (Exception e) {
logger.debug("Can't find Memory information for {} (ID: {})", virtualMachine.getName(), virtualMachine.getMOR().getVal());
}
return request.isPersistVMs() ? Optional.of(node) : Optional.<RequisitionNode>empty();
}, executor)).collect(Collectors.toList());
completableFutures.stream().map(CompletableFuture::join).filter(Optional::isPresent).forEach(m -> {
synchronized (m_requisition) {
m_requisition.insertNode(m.get());
}
});
executor.shutdown();
}
}
Aggregations