Java tutorial
/*************************************************************************** * Copyright (c) 2012-2015 VMware, Inc. All Rights Reserved. * Licensed 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 com.vmware.bdd.entity; import java.util.ArrayList; import java.util.Collection; import java.util.Collections; import java.util.Comparator; import java.util.HashMap; import java.util.HashSet; import java.util.List; import java.util.Map; import java.util.Set; import javax.persistence.*; import org.apache.commons.lang.builder.EqualsBuilder; import org.apache.log4j.Logger; import com.vmware.bdd.apitypes.IpConfigInfo; import com.vmware.bdd.apitypes.NetConfigInfo.NetTrafficType; import com.vmware.bdd.apitypes.NodeRead; import com.vmware.bdd.apitypes.NodeStatus; import com.vmware.bdd.apitypes.StorageRead.DiskType; import com.vmware.bdd.exception.BddException; import com.vmware.bdd.spectypes.NicSpec; import com.vmware.bdd.utils.AuAssert; import com.vmware.bdd.utils.CommonUtil; import com.vmware.bdd.utils.Constants; /** * Hadoop Node Entity class: describes hadoop node info * */ @NamedNativeQueries({ @NamedNativeQuery(name = "node.countByNodeGroup", query = "select count(n.id) from node as n where n.node_group_id=:nodeGroupId") }) @Entity @SequenceGenerator(name = "IdSequence", sequenceName = "node_seq", allocationSize = 1) @Table(name = "node") public class NodeEntity extends EntityBase { private static final Logger logger = Logger.getLogger(NodeEntity.class); @Column(name = "vm_name", unique = true, nullable = false) private String vmName; @Column(name = "moid", unique = true) private String moId; @Column(name = "rack") private String rack; @Column(name = "host_name") private String hostName; // vm status, poweredOn/poweredOff @Enumerated(EnumType.STRING) @Column(name = "status") private NodeStatus status = NodeStatus.NOT_EXIST; // this field means VM status changed from powered on to powered off or vice visa. // if status changed is true, when user query status, will start a query to Ironfan // to get VM bootstrap status @Column(name = "power_status_changed") private boolean powerStatusChanged; @Column(name = "action") private String action; @Column(name = "action_failed") private boolean actionFailed; @Column(name = "error_message") private String errMessage; @Column(name = "guest_host_name") private String guestHostName; @Column(name = "cpu_number") private Integer cpuNum; @Column(name = "memory") private Long memorySize; @Column(name = "version") private String version; @ManyToOne @JoinColumn(name = "node_group_id") private NodeGroupEntity nodeGroup; @ManyToOne @JoinColumn(name = "vc_rp_id") private VcResourcePoolEntity vcRp; @OneToMany(mappedBy = "nodeEntity", cascade = CascadeType.ALL, fetch = FetchType.LAZY) @OrderBy("id") private Set<DiskEntity> disks; @OneToMany(mappedBy = "nodeEntity", cascade = CascadeType.ALL, fetch = FetchType.LAZY) private Set<NicEntity> nics; public NodeEntity() { this.disks = new HashSet<DiskEntity>(); this.nics = new HashSet<NicEntity>(); } public NodeEntity(String vmName, String rack, String hostName, NodeStatus status) { super(); this.vmName = vmName; this.rack = rack; this.hostName = hostName; this.status = status; this.disks = new HashSet<DiskEntity>(); this.nics = new HashSet<NicEntity>(); } public static List<DiskEntity> toDiskEntityList(Collection<DiskEntity> diskEntityCollection) { ArrayList<DiskEntity> diskSpecArrayList = new ArrayList<>(); for (DiskEntity entity : diskEntityCollection) { diskSpecArrayList.add(entity); } return diskSpecArrayList; } public static void sortDiskOrder(List<DiskEntity> diskSpecs) { //ensure the order by entity Id Collections.sort(diskSpecs, new Comparator<DiskEntity>() { @Override public int compare(DiskEntity o1, DiskEntity o2) { return Long.compare(o1.getId(), o2.getId()); } }); } public List<String> getVolumns() { List<String> volumns = new ArrayList<String>(); if (disks == null || disks.size() < 1) { return volumns; } List<DiskEntity> sortedDisks = new ArrayList<>(); sortedDisks.addAll(disks); sortDiskOrder(sortedDisks); for (DiskEntity disk : sortedDisks) { if (DiskType.DATA_DISK.getType().equals(disk.getDiskType()) || DiskType.SWAP_DISK.getType().equals(disk.getDiskType())) volumns.add(disk.getDiskType() + ":" + disk.getHardwareUUID()); } return volumns; } public List<String> getDataVolumnsMountPoint() { List<DiskEntity> sortedDisks = new ArrayList<>(); sortedDisks.addAll(disks); sortDiskOrder(sortedDisks); //Todo(qjin): need to check List<String> mountPoints = new ArrayList<String>(); int i = 0; for (DiskEntity disk : sortedDisks) { if (DiskType.DATA_DISK.getType().equals(disk.getDiskType())) { //Todo(qjin): when will the uuid be null? if (disk.getHardwareUUID() == null) { continue; } mountPoints.add("/mnt/data" + i++); } } return mountPoints; } public String getGuestHostName() { return guestHostName; } public void setGuestHostName(String guestHostName) { this.guestHostName = guestHostName; } public boolean isPowerStatusChanged() { return powerStatusChanged; } public void setPowerStatusChanged(boolean powerStatusChanged) { this.powerStatusChanged = powerStatusChanged; } public String getVmName() { return vmName; } public void setVmName(String vmName) { this.vmName = vmName; } public String getMoId() { return moId; } public void setMoId(String moId) { this.moId = moId; } public String getRack() { return rack; } public void setRack(String rack) { this.rack = rack; } public String getHostName() { return hostName; } public void setHostName(String hostName) { this.hostName = hostName; } public NodeStatus getStatus() { return status; } public void setUnavailableConnection() { this.status = NodeStatus.DISCONNECTED; logger.debug("node " + getVmName() + " status changed to " + status); } public boolean isDisconnected() { return (this.status == NodeStatus.DISCONNECTED); } /* * This method will compare the setting status with existing status. * If they are different, powerChanged field will be set accordingly. * To turn off statusChanged, user need to call setStatusChanged explicitly. * */ public void setStatus(NodeStatus status) { if (status.ordinal() >= NodeStatus.POWERED_ON.ordinal() && this.status.ordinal() >= NodeStatus.POWERED_ON.ordinal()) { if (status.ordinal() > this.status.ordinal()) { this.status = status; logger.debug("node " + getVmName() + " status changed to " + status); } return; } else if (status.ordinal() <= NodeStatus.POWERED_OFF.ordinal() && this.status.ordinal() <= NodeStatus.POWERED_OFF.ordinal()) { // the new status and old status are in same range, both powered on, or both powered off status // don't think that power status is changed if (this.status != status) { this.status = status; logger.debug("node " + getVmName() + " status changed to " + status); } return; } if (this.status != status) { powerStatusChanged = true; logger.debug("node " + getVmName() + " status changed to " + status); this.status = status; } } public void setStatus(NodeStatus status, boolean validation) { if (validation) { setStatus(status); } else { logger.debug("Set node " + getVmName() + " status to" + status + " without validation"); this.status = status; } } public String getAction() { return action; } public void setAction(String action) { if (!(new EqualsBuilder().append(this.action, action).isEquals())) { logger.debug("node " + getVmName() + " action changed to " + action); this.action = action; } } public NicEntity getPrimaryMgtNic() { if (nics == null || nics.isEmpty()) { return null; } for (NicEntity nicEntity : nics) { for (NicSpec.NetTrafficDefinition netDef : nicEntity.getNetTrafficDefs()) { if (netDef.getTrafficType().equals(NetTrafficType.MGT_NETWORK) && netDef.getIndex() == 0) { return nicEntity; } } } return (NicEntity) nics.toArray()[0]; } public String getPrimaryMgtIpV4() { NicEntity nicEntity = getPrimaryMgtNic(); if (nicEntity == null) { return Constants.NULL_IPV4_ADDRESS; } return nicEntity.getIpv4Address(); } /** * @return the cpuNum */ public Integer getCpuNum() { return cpuNum; } /** * @param cpuNum * the cpuNum to set */ public void setCpuNum(Integer cpuNum) { this.cpuNum = cpuNum; } /** * @return the memorySize */ public Long getMemorySize() { return memorySize; } /** * @param memorySize * the memorySize to set */ public void setMemorySize(Long memorySize) { this.memorySize = memorySize; } public NodeGroupEntity getNodeGroup() { return nodeGroup; } public void setNodeGroup(NodeGroupEntity nodeGroup) { this.nodeGroup = nodeGroup; } public VcResourcePoolEntity getVcRp() { return vcRp; } public void setVcRp(VcResourcePoolEntity vcRp) { this.vcRp = vcRp; } public List<String> getDatastoreNameList() { Set<String> datastores = new HashSet<String>(disks.size()); for (DiskEntity disk : disks) { datastores.add(disk.getDatastoreName()); } return new ArrayList<String>(datastores); } public Set<DiskEntity> getDisks() { return disks; } public void setDisks(Set<DiskEntity> disks) { this.disks = disks; } public void copy(NodeEntity newNode) { this.status = newNode.getStatus(); this.action = newNode.getAction(); this.memorySize = newNode.getMemorySize(); this.cpuNum = newNode.getCpuNum(); if (newNode.getRack() != null) { this.rack = newNode.getRack(); } if (newNode.getHostName() != null) { this.hostName = newNode.getHostName(); } if (newNode.getMoId() != null) { this.moId = newNode.getMoId(); } if (newNode.getVcRp() != null) { this.vcRp = newNode.getVcRp(); } if (newNode.getDisks() != null && !newNode.getDisks().isEmpty()) { if (this.disks == null) this.disks = new HashSet<>(newNode.disks.size()); for (DiskEntity disk : newNode.getDisks()) { DiskEntity clone = disk.copy(disk); clone.setNodeEntity(this); this.disks.add(clone); } } } public Set<String> fetchAllPortGroups() { return fetchPortGroupToIpMap().keySet(); } public Map<String, String> fetchPortGroupToIpMap() { Map<String, String> pgToIpMap = new HashMap<String, String>(); if (nics != null && !nics.isEmpty()) { for (NicEntity nicEntity : nics) { pgToIpMap.put(nicEntity.getNetworkEntity().getPortGroup(), nicEntity.getIpv4Address()); } } return pgToIpMap; } public boolean nicsReady() { if (nics == null || nics.isEmpty()) { return false; } for (NicEntity nicEntity : nics) { if (!nicEntity.isReady()) { return false; } } return true; } public void resetNicsInfo() { if (nics == null || nics.isEmpty()) { return; } for (NicEntity nicEntity : nics) { nicEntity.setConnected(false); nicEntity.setIpv4Address(Constants.NULL_IPV4_ADDRESS); nicEntity.setIpv6Address(Constants.NULL_IPV6_ADDRESS); } } public NicEntity findNic(NetworkEntity networkEntity) { AuAssert.check(networkEntity != null); for (NicEntity nicEntity : nics) { if (nicEntity.getNetworkEntity() != null && nicEntity.getNetworkEntity().equals(networkEntity)) { return nicEntity; } } return null; } public DiskEntity findDisk(String diskName) { AuAssert.check(diskName != null && !diskName.isEmpty() && this.disks != null); for (DiskEntity disk : this.disks) { if (disk.getName().equals(diskName)) return disk; } return null; } public DiskEntity findSystemDisk() { AuAssert.check(this.disks != null); for (DiskEntity disk : this.disks) { if (DiskType.SYSTEM_DISK.getType().equals(disk.getDiskType())) return disk; } return null; } public boolean isObsoleteNode() { // if resize failed, some node is out of cluster scope. try { long index = CommonUtil.getVmIndex(vmName); if (index < nodeGroup.getDefineInstanceNum()) { return false; } else { return true; } } catch (BddException e) { logger.warn("VM " + vmName + " violate name convention"); return true; } } // if includeVolumes is true, this method must be called inside a transaction public NodeRead toNodeRead(boolean includeVolumes) { NodeRead node = new NodeRead(); node.setRack(this.rack); node.setHostName(this.hostName); // For class NodeRead, keep "ipConfigsInfo" structure since it's used by software provision node.setIpConfigs(convertToIpConfigInfo()); node.setName(this.vmName); node.setMoId(this.moId); node.setStatus(this.status != null ? this.status.toString() : null); node.setAction(this.action); node.setVersion(this.version); if (this.cpuNum != null) { node.setCpuNumber(this.cpuNum); } if (this.memorySize != null) { node.setMemory(this.memorySize); } List<String> roleNames = nodeGroup.getRoleNameList(); node.setRoles(roleNames); if (includeVolumes) node.setVolumes(this.getVolumns()); if (actionFailed) { node.setActionFailed(true); } if (errMessage != null && !errMessage.isEmpty()) { node.setErrMessage(errMessage); } return node; } /** * convert "nics" to NodeRead's "ipConfigInfo" field * * @return */ public Map<NetTrafficType, List<IpConfigInfo>> convertToIpConfigInfo() { Map<NetTrafficType, List<IpConfigInfo>> ipConfigInfo = new HashMap<NetTrafficType, List<IpConfigInfo>>(); if (nics != null) { for (NicEntity nicEntity : nics) { for (NicSpec.NetTrafficDefinition netDef : nicEntity.getNetTrafficDefs()) { if (!ipConfigInfo.containsKey(netDef.getTrafficType())) { ipConfigInfo.put(netDef.getTrafficType(), new ArrayList<IpConfigInfo>()); } List<IpConfigInfo> ipInfo = ipConfigInfo.get(netDef.getTrafficType()); IpConfigInfo newIpConfig = new IpConfigInfo(netDef.getTrafficType(), nicEntity.getNetworkEntity().getName(), nicEntity.getNetworkEntity().getPortGroup(), nicEntity.getIpv4Address(), nicEntity.getFqdn()); if (netDef.getIndex() + 1 > ipInfo.size()) { while (ipInfo.size() < netDef.getIndex() + 1) { ipInfo.add(null); } } ipInfo.remove(netDef.getIndex()); ipInfo.add(netDef.getIndex(), newIpConfig); } } } return ipConfigInfo; } @Override public int hashCode() { if (this.vmName != null) { return this.vmName.hashCode(); } if (this.id != null) { return this.id.intValue(); } return 0; } @Override public boolean equals(Object node) { if (!(node instanceof NodeEntity)) return false; if (this.vmName != null && ((NodeEntity) node).getVmName() != null) { return ((NodeEntity) node).getVmName().equals(this.vmName); } return false; } public void cleanupErrorMessage() { this.actionFailed = false; this.errMessage = null; this.action = null; } public Set<NicEntity> getNics() { return nics; } public void setNics(Set<NicEntity> nics) { this.nics = nics; } public boolean isActionFailed() { return actionFailed; } public void setActionFailed(boolean actionFailed) { this.actionFailed = actionFailed; } public String getErrMessage() { return errMessage; } public void setErrMessage(String errMessage) { this.errMessage = errMessage; } public String getVersion() { return version; } public void setVersion(String version) { this.version = version; } public boolean needUpgrade(String serverVersion) { return (this.getMoId() != null && (this.getVersion() == null || !serverVersion.equals(this.getVersion()))); } public boolean canBeUpgrade() { String nodeIp = this.getPrimaryMgtIpV4(); return this.status.ordinal() >= NodeStatus.POWERED_ON.ordinal() && nodeIp != null && !Constants.NULL_IPV4_ADDRESS.equals(nodeIp); } public void cleanupErrorMessageForUpgrade() { this.actionFailed = false; this.errMessage = null; if (!canBeUpgrade()) { this.action = null; } } public boolean isVmReady() { return NodeStatus.VM_READY.equals(this.status); } public String getVmNameWithIP() { return this.getVmName() + "(" + this.getPrimaryMgtIpV4() + ")"; } public boolean isNotExist() { return NodeStatus.NOT_EXIST.equals(this.status); } }