/**
 * Defines the Infrastructure Management Service
 * @author Jerome Dochez
 */
@Contract
public interface IAAS extends Iterable<ServerPool> {

    /**
     * Returns the runtime information for the serverPool identified by its name.
     * @param groupName the serverPool name
     * @return the serverPool runtime information or null if not found.
     */
    ServerPool byName(String groupName);

    /**
     * Allocate a virtual machine based on the provided template.
     *
     * @param order the allocation constraints for the virtual machine allocation
     * @param listeners list of synchronous {@link Listener} to register before starting any allocation
     * work.
     * @return a {@link ListenableFuture} to get asynchronous phases completion notification and the
     * {@link VirtualMachine} instance upon allocation completion.
     * @throws VirtException when the virtual machine creation failed.
     */
    ListenableFuture<AllocationPhase, VirtualMachine> allocate(VMOrder order,
                                                               List<Listener<AllocationPhase>> listeners)
            throws VirtException;

    /**
     * Allocate a virtual machine based on the provided template.
     *
     * @param strategy strategy to allocate the virtual machines within the machine pools.
     * @param order the allocation constraints for the virtual machine allocation
     * @return a {@link ListenableFuture} to get asynchronous phases completion notification and the
     * {@link VirtualMachine} instance upon allocation completion.
     * @param listeners list of synchronous {@link Listener} to register before starting any allocation
     * work.
     * @throws VirtException when the virtual machine creation failed.
     */
    ListenableFuture<AllocationPhase, VirtualMachine> allocate(AllocationStrategy strategy,
                                                               VMOrder order,
                                                               List<Listener<AllocationPhase>> listeners)
            throws VirtException;
}

/**
 * An allocation strategy is responsible for allocating virtual machines given
 * a set of server pools and machines within these server pools.
 *
 * @author Jerome Dochez
 */
public interface AllocationStrategy {

    /**
     * allocate a virtual machine within the provided server pools, notifying of progress all listeners
     *
     * @param serverPools the server pools elligible to run the virtual machine
     * @param order the virtual machine requested characteristics
     * @param listeners listeners to register before any work is performed
     * @return a listenable future implementation that can be used to monitor progress and get the
     * result of the allocation as {@link VirtualMachine} instance.
     * @throws VirtException if the allocation failed.
     */
    ListenableFuture<AllocationPhase, VirtualMachine> allocate(Collection<ServerPool> serverPools,
                                                               VMOrder order,
                                                               List<Listener<AllocationPhase>> listeners)
        throws VirtException;

    /**
     * Returns the server pool allocation strategy for a particular server pool instance.
     * @param serverPool the server pool instance
     * @return the server pool allocation strategy
     */
    ServerPoolAllocationStrategy getServerPoolStrategy(ServerPool serverPool);
}

/**
 * Virtual machine procurement order.
 * @author Jerome Dochez
 */
public class VMOrder {

    final TemplateInstance template;
    final VirtualCluster targetCluster;
    final List<ServerPool> groups = new ArrayList<ServerPool>();
    final List<VirtualMachine> noColocationList = new ArrayList<VirtualMachine>();
    final Properties vmProps = new Properties();

    public VMOrder(TemplateInstance template, VirtualCluster targetCluster) {
        this.template = template;
        this.targetCluster = targetCluster;
    }

    /**
     * Returns the virtual cluster this allocation is targeted to
     * @return the target virtual cluster
     */
    public VirtualCluster getTargetCluster() {
        return targetCluster;
    }

    /**
     * Returns the requested characteristics for the virtual machines
     * @return a set of static virtual machine characteristics to use when
     * allocating the new virtual machines or null if the template characteristics
     * should apply.
     */
    public StaticVirtualMachineInfo getCharacteristics() {
        return null;
    }

    /**
     * Specifies the serverPool in which the number of virtual machines should be allocated.
     * If no serverPool is specified, it's left to the Infrastructure Management Service to
     * decide in which groups those Virtual Machines will be allocated.
     *
     * @param groups desired serverPool instance
     * @return itself
     */
    public VMOrder in(ServerPool... groups) {
        this.groups.addAll(Arrays.asList(groups));
        return this;
    }

    /**
     * Specifies the virtual machines that should not be co-located on the same hardware
     * with the new allocated virtual machines. This is particularly useful when willing
     * to allocate replication instances for existing virtual machines so they do not end
     * up being running on the same hardware resource.
     *
     * @param vms list of virtual machines to not co-locate with.
     * @return itself.
     */
    public VMOrder noColocationWith(VirtualMachine... vms) {
        this.noColocationList.addAll(Arrays.asList(vms));
        return this;
    }

    /**
     * Returns the properties for a specific virtual machine allocation. These properties
     * will be passed to the virtual machine through a provider specific mechanism. Such
     * properties can be used by the virtual machine to configure itself.
     *
     * @return the virtual machine properties
     */
    public Properties getVirtualMachineProperties() {
        return vmProps;
    }

    /**
     * Returns the groups this set of virtual machine allocations should be allocated into
     *
     * @return the groups we should use to allocate the virtual machines if possible.
     */
    public Collection<ServerPool> affinities() {
        return Collections.unmodifiableList(groups);
    }

    /**
     * Returns a list of virtual machine we would like the new virtual machines to not be
     * co-located with (meaning not running on the same hardware resource).
     *
     * @return a list of virtual machines to no co-locate new ones with.
     */
    public List<VirtualMachine> separateFrom() {
        return Collections.unmodifiableList(noColocationList);
    }

    /**
     * Returns the template associated with the virtual machine order.
     *
     * @return the template to use for the virtual machines allocation.
     */
    public TemplateInstance getTemplate() {
        return template;
    }
}

/**
 * Defines a Virtual machine
 * @author Jerome Dochez
 */
public interface VirtualMachine {

    /**
     * Returns the machine's name
     * @return machine's name as it is registered in the configuration
     */
    String getName();

    /**
     * Returns the IP address of the machine, which can be varying at runtime
     *
     * @return the machine's IP address
     */
    String getAddress();

    /**
     * Sets the IO address of the machine, usually performed by a back end
     * operation.
     * @param address the new IP address
     */
    void setAddress(String address);

    /**
     * Starts the virtual machine
     *
     * @throws VirtException if the request to start failed.
     */
    void start() throws VirtException;

    /**
     * Suspend the virtual machine
     * @throws VirtException if the request to suspend failed
     */
    void suspend() throws VirtException;

    /**
     * Resumes the virtual machine.
     *
     * @throws VirtException if the request to resume failed
     */
    void resume() throws VirtException;

    /**
     * Stops a virtual machine.
     *
     * @throws VirtException if the request to stop failed
     */
    void stop() throws VirtException;

    /**
     * Deletes the virtual machine and all associated storage
     *
     * @throws VirtException if the deletion failed
     */
    void delete() throws VirtException;

    /**
     * Returns the current machine information
     * @return the machine's current information
     */
    VirtualMachineInfo getInfo();
}

/**
 * Returns the virtual machine information
 * @author Jerome Dochez
 */
public interface VirtualMachineInfo extends StaticVirtualMachineInfo {

    /**
     * Returns the maximum memory allocated to this virtual machine.
     *
     * @return the virtual machine maximum memory.
     */
    long maxMemory() throws VirtException;

    /**
     * Returns the current memory used by this virtual machine
     * @return the virtual machine current memory usage
     */
    long memory() throws VirtException;

    /**
     * Returns the CPU used by this virtual machine
     * @return the CPU time used by this VM.
     * @throws VirtException
     */
    long cpuTime() throws VirtException;

    /**
     * Returns the machine's state
     * @return the machine's state
     *
     * @throws VirtException if the machine's state cannot be obtained
     */
    Machine.State getState() throws VirtException;

    /**
     * Registers a memory changes listener
     * @param ml the memory listener instance
     * @param delay notification interval for memory changes polling.
     * @param unit the time unit to express delay
     */
    void registerResourcesListener(VMResourcesListener ml, long delay, TimeUnit unit);

    /**
     * Un-registers a memory changes listener
     * @param ml, the listener to un-register.
     */
    void unregisterResourcesListener(VMResourcesListener ml);
}

public interface VMResourcesListener {

    public void notified(VirtualMachine vm, long memory, long cpuTime);
}

sudo apt-get -y -q install wget
sudo apt-get -y -q install sun-java6-jdk
sudo apt-get -y -q install unzip
sudo apt-get -y -q install openssh-server
sudo apt-get clean

/**
 * Abstract a set of servers than can be used to provide {@link VirtualMachine}
 *
 * @author Jerome Dochez
 */
public interface ServerPool {

    /**
     * Returns the configuration for this server pool.
     *
     * @return  the server pool's configuration.
     */
    ServerPoolConfig getConfig();
    void setConfig(ServerPoolConfig config);


    /**
     * Returns this pool's name.
     * @return  this pool's name
     */
    String getName();

    /**
     * Returns all allocated virtual machine in this server pool
     * @return the list of allocated virtual machines
     */
    Collection<VirtualMachine> getVMs() throws VirtException;

    /**
     * Returns an allocated virtual machine in this server pool using its name.
     * @param name virtual machine name
     * @return virtual machine instance if found or null otherwise.
     * @throws VirtException if the vm cannot be obtained
     */
    VirtualMachine vmByName(String name) throws VirtException;

    /**
     * Allocates number of virtual machines on any machine belonging to this server pool, each virtual machine
     * should be based on the provided template.
     * @param template  template for the virtual machines
     * @param cluster the virtual cluster instance to allocated virtual machines for
     * @return Listenable future for the VirtualMachine instance
     * @throws VirtException when the virtual machine creation failed.
     */
    ListenableFuture<AllocationPhase, VirtualMachine> allocate(TemplateInstance template, VirtualCluster cluster) throws VirtException;

    /**
     * Returns the list of templates installed.
     * @return list of installed templates or empty list if none
     */
    List<VMTemplate> getInstalledTemplates();

    /**
     * Install a template in this server pool
     * @param template to install
     */
    void install(VMTemplate template);
}

/**
 * Abstract a set of servers than can be used to provide {@link VirtualMachine}
 *
 * @author Jerome Dochez
 */
public interface ServerPool {

    /**
     * Returns the configuration for this server pool.
     *
     * @return  the server pool's configuration.
     */
    ServerPoolConfig getConfig();
    void setConfig(ServerPoolConfig config);


    /**
     * Returns this pool's name.
     * @return  this pool's name
     */
    String getName();

    /**
     * Returns all allocated virtual machine in this server pool
     * @return the list of allocated virtual machines
     */
    Collection<VirtualMachine> getVMs() throws VirtException;

    /**
     * Returns an allocated virtual machine in this server pool using its name.
     * @param name virtual machine name
     * @return virtual machine instance if found or null otherwise.
     * @throws VirtException if the vm cannot be obtained
     */
    VirtualMachine vmByName(String name) throws VirtException;

    /**
     * Allocates number of virtual machines on any machine belonging to this server pool, each virtual machine
     * should be based on the provided template.
     * @param template  template for the virtual machines
     * @param cluster the virtual cluster instance to allocated virtual machines for
     * @return Listenable future for the VirtualMachine instance
     * @throws VirtException when the virtual machine creation failed.
     */
    ListenableFuture<AllocationPhase, VirtualMachine> allocate(TemplateInstance template, VirtualCluster cluster) throws VirtException;

    /**
     * Returns the list of templates installed.
     * @return list of installed templates or empty list if none
     */
    List<VMTemplate> getInstalledTemplates();

    /**
     * Install a template in this server pool
     * @param template to install
     */
    void install(VMTemplate template);
}

/**
 * Represents a serverPool of machines. How machines are allocated to groups is defined
 * by the user.
 *
 * @author  Jerome Dochez
 */
@Contract
public interface PhysicalServerPool extends ServerPool {

    /**
     * Returns the currently attached machines to this serverPool
     *
     * @return iterable of machines attached to this serverPool
     */
    Iterable<? extends Machine> machines();

    /**
     * Returns a @see Machine instance which name is equal to the provided name
     * @param name  name of the machine looked up
     * @return  the @see Machine instance if found or null otherwise
     */
    Machine byName(String name);

    /**
     * Returns the size of this serverPool
     *
     * @return size of the serverPool.
     */
    int size();
}

create-server-pool --virtname=virtname --subnet=subnet --portname=portname name
    delete-server-pool name
    list-server-pools

create-server-pool-user --pool=poolid [--authmethod=authmethod] --userid=userid --groupid=groupid name

create-machine [--emulator=emulator] [--templateslocation=templateslocation] [--mac=mac] --serverPool=poolName [--networkname=networkname] [--diskslocation=diskslocation] [--maxcpu=maxcpu] [--maxmem=maxmemory] name
delete-machine --pool=group name
list-machines --pool=group

create-machine-user --groupid=groupid [--authmethod=authmethod] --userid=userid --machine=machine --pool=poolName name

create-group-manager --url=url name