private boolean hasNoPorts() { return getRequiredPorts().isEmpty() && getProvidedPorts().isEmpty(); }
@Override protected void handleLackOfCandidate(Deployment deployment, List<Component> candidates) { final String message = String.format( "Unable to find a node type relevant to install artefacts of type '%s'", component.getRequiredExecutionPlatform().getName()); throw new IllegalStateException(message); } }
@Override public void dispatchTo(Visitor visitor, InternalComponent internalComponent) { dispatchTo(visitor, (Component) internalComponent); for (RequiredPort port : internalComponent.getRequiredPorts()) { visitor.visitRequiredPort(port); } visitor.visitRequiredExecutionPlatform(internalComponent.getRequiredExecutionPlatform()); }
/** * Upload resources associated to an internal component on a specified * external component * * @param x the internal component with upload commands * @param owner the external component on which the resources are about to * be uploaded * @param jc the connector used to upload */ private void executeUploadCommands(InternalComponentInstance x, VMInstance owner, Connector jc) { journal.log(Level.INFO, ">> Upload "+x.getType().getName()); unlessNotNull("Cannot upload with an argument at null", x, owner, jc); for (Resource r : x.getType().getResources()) { for (String path : r.getUploadCommand().keySet()) { jc.uploadFile(path, r.getUploadCommand().get(path), owner.getId(), "ubuntu", owner.getType().getPrivateKey()); } } }
public void internalComponentToKmf(InternalComponent internalComponent) { checkNull(internalComponent, "Cannot convert null!"); net.cloudml.core.InternalComponent kic = factory.createInternalComponent(); kic.setName(internalComponent.getName()); convertProperties(internalComponent, kic, factory); convertResources(internalComponent, kic, factory); this.internalComponents.put(kic.getName(), kic); initRequiredExecutionPlatform(internalComponent, kic); initProvidedExecutionPlatforms(internalComponent, kic); convertAndAddProvidedPorts(internalComponent.getProvidedPorts().toList(), kic); convertAndAddRequiredPorts(internalComponent.getRequiredPorts().toList(), kic); kDeploy.addInternalComponents(kic); //kDeploy.addComponents(kic); }
public void internalComponentToPOJO(net.cloudml.core.InternalComponent kInternalComponent) { checkForNull(kInternalComponent, "Cannot convert null!"); InternalComponent ic = new InternalComponent(kInternalComponent.getName(), new RequiredExecutionPlatform("to be replaced")); convertProperties(kInternalComponent, ic); convertResources(kInternalComponent, ic); convertPuppetResources(kInternalComponent,ic); internalComponents.put(ic.getName(), ic); initRequiredExecutionPlatform(kInternalComponent, ic); initProvidedExecutionPlatforms(kInternalComponent, ic); convertAndAddProvidedPortsToPOJO(kInternalComponent.getProvidedPorts(), ic); convertAndAddRequiredPortsToPOJO(kInternalComponent.getRequiredPorts(), ic); model.getComponents().add(ic); }
for(Property p : ic.getProperties()){ if(p.getName().contains("env:")){ for(InternalComponentInstance ici: d.getComponentInstances().ofType(ic.getName()).onlyInternals()){ prepareSetEnv(d,ici,p);
protected void restartHostedComponents(VMInstance ci){ journal.log(Level.INFO, ">> Restarting Hosted components of: "+ci.getName()); for(InternalComponentInstance ici: allHostedComponents(ci)){ Provider p=ci.getType().getProvider(); Connector c2=ConnectorFactory.createIaaSConnector(p); for(Resource r: ici.getType().getResources()){ dep.start(c2,ci.getType(),ci,r.getStartCommand()); } c2.closeConnection(); } }
private RequiredPort findClientPort(Deployment container) throws IllegalStateException { final RequiredPort clientPort = findClient(container).getRequiredPorts().firstNamed(clientPortName); if (clientPort == null) { final String error = String.format("required port '%s::%s' not found!", clientName, clientPortName); throw new IllegalStateException(formatError(error)); } return clientPort; }
@Override public InternalComponentInstance build() { final InternalComponent type = createStubType(); final InternalComponentInstance result = type.instantiate(getName()); setupProperties(result); setupResources(result); // We do not do anytgng with the host name, as without a deployment // owner, it is not possible for the component instance to retrieved // its host return result; }
public InternalComponent(String name, RequiredExecutionPlatform requiredExecutionPlatform) { super(name); this.requiredPorts = new LocalRequiredPortGroup(); setRequiredExecutionPlatform(requiredExecutionPlatform); }
private boolean isCandidate(InternalComponent component) { return component.getProvidedPorts().contains(relationshipType.getProvidedEnd()); }
@Override public InternalComponent build() { final RequiredExecutionPlatform platform = requiredExecutionPlatform.build(); final InternalComponent component = new InternalComponent(getName(), platform); super.prepare(component); for(RequiredPortBuilder port: requiredPorts) { port.integrateIn(component); } return component; }
/** * Stop a specific component instance * * @param a An InternalComponent Instance * @throws MalformedURLException */ private void stopInternalComponent(InternalComponentInstance a) { VMInstance ownerVM = (VMInstance) findDestinationWhenNoRequiredExecutionPlatformSpecified(a); //TODO: to be generalized if (ownerVM != null) { VM n = ownerVM.getType(); Connector jc = ConnectorFactory.createIaaSConnector(n.getProvider()); for (Resource r : a.getType().getResources()) { String stopCommand = r.getStopCommand(); //jc.execCommand(ownerVM.getId(), stopCommand, "ubuntu", n.getPrivateKey()); executeCommand(ownerVM, jc, stopCommand); } jc.closeConnection(); coordinator.updateStatusInternalComponent(a.getName(), State.UNINSTALLED.toString(), CloudAppDeployer.class.getName()); //a.setStatus(State.CONFIGURED); } }
private RequiredPortInstance findClientPort(Deployment container) { final InternalComponentInstance client = findClient(container); final RequiredPort portType = client.getType().getRequiredPorts().firstNamed(clientPort); if(portType == null){ final String error = String.format("Unable to find the required port type '%s'", clientPort); throw new IllegalStateException(error); } final RequiredPortInstance port = client.getRequiredPorts().ofType(portType); if (port == null) { final String error = String.format("Unable to find the required port instance '%s' in '%s'", clientPort, client); throw new IllegalStateException(error); } return port; }
@Override public void integrateIn(Deployment container) { final InternalComponentInstance result = findType(container).instantiate(getName()); setupProperties(result); setupResources(result); container.getComponentInstances().add(result); container.deploy(result, findHost(container)); }
@Override public void integrateIn(InternalComponent container) { final RequiredExecutionPlatform platform = new RequiredExecutionPlatform(getName()); prepare(platform); platform.getOwner().set(container); container.setRequiredExecutionPlatform(platform); }
private ComponentInstance<? extends Component> rejectIfInvalid(ComponentInstance<? extends Component> host) { if (host == null) { throw new IllegalArgumentException("'null' is not a valid destination for installation"); } if (!host.canHost(type)) { final String error = String.format("Illegal installation: '%s' cannot host component of type '%s'", host.getName(), type.getName()); throw new IllegalArgumentException(error); } return host; }
private void initRequiredExecutionPlatform(InternalComponent ic, net.cloudml.core.InternalComponent ka) { if (ic.getRequiredExecutionPlatform() != null) { net.cloudml.core.RequiredExecutionPlatform krep = factory.createRequiredExecutionPlatform(); krep.setName(ic.getRequiredExecutionPlatform().getName()); krep.setOwner(ka); convertDemands(ic, krep); convertProperties(ic.getRequiredExecutionPlatform(), krep, factory); convertResources(ic.getRequiredExecutionPlatform(), krep, factory); ka.setRequiredExecutionPlatform(krep); } }