/** * Concurrently stops a List of Vms, then restart them. Does not wait for the restart to complete * before returning. This allows the caller to carry out operations concurrent with the stop and * start activity, then wait for the restart to complete using {@link * #joinStopStartThreads(List,List)}. * * <p>Side effects: For any VM which is performing a NICE_KILL because of this call, it is marked * as such in the StopStartBB (blackboard). The blackboard will contain a key prefixed with * util.StopStartVMs.NiceKillInProgress and appended to with its VmId. The value of this key is * the true. * * <p>This blackboard entry is for the convenience of the caller, and it is up to the caller to * look for it or not. When a VM undergoes a NICE_KILL, the VM closes the cache and disconnects * from the distributed system. Any threads in that VM doing work can get exceptions during the * close and/or disconnect step. This blackboard entry is useful for those threads to allow * exceptions when they know an exception is possible. * * @param targetVmList A list of hydra.ClientVmInfos to stop then restart. * @param stopModeList A parallel list of stop modes (Strings). * @return threadList The threads created to stop the VMs. */ public static List stopStartAsync(List targetVmList, List stopModeList) { if (targetVmList.size() != stopModeList.size()) { throw new TestException( "Expected targetVmList " + targetVmList + " and stopModeList " + stopModeList + " to be parallel lists of the same size, but they have different sizes"); } Log.getLogWriter() .info( "In stopStartVMs, vms to stop: " + targetVmList + ", corresponding stop modes: " + stopModeList); // mark in the blackboard any vms that will undergo a NICE_KILL for (int i = 0; i < stopModeList.size(); i++) { String stopMode = (String) (stopModeList.get(i)); if (ClientVmMgr.toStopMode(stopMode) == ClientVmMgr.NICE_KILL) { // write nice kills to the blackboard so the killed vm may, if it chooses, handle any // exceptions that are underway. StopStartBB.getBB() .getSharedMap() .put( NiceKillInProgress + ((ClientVmInfo) targetVmList.get(i)).getVmid(), new Boolean(true)); } } // stop all vms in targetVms list List threadList = new ArrayList(); for (int i = 0; i < targetVmList.size(); i++) { ClientVmInfo targetVm = (ClientVmInfo) (targetVmList.get(i)); int stopMode = ClientVmMgr.toStopMode((String) (stopModeList.get(i))); Thread aThread = new StopStartVMs(targetVm, stopMode); aThread = new HydraSubthread(aThread); threadList.add(aThread); aThread.start(); } return threadList; }
/** * Concurrently stop and/or start a List of Vms. Wait for the operations to complete before * returning. * * <p>Side effects: For any VM which is performing a NICE_KILL because of this call, it is marked * as such in the StopStartBB (blackboard). The blackboard will contain a key prefixed with * util.StopStartVMs.NiceKillInProgress and appended to with its VmId. The value of this key is * the true. * * <p>This blackboard entry is for the convenience of the caller, and it is up to the caller to * look for it or not. When a VM undergoes a NICE_KILL, the VM closes the cache and disconnects * from the distributed system. Any threads in that VM doing work can get exceptions during the * close and/or disconnect step. This blackboard entry is useful for those threads to allow * exceptions when they know an exception is possible. * * @param targetVmList A list of hydra.ClientVmInfos to stop and/or start. * @param stopModeList A parallel list of stop modes (Strings), if doStop is true. * @param doStop True if we want to stop the targetVmList, false if not. * @param doStart True if we want to start the targetVmList, false if not. */ private static void stopStartVMs( List targetVmList, List stopModeList, boolean doStop, boolean doStart) { Log.getLogWriter() .info( "In stopStartVMs, vms to " + getAction(doStop, doStart) + ": " + targetVmList + ", corresponding stop modes: " + stopModeList); if (doStop) { // mark in the blackboard any vms that will undergo a NICE_KILL for (int i = 0; i < stopModeList.size(); i++) { String stopMode = (String) (stopModeList.get(i)); if (ClientVmMgr.toStopMode(stopMode) == ClientVmMgr.NICE_KILL) { // write nice kills to the blackboard so the killed vm may, if it chooses, handle any // exceptions that are underway. StopStartBB.getBB() .getSharedMap() .put( NiceKillInProgress + ((ClientVmInfo) targetVmList.get(i)).getVmid(), new Boolean(true)); } } } // process the vms in targetVms list List threadList = new ArrayList(); for (int i = 0; i < targetVmList.size(); i++) { ClientVmInfo targetVm = (ClientVmInfo) (targetVmList.get(i)); int stopMode = 0; if (doStop) { stopMode = ClientVmMgr.toStopMode((String) (stopModeList.get(i))); } StringBuffer aStr = new StringBuffer(); Thread aThread = new StopStartVMs(targetVm, stopMode, doStop, doStart); aThread = new HydraSubthread(aThread); threadList.add(aThread); aThread.start(); } // wait for all threads to complete their actions for (int i = 0; i < threadList.size(); i++) { Thread aThread = (Thread) (threadList.get(i)); try { aThread.join(); } catch (InterruptedException e) { throw new TestException(TestHelper.getStackTrace(e)); } } String err = (String) (StopStartBB.getBB().getSharedMap().get(StopStartBB.errKey)); if (err != null) { throw new TestException(err); } // reset the blackboard entries if (doStop) { for (int i = 0; i < targetVmList.size(); i++) { ClientVmInfo targetVm = (ClientVmInfo) (targetVmList.get(i)); StopStartBB.getBB() .getSharedMap() .put(StopStartVMs.NiceKillInProgress + targetVm.getVmid(), new Boolean(false)); } } Log.getLogWriter() .info("In stopStartVMs, done with " + getAction(doStop, doStart) + ": " + targetVmList); }