net.java.dev.vcc.spi.AbstractDatacenter Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of vcc-api Show documentation
The API for control of virtual computers running on a virtual computer host
The newest version!
package net.java.dev.vcc.spi;

import net.java.dev.vcc.api.CapabilityProfile;
import net.java.dev.vcc.api.Command;
import net.java.dev.vcc.api.Computer;
import net.java.dev.vcc.api.ComputerTemplate;
import net.java.dev.vcc.api.Datacenter;
import net.java.dev.vcc.api.DatacenterResourceGroup;
import net.java.dev.vcc.api.Host;
import net.java.dev.vcc.api.HostResourceGroup;
import net.java.dev.vcc.api.ManagedObject;
import net.java.dev.vcc.api.ManagedObjectId;
import net.java.dev.vcc.api.Log;
import net.java.dev.vcc.api.LogFactory;

import java.util.AbstractMap;
import java.util.Arrays;
import java.util.Collections;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Map;
import java.util.Set;

/**
 * The base class from which all Service Provider Implementations map a connection from.
 */
public abstract class AbstractDatacenter
        extends AbstractManagedObject
        implements Datacenter {

    private final Log log;

    private final Map, Set>> capabilities;

    public AbstractDatacenter(LogFactory logFactory, ManagedObjectId id,
                              Map.Entry, Set>>... capabilities) {
        super(id);
        log = logFactory.getLog(getClass());
        Map, Set>> tmp =
                new HashMap, Set>>(capabilities.length);
        for (Map.Entry, Set>> capability : capabilities) {
            tmp.put(capability.getKey(), capability.getValue());
        }
        this.capabilities = Collections.unmodifiableMap(tmp);
    }

    public AbstractDatacenter(LogFactory logFactory, ManagedObjectId id, CapabilityProfile base,
                              Map.Entry, Set>>... capabilities) {
        super(id);
        log = logFactory.getLog(getClass());
        Map, Set>> tmp =
                new HashMap, Set>>(capabilities.length);
        for (Map.Entry, Set>> capability : capabilities) {
            tmp.put(capability.getKey(), capability.getValue());
        }
        for (Class moc : base.getObjectClasses()) {
            Set> foo = new HashSet>(base.getCommands(moc));
            if (tmp.containsKey(moc)) {
                foo.addAll(tmp.get(moc));
            }
            tmp.put(moc, Collections.unmodifiableSet(foo));
        }
        this.capabilities = Collections.unmodifiableMap(tmp);
    }

    public AbstractDatacenter(LogFactory logFactory, ManagedObjectId id, boolean ignore, CapabilityProfile... bases) {
        super(id);
        log = logFactory.getLog(getClass());
        Map, Set>> tmp =
                new HashMap, Set>>();
        for (CapabilityProfile base : bases) {
            for (Class moc : base.getObjectClasses()) {
                Set> foo = new HashSet>(base.getCommands(moc));
                if (tmp.containsKey(moc)) {
                    foo.addAll(tmp.get(moc));
                }
                tmp.put(moc, Collections.unmodifiableSet(foo));
            }
        }
        this.capabilities = Collections.unmodifiableMap(tmp);
    }

    public final Log getLog() {
        return log;
    }

    /**
     * Helper method.
     *
     * @param object   The type of {@link net.java.dev.vcc.api.ManagedObject}
     * @param commands The types of {@link net.java.dev.vcc.api.Command}s supported on the {@link
     *                 net.java.dev.vcc.api.ManagedObject}.
     *
     * @return An {@link java.util.Map.Entry} for use in the constructor.
     */
    protected static Map.Entry, Set>> with(
            Class object, Class... commands) {
        return new AbstractMap.SimpleImmutableEntry, Set>>(
                object, Collections.unmodifiableSet(new HashSet>(Arrays.asList(commands))));
    }

    /**
     * {@inheritDoc}
     */
    public Set getComputerTemplates() {
        return Collections.emptySet();
    }

    /**
     * {@inheritDoc}
     */
    public Set getHosts() {
        return Collections.emptySet();
    }

    /**
     * {@inheritDoc}
     */
    public Set getDatacenterResourceGroups() {
        return Collections.emptySet();
    }

    /**
     * {@inheritDoc}
     */
    public Set getAllHosts() {
        Set result = new HashSet(getHosts());
        for (DatacenterResourceGroup group : getDatacenterResourceGroups()) {
            result.addAll(group.getAllHosts());
        }
        return result;
    }

    /**
     * {@inheritDoc}
     */
    public Set getAllComputerTemplates() {
        Set result = new HashSet(getComputerTemplates());
        for (DatacenterResourceGroup group : getDatacenterResourceGroups()) {
            result.addAll(group.getAllComputerTemplates());
        }
        for (Host host : getHosts()) {
            result.addAll(host.getAllComputerTemplates());
        }
        return result;
    }

    /**
     * {@inheritDoc}
     */
    public Set getAllComputers() {
        Set result = new HashSet();
        for (DatacenterResourceGroup group : getDatacenterResourceGroups()) {
            result.addAll(group.getAllComputers());
        }
        for (Host host : getHosts()) {
            result.addAll(host.getAllComputers());
        }
        return result;
    }

    /**
     * {@inheritDoc}
     */
    public Set getAllDatacenterResourceGroups() {
        Set result = new HashSet(getDatacenterResourceGroups());
        for (DatacenterResourceGroup group : getDatacenterResourceGroups()) {
            result.addAll(group.getAllDatacenterResourceGroups());
        }
        return result;
    }

    /**
     * {@inheritDoc}
     */
    public Set getAllHostResourceGroups() {
        Set result = new HashSet();
        for (DatacenterResourceGroup group : getDatacenterResourceGroups()) {
            result.addAll(group.getAllHostResourceGroups());
        }
        for (Host host : getHosts()) {
            result.addAll(host.getAllHostResourceGroups());
        }
        return result;
    }

    /**
     * {@inheritDoc}
     */
    public final Set> getCommands(Class managedObjectClass) {
        Set> result = capabilities.get(managedObjectClass);
        return result == null ? Collections.>emptySet() : result;
    }

    /**
     * {@inheritDoc}
     */
    public final Set> getObjectClasses() {
        return capabilities.keySet();
    }

    /**
     * {@inheritDoc}
     */
    public final boolean supports(CapabilityProfile that) {
        if (this == that) {
            return true;
        }
        if (!that.getObjectClasses().containsAll(capabilities.keySet())) {
            return false;
        }
        for (Class b : that.getObjectClasses()) {
            if (!that.getCommands(b).containsAll(capabilities.get(b))) {
                return false;
            }
        }

        return true;
    }

}