Ticket #13647: OutOfMemory.java

import java.util.Arrays;
import java.util.List;

import org.virtualbox_4_3.CleanupMode;
import org.virtualbox_4_3.IEvent;
import org.virtualbox_4_3.IEventListener;
import org.virtualbox_4_3.IMachine;
import org.virtualbox_4_3.IMedium;
import org.virtualbox_4_3.IProgress;
import org.virtualbox_4_3.ISession;
import org.virtualbox_4_3.IVirtualBox;
import org.virtualbox_4_3.SessionState;
import org.virtualbox_4_3.VBoxEventType;
import org.virtualbox_4_3.VBoxException;
import org.virtualbox_4_3.VirtualBoxManager;

/*
 * Hyperbox - Enterprise Virtualization Manager
 * Copyright (C) 2014 Maxime Dor
 * 
 * http://hyperbox.altherian.org
 * 
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 * 
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 * 
 * You should have received a copy of the GNU General Public License
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 * 
 */

public class OutOfMemory {
   
   private final int waitingCoef = 500;
   private Thread worker;
   
   @SuppressWarnings("unused")
   public static void main(String[] args) {
      new OutOfMemory();
   }
   
   public OutOfMemory() {
      System.out.println("Starting");
      VirtualBoxManager vboxManager = VirtualBoxManager.createInstance(null);
      if (System.getProperty("vbox.ws") != null) {
         vboxManager.connect("http://" + System.getProperty("vbox.ws.host") + ":18083", "", "");
      }
      IVirtualBox vbox = vboxManager.getVBox();
      
      worker = new Thread(new EventWorker(vbox));
      worker.start();
      
      while (worker.isAlive()) {
         try {
            IMachine machine = vbox.createMachine(null, Long.toString(System.currentTimeMillis()), null, "Other", null);
            vbox.registerMachine(machine);
            System.out.println("Machine registered");
            
            ISession session = vboxManager.getSessionObject();
            IProgress pOn = machine.launchVMProcess(session, "headless", null);
            while (!pOn.getCompleted() || pOn.getCanceled()) {
               try {
                  Thread.sleep(Math.abs(pOn.getTimeRemaining()) * waitingCoef);
               } catch (InterruptedException e) {
                  e.printStackTrace();
               }
            }
            if (pOn.getResultCode() != 0) {
               System.out.println("Error when starting machine: " + pOn.getErrorInfo().getText());
            } else {
               System.out.println("Maching started");
            }
            
            IProgress pOff = session.getConsole().powerDown();
            while (!pOff.getCompleted() || pOff.getCanceled()) {
               try {
                  Thread.sleep(Math.abs(pOn.getTimeRemaining()) * waitingCoef);
               } catch (InterruptedException e) {
                  e.printStackTrace();
               }
            }
            if (pOff.getResultCode() != 0) {
               System.out.println("Error when stopping machine: " + pOff.getErrorInfo().getText());
            } else {
               System.out.println("Machine stopped");
            }
            
            if (session.getState().equals(SessionState.Locked)) {
               try {
                  session.unlockMachine();
               } catch (VBoxException e) {
                  if (!e.getMessage().toUpperCase().contains("8000FFFF")) {
                     e.printStackTrace();
                  }
                  
               }
            }
            
            machine = vbox.findMachine(machine.getId());
            while (!machine.getSessionState().equals(SessionState.Unlocked)) {
               Thread.sleep(10);
            }
            try {
               List<IMedium> hdds = machine.unregister(CleanupMode.DetachAllReturnHardDisksOnly);
               IProgress pDel = machine.deleteConfig(hdds);
               while (!pDel.getCompleted() || pDel.getCanceled()) {
                  try {
                     Thread.sleep(Math.abs(pDel.getTimeRemaining()) * waitingCoef);
                  } catch (InterruptedException e) {
                     e.printStackTrace();
                  }
               }
               if (pDel.getResultCode() != 0) {
                  System.out.println("Error when deleting machine: " + pDel.getErrorInfo().getText());
               } else {
                  System.out.println("Machine deleted");
               }
            } catch (Throwable t) {
               t.printStackTrace();
            }
            
            System.out.println("------------------------------");
         } catch (Throwable t) {
            t.printStackTrace();
            worker.interrupt();
            break;
         }
      }
      
      vboxManager.cleanup();
      
      System.out.println("Stopping");
   }
   
   private class EventWorker implements Runnable {
      
      private IVirtualBox vbox;
      
      public EventWorker(IVirtualBox vbox) {
         this.vbox = vbox;
      }
      
      @Override
      public void run() {
         System.out.println("Starting worker");
         IEventListener el = vbox.getEventSource().createListener();
         vbox.getEventSource().registerListener(el, Arrays.asList(VBoxEventType.Any), false);
         
         while (!Thread.currentThread().isInterrupted()) {
            try {
               IEvent rawEvent = vbox.getEventSource().getEvent(el, 1000);
               if (rawEvent != null) {
                  System.out.println("VBox Event: " + rawEvent.getClass().getName() + " - " + rawEvent.getType() + " - " + rawEvent);
                  vbox.getEventSource().eventProcessed(el, rawEvent);
               }
            } catch (Throwable t) {
               t.printStackTrace();
               break;
            }
         }
         
         vbox.getEventSource().unregisterListener(el);
         System.out.println("Stopping worker");
      }
      
   }
   
}