| // 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 com.cloud.baremetal; |
| |
| import java.util.HashMap; |
| import java.util.Map; |
| |
| import javax.ejb.Local; |
| import javax.naming.ConfigurationException; |
| |
| import org.apache.log4j.Logger; |
| |
| import com.cloud.agent.IAgentControl; |
| import com.cloud.agent.api.Answer; |
| import com.cloud.agent.api.CheckNetworkAnswer; |
| import com.cloud.agent.api.CheckNetworkCommand; |
| import com.cloud.agent.api.CheckVirtualMachineAnswer; |
| import com.cloud.agent.api.CheckVirtualMachineCommand; |
| import com.cloud.agent.api.Command; |
| import com.cloud.agent.api.MaintainAnswer; |
| import com.cloud.agent.api.MaintainCommand; |
| import com.cloud.agent.api.MigrateAnswer; |
| import com.cloud.agent.api.MigrateCommand; |
| import com.cloud.agent.api.PingCommand; |
| import com.cloud.agent.api.PingRoutingCommand; |
| import com.cloud.agent.api.PrepareForMigrationAnswer; |
| import com.cloud.agent.api.PrepareForMigrationCommand; |
| import com.cloud.agent.api.ReadyAnswer; |
| import com.cloud.agent.api.ReadyCommand; |
| import com.cloud.agent.api.RebootAnswer; |
| import com.cloud.agent.api.RebootCommand; |
| import com.cloud.agent.api.StartAnswer; |
| import com.cloud.agent.api.StartCommand; |
| import com.cloud.agent.api.StartupCommand; |
| import com.cloud.agent.api.StartupRoutingCommand; |
| import com.cloud.agent.api.StopAnswer; |
| import com.cloud.agent.api.StopCommand; |
| import com.cloud.agent.api.baremetal.IpmISetBootDevCommand; |
| import com.cloud.agent.api.baremetal.IpmISetBootDevCommand.BootDev; |
| import com.cloud.agent.api.baremetal.IpmiBootorResetCommand; |
| import com.cloud.agent.api.to.VirtualMachineTO; |
| import org.apache.cloudstack.api.ApiConstants; |
| import com.cloud.host.Host.Type; |
| import com.cloud.hypervisor.Hypervisor; |
| import com.cloud.resource.ServerResource; |
| import com.cloud.utils.exception.CloudRuntimeException; |
| import com.cloud.utils.script.OutputInterpreter; |
| import com.cloud.utils.script.Script; |
| import com.cloud.utils.script.Script2; |
| import com.cloud.utils.script.Script2.ParamType; |
| import com.cloud.vm.VirtualMachine; |
| import com.cloud.vm.VirtualMachine.State; |
| |
| @Local(value = ServerResource.class) |
| public class BareMetalResourceBase implements ServerResource { |
| private static final Logger s_logger = Logger.getLogger(BareMetalResourceBase.class); |
| protected HashMap<String, State> _vms = new HashMap<String, State>(2); |
| protected String _name; |
| protected String _uuid; |
| protected String _zone; |
| protected String _pod; |
| protected String _cluster; |
| protected long _memCapacity; |
| protected long _cpuCapacity; |
| protected long _cpuNum; |
| protected String _mac; |
| protected String _username; |
| protected String _password; |
| protected String _ip; |
| protected IAgentControl _agentControl; |
| protected Script2 _pingCommand; |
| protected Script2 _setPxeBootCommand; |
| protected Script2 _setDiskBootCommand; |
| protected Script2 _rebootCommand; |
| protected Script2 _getStatusCommand; |
| protected Script2 _powerOnCommand; |
| protected Script2 _powerOffCommand; |
| protected Script2 _forcePowerOffCommand; |
| protected Script2 _bootOrRebootCommand; |
| protected String _vmName; |
| |
| private void changeVmState(String vmName, VirtualMachine.State state) { |
| synchronized (_vms) { |
| _vms.put(vmName, state); |
| } |
| } |
| |
| private State removeVmState(String vmName) { |
| synchronized (_vms) { |
| return _vms.remove(vmName); |
| } |
| } |
| |
| @Override |
| public boolean configure(String name, Map<String, Object> params) throws ConfigurationException { |
| _name = name; |
| _uuid = (String) params.get("guid"); |
| try { |
| _memCapacity = Long.parseLong((String)params.get(ApiConstants.MEMORY)) * 1024L * 1024L; |
| _cpuCapacity = Long.parseLong((String)params.get(ApiConstants.CPU_SPEED)); |
| _cpuNum = Long.parseLong((String)params.get(ApiConstants.CPU_NUMBER)); |
| } catch (NumberFormatException e) { |
| throw new ConfigurationException(String.format("Unable to parse number of CPU or memory capacity " + |
| "or cpu capacity(cpu number = %1$s memCapacity=%2$s, cpuCapacity=%3$s", (String)params.get(ApiConstants.CPU_NUMBER), |
| (String)params.get(ApiConstants.MEMORY), (String)params.get(ApiConstants.CPU_SPEED))); |
| } |
| |
| _zone = (String) params.get("zone"); |
| _pod = (String) params.get("pod"); |
| _cluster = (String) params.get("cluster"); |
| _ip = (String)params.get(ApiConstants.PRIVATE_IP); |
| _mac = (String)params.get(ApiConstants.HOST_MAC); |
| _username = (String)params.get(ApiConstants.USERNAME); |
| _password = (String)params.get(ApiConstants.PASSWORD); |
| _vmName = (String)params.get("vmName"); |
| |
| if (_pod == null) { |
| throw new ConfigurationException("Unable to get the pod"); |
| } |
| |
| if (_cluster == null) { |
| throw new ConfigurationException("Unable to get the pod"); |
| } |
| |
| if (_ip == null) { |
| throw new ConfigurationException("Unable to get the host address"); |
| } |
| |
| if (_mac.equalsIgnoreCase("unknown")) { |
| throw new ConfigurationException("Unable to get the host mac address"); |
| } |
| |
| if (_mac.split(":").length != 6) { |
| throw new ConfigurationException("Wrong MAC format(" + _mac + "). It must be in format of for example 00:11:ba:33:aa:dd which is not case sensitive"); |
| } |
| |
| if (_uuid == null) { |
| throw new ConfigurationException("Unable to get the uuid"); |
| } |
| |
| String injectScript = "scripts/util/ipmi.py"; |
| String scriptPath = Script.findScript("", injectScript); |
| if (scriptPath == null) { |
| throw new ConfigurationException("Cannot find ping script " + scriptPath); |
| } |
| _pingCommand = new Script2(scriptPath, s_logger); |
| _pingCommand.add("ping"); |
| _pingCommand.add("hostname="+_ip); |
| _pingCommand.add("usrname="+_username); |
| _pingCommand.add("password="+_password, ParamType.PASSWORD); |
| |
| _setPxeBootCommand = new Script2(scriptPath, s_logger); |
| _setPxeBootCommand.add("boot_dev"); |
| _setPxeBootCommand.add("hostname="+_ip); |
| _setPxeBootCommand.add("usrname="+_username); |
| _setPxeBootCommand.add("password="+_password, ParamType.PASSWORD); |
| _setPxeBootCommand.add("dev=pxe"); |
| |
| _setDiskBootCommand = new Script2(scriptPath, s_logger); |
| _setDiskBootCommand.add("boot_dev"); |
| _setDiskBootCommand.add("hostname="+_ip); |
| _setDiskBootCommand.add("usrname="+_username); |
| _setDiskBootCommand.add("password="+_password, ParamType.PASSWORD); |
| _setDiskBootCommand.add("dev=disk"); |
| |
| _rebootCommand = new Script2(scriptPath, s_logger); |
| _rebootCommand.add("reboot"); |
| _rebootCommand.add("hostname="+_ip); |
| _rebootCommand.add("usrname="+_username); |
| _rebootCommand.add("password="+_password, ParamType.PASSWORD); |
| |
| _getStatusCommand = new Script2(scriptPath, s_logger); |
| _getStatusCommand.add("ping"); |
| _getStatusCommand.add("hostname="+_ip); |
| _getStatusCommand.add("usrname="+_username); |
| _getStatusCommand.add("password="+_password, ParamType.PASSWORD); |
| |
| _powerOnCommand = new Script2(scriptPath, s_logger); |
| _powerOnCommand.add("power"); |
| _powerOnCommand.add("hostname="+_ip); |
| _powerOnCommand.add("usrname="+_username); |
| _powerOnCommand.add("password="+_password, ParamType.PASSWORD); |
| _powerOnCommand.add("action=on"); |
| |
| _powerOffCommand = new Script2(scriptPath, s_logger); |
| _powerOffCommand.add("power"); |
| _powerOffCommand.add("hostname="+_ip); |
| _powerOffCommand.add("usrname="+_username); |
| _powerOffCommand.add("password="+_password, ParamType.PASSWORD); |
| _powerOffCommand.add("action=soft"); |
| |
| _forcePowerOffCommand = new Script2(scriptPath, s_logger); |
| _forcePowerOffCommand.add("power"); |
| _forcePowerOffCommand.add("hostname=" + _ip); |
| _forcePowerOffCommand.add("usrname=" + _username); |
| _forcePowerOffCommand.add("password=" + _password, ParamType.PASSWORD); |
| _forcePowerOffCommand.add("action=off"); |
| |
| _bootOrRebootCommand = new Script2(scriptPath, s_logger); |
| _bootOrRebootCommand.add("boot_or_reboot"); |
| _bootOrRebootCommand.add("hostname="+_ip); |
| _bootOrRebootCommand.add("usrname="+_username); |
| _bootOrRebootCommand.add("password="+_password, ParamType.PASSWORD); |
| |
| return true; |
| } |
| |
| protected boolean doScript(Script cmd) { |
| return doScript(cmd, null); |
| } |
| |
| protected boolean doScript(Script cmd, OutputInterpreter interpreter) { |
| int retry = 5; |
| String res = null; |
| while (retry-- > 0) { |
| if (interpreter == null) { |
| res = cmd.execute(); |
| } else { |
| res = cmd.execute(interpreter); |
| } |
| if (res != null && res.startsWith("Error: Unable to establish LAN")) { |
| s_logger.warn("IPMI script timeout(" + cmd.toString() + "), will retry " + retry + " times"); |
| continue; |
| } else if (res == null) { |
| return true; |
| } else { |
| break; |
| } |
| } |
| |
| s_logger.warn("IPMI Scirpt failed due to " + res + "(" + cmd.toString() +")"); |
| return false; |
| } |
| |
| @Override |
| public boolean start() { |
| return true; |
| } |
| |
| @Override |
| public boolean stop() { |
| return true; |
| } |
| |
| @Override |
| public String getName() { |
| return _name; |
| } |
| |
| @Override |
| public Type getType() { |
| return com.cloud.host.Host.Type.Routing; |
| } |
| |
| protected State getVmState() { |
| OutputInterpreter.AllLinesParser interpreter = new OutputInterpreter.AllLinesParser(); |
| if (!doScript(_getStatusCommand, interpreter)) { |
| s_logger.warn("Cannot get power status of " + _name + ", assume VM state was not changed"); |
| return null; |
| } |
| if (isPowerOn(interpreter.getLines())) { |
| return State.Running; |
| } else { |
| return State.Stopped; |
| } |
| } |
| |
| protected Map<String, State> fullSync() { |
| Map<String, State> changes = new HashMap<String, State>(); |
| |
| if (_vmName != null) { |
| State state = getVmState(); |
| if (state != null) { |
| changes.put(_vmName, state); |
| } |
| } |
| |
| return changes; |
| } |
| |
| @Override |
| public StartupCommand[] initialize() { |
| StartupRoutingCommand cmd = new StartupRoutingCommand(0, 0, 0, 0, null, Hypervisor.HypervisorType.BareMetal, |
| new HashMap<String, String>(), null); |
| cmd.setDataCenter(_zone); |
| cmd.setPod(_pod); |
| cmd.setCluster(_cluster); |
| cmd.setGuid(_uuid); |
| cmd.setName(_ip); |
| cmd.setPrivateIpAddress(_ip); |
| cmd.setStorageIpAddress(_ip); |
| cmd.setVersion(BareMetalResourceBase.class.getPackage().getImplementationVersion()); |
| cmd.setCpus((int)_cpuNum); |
| cmd.setSpeed(_cpuCapacity); |
| cmd.setMemory(_memCapacity); |
| cmd.setPrivateMacAddress(_mac); |
| cmd.setPublicMacAddress(_mac); |
| cmd.setStateChanges(fullSync()); |
| return new StartupCommand[] {cmd}; |
| } |
| |
| private boolean ipmiPing() { |
| return doScript(_pingCommand); |
| } |
| |
| @Override |
| public PingCommand getCurrentStatus(long id) { |
| try { |
| if (!ipmiPing()) { |
| Thread.sleep(1000); |
| if (!ipmiPing()) { |
| s_logger.warn("Cannot ping ipmi nic " + _ip); |
| return null; |
| } |
| } |
| } catch (Exception e) { |
| s_logger.debug("Cannot ping ipmi nic " + _ip, e); |
| return null; |
| } |
| |
| return new PingRoutingCommand(getType(), id, deltaSync()); |
| } |
| |
| protected Answer execute(IpmISetBootDevCommand cmd) { |
| Script bootCmd = null; |
| if (cmd.getBootDev() == BootDev.disk) { |
| bootCmd = _setDiskBootCommand; |
| } else if (cmd.getBootDev() == BootDev.pxe) { |
| bootCmd = _setPxeBootCommand; |
| } else { |
| throw new CloudRuntimeException("Unkonwn boot dev " + cmd.getBootDev()); |
| } |
| |
| String bootDev = cmd.getBootDev().name(); |
| if (!doScript(bootCmd)) { |
| s_logger.warn("Set " + _ip + " boot dev to " + bootDev + "failed"); |
| return new Answer(cmd, false, "Set " + _ip + " boot dev to " + bootDev + "failed"); |
| } |
| |
| s_logger.warn("Set " + _ip + " boot dev to " + bootDev + "Success"); |
| return new Answer(cmd, true, "Set " + _ip + " boot dev to " + bootDev + "Success"); |
| } |
| |
| protected MaintainAnswer execute(MaintainCommand cmd) { |
| return new MaintainAnswer(cmd, false); |
| } |
| |
| protected PrepareForMigrationAnswer execute(PrepareForMigrationCommand cmd) { |
| return new PrepareForMigrationAnswer(cmd); |
| } |
| |
| protected MigrateAnswer execute(MigrateCommand cmd) { |
| if (!doScript(_powerOffCommand)) { |
| return new MigrateAnswer(cmd, false, "IPMI power off failed", null); |
| } |
| return new MigrateAnswer(cmd, true, "success", null); |
| } |
| |
| protected CheckVirtualMachineAnswer execute(final CheckVirtualMachineCommand cmd) { |
| return new CheckVirtualMachineAnswer(cmd, State.Stopped, null); |
| } |
| |
| protected Answer execute(IpmiBootorResetCommand cmd) { |
| if (!doScript(_bootOrRebootCommand)) { |
| return new Answer(cmd ,false, "IPMI boot or reboot failed"); |
| } |
| return new Answer(cmd, true, "Success"); |
| |
| } |
| |
| protected CheckNetworkAnswer execute(CheckNetworkCommand cmd) { |
| return new CheckNetworkAnswer(cmd, true, "Success"); |
| } |
| |
| @Override |
| public Answer executeRequest(Command cmd) { |
| if (cmd instanceof ReadyCommand) { |
| return execute((ReadyCommand)cmd); |
| } else if (cmd instanceof StartCommand) { |
| return execute((StartCommand)cmd); |
| } else if (cmd instanceof StopCommand) { |
| return execute((StopCommand)cmd); |
| } else if (cmd instanceof RebootCommand) { |
| return execute((RebootCommand)cmd); |
| } else if (cmd instanceof IpmISetBootDevCommand) { |
| return execute((IpmISetBootDevCommand)cmd); |
| } else if (cmd instanceof MaintainCommand) { |
| return execute((MaintainCommand)cmd); |
| } else if (cmd instanceof PrepareForMigrationCommand) { |
| return execute((PrepareForMigrationCommand)cmd); |
| } else if (cmd instanceof MigrateCommand) { |
| return execute((MigrateCommand)cmd); |
| } else if (cmd instanceof CheckVirtualMachineCommand) { |
| return execute((CheckVirtualMachineCommand)cmd); |
| } else if (cmd instanceof IpmiBootorResetCommand) { |
| return execute((IpmiBootorResetCommand)cmd); |
| } else if (cmd instanceof CheckNetworkCommand) { |
| return execute((CheckNetworkCommand)cmd); |
| } else { |
| return Answer.createUnsupportedCommandAnswer(cmd); |
| } |
| } |
| |
| protected boolean isPowerOn(String str) { |
| if (str.startsWith("Chassis Power is on")) { |
| return true; |
| } else if (str.startsWith("Chassis Power is off")) { |
| return false; |
| } else { |
| throw new CloudRuntimeException("Cannot parse IPMI power status " + str); |
| } |
| } |
| |
| protected RebootAnswer execute(final RebootCommand cmd) { |
| if (!doScript(_rebootCommand)) { |
| return new RebootAnswer(cmd, "IPMI reboot failed", false); |
| } |
| |
| return new RebootAnswer(cmd, "reboot succeeded", true); |
| } |
| |
| protected StopAnswer execute(final StopCommand cmd) { |
| boolean success = false; |
| int count = 0; |
| Script powerOff = _powerOffCommand; |
| |
| while (count < 10) { |
| if (!doScript(powerOff)) { |
| break; |
| } |
| |
| try { |
| Thread.sleep(1000); |
| } catch (InterruptedException e) { |
| break; |
| } |
| |
| OutputInterpreter.AllLinesParser interpreter = new OutputInterpreter.AllLinesParser(); |
| if (!doScript(_getStatusCommand, interpreter)) { |
| s_logger.warn("Cannot get power status of " + _name + ", assume VM state was not changed"); |
| break; |
| } |
| |
| if (!isPowerOn(interpreter.getLines())) { |
| success = true; |
| break; |
| } else { |
| powerOff = _forcePowerOffCommand; |
| } |
| |
| count++; |
| } |
| |
| return success ? new StopAnswer(cmd, "Success", null, true) : new StopAnswer(cmd, "IPMI power off failed", false); |
| } |
| |
| protected StartAnswer execute(StartCommand cmd) { |
| VirtualMachineTO vm = cmd.getVirtualMachine(); |
| State state = State.Stopped; |
| |
| try { |
| changeVmState(vm.getName(), State.Starting); |
| |
| boolean pxeBoot = false; |
| String[] bootArgs = vm.getBootArgs().split(" "); |
| for (int i = 0; i < bootArgs.length; i++) { |
| if (bootArgs[i].equalsIgnoreCase("PxeBoot")) { |
| pxeBoot = true; |
| break; |
| } |
| } |
| |
| if (pxeBoot) { |
| if (!doScript(_setPxeBootCommand)) { |
| return new StartAnswer(cmd, "Set boot device to PXE failed"); |
| } |
| s_logger.debug("Set " + vm.getHostName() + " to PXE boot successfully"); |
| } else { |
| execute(new IpmISetBootDevCommand(BootDev.disk)); |
| } |
| |
| OutputInterpreter.AllLinesParser interpreter = new OutputInterpreter.AllLinesParser(); |
| if (!doScript(_getStatusCommand, interpreter)) { |
| return new StartAnswer(cmd, "Cannot get current power status of " + _name); |
| } |
| |
| if (isPowerOn(interpreter.getLines())) { |
| if (pxeBoot) { |
| if (!doScript(_rebootCommand)) { |
| return new StartAnswer(cmd, "IPMI reboot failed"); |
| } |
| s_logger.debug("IPMI reboot " + vm.getHostName() + " successfully"); |
| } else { |
| s_logger.warn("Machine " + _name + " is alreay power on, why we still get a Start command? ignore it"); |
| |
| } |
| } else { |
| if (!doScript(_powerOnCommand)) { |
| return new StartAnswer(cmd, "IPMI power on failed"); |
| } |
| } |
| |
| s_logger.debug("Start bare metal vm " + vm.getName() + "successfully"); |
| state = State.Running; |
| _vmName = vm.getName(); |
| return new StartAnswer(cmd); |
| } finally { |
| if (state != State.Stopped) { |
| changeVmState(vm.getName(), state); |
| } else { |
| removeVmState(vm.getName()); |
| } |
| } |
| } |
| |
| protected HashMap<String, State> deltaSync() { |
| final HashMap<String, State> changes = new HashMap<String, State>(); |
| /* |
| * Disable sync until we find a way that only tracks status but not does action |
| * |
| * The scenario is: Baremetal will reboot host when creating template. Given most |
| * servers take a long time to boot up, there would be a period that mgmt server finds |
| * the host is stopped through fullsync. Then mgmt server updates database with marking the host as |
| * stopped, after that, the host comes up and full sync then indicates it's running. Because |
| * in database the host is already stopped, mgmt server sends out a stop command. |
| * As a result, creating image gets never happened. |
| * |
| if (_vmName == null) { |
| return null; |
| } |
| |
| State newState = getVmState(); |
| if (newState == null) { |
| s_logger.warn("Cannot get power state of VM " + _vmName); |
| return null; |
| } |
| |
| final State oldState = removeVmState(_vmName); |
| if (oldState == null) { |
| changeVmState(_vmName, newState); |
| changes.put(_vmName, newState); |
| } else if (oldState == State.Starting) { |
| if (newState == State.Running) { |
| changeVmState(_vmName, newState); |
| } else if (newState == State.Stopped) { |
| s_logger.debug("Ignoring vm " + _vmName + " because of a lag in starting the vm."); |
| } |
| } else if (oldState == State.Migrating) { |
| s_logger.warn("How can baremetal VM get into migrating state???"); |
| } else if (oldState == State.Stopping) { |
| if (newState == State.Stopped) { |
| changeVmState(_vmName, newState); |
| } else if (newState == State.Running) { |
| s_logger.debug("Ignoring vm " + _vmName + " because of a lag in stopping the vm. "); |
| } |
| } else if (oldState != newState) { |
| changeVmState(_vmName, newState); |
| changes.put(_vmName, newState); |
| } |
| */ |
| return changes; |
| |
| } |
| |
| protected ReadyAnswer execute(ReadyCommand cmd) { |
| // derived resource should check if the PXE server is ready |
| s_logger.debug("Bare metal resource " + _name + " is ready"); |
| return new ReadyAnswer(cmd); |
| } |
| |
| @Override |
| public void disconnected() { |
| |
| } |
| |
| @Override |
| public IAgentControl getAgentControl() { |
| return _agentControl; |
| } |
| |
| @Override |
| public void setAgentControl(IAgentControl agentControl) { |
| _agentControl = agentControl; |
| } |
| |
| } |
