private ProvidedPortInstance createServerPort() { return new ProvidedPortInstance(serverPort, new ProvidedPort("provided port type")); }
private void validateProvidedEnd(Report report) { if (!providedEnd.getType().equals(type.getProvidedEnd())) { final String message = String.format( "illegal relationship instance '%s' that does not match its type (provided port found '%s' but expected '%s')", getName(), providedEnd.getType().getQualifiedName(), type.getProvidedEnd().getQualifiedName()); report.addError(message); } }
public ProvidedPortInstance withTypeNamed(String name){ for (ProvidedPortInstance port: this) { if (port.getType().getName().equals(name)) { return port; } } return null; }
public void convertAndAddProvidedPorts(List<ProvidedPort> ports, net.cloudml.core.Component kc) { checkNull(ports, "cannot iterate on null!"); for (ProvidedPort pp: ports) { checkNull(pp, "cannot convert null!"); net.cloudml.core.ProvidedPort kpp = factory.createProvidedPort(); kpp.setName(pp.getName()); convertProperties(pp, kpp, factory); kpp.setPortNumber(pp.getPortNumber()); kpp.setIsLocal(pp.isLocal()); kc.addProvidedPorts(kpp); kpp.setComponent(kc); providedPorts.put(calculatePortIdentifier(pp), kpp); } assert providedPorts.size() >= ports.size(); assert kc.getProvidedPorts().size() == ports.size(); }
public void convertAndAddProvidedPortsToPOJO(List<net.cloudml.core.ProvidedPort> pps, Component ic) { for (net.cloudml.core.ProvidedPort kpp: pps) { ProvidedPort pp = new ProvidedPort(kpp.getName(), kpp.getIsLocal()); pp.getOwner().set(ic); convertProperties(kpp, pp); pp.setPortNumber(kpp.getPortNumber()); ic.getProvidedPorts().add(pp); providedPorts.put(calculatePortIdentifier(kpp), pp); } assert providedPorts.size() >= pps.size(); assert ic.getProvidedPorts().size() == pps.size(); }
@Override public void validate(Report report) { if (requiredEnd != null && providedEnd != null) { if (requiredEnd.isLocal() && providedEnd.isRemote()) { final String message = String.format( "Illegal relationship (%s) between a local client (%s) and a remote server (%s)", getName(), requiredEnd.getQualifiedName(), providedEnd.getQualifiedName() ); report.addError(message); } if (requiredEnd.isRemote() && providedEnd.isLocal()) { final String message = String.format( "Illegal relationship (%s) between a remote client (%s) and a local server (%s)", getName(), requiredEnd.getQualifiedName(), providedEnd.getQualifiedName()); report.addError(message); } } }
public void integrateIn(Component container) { final ProvidedPort port = new ProvidedPort(getName(), isLocal()); prepare(port); port.getOwner().set(container); container.getProvidedPorts().add(port); }
public Component getServerComponent() { return this.providedEnd.getOwner().get(); }
/** * @return true if this component type has the given provided port, false otherwise * @param port the port whose existence is to be asserted */ public boolean canProvide(ProvidedPort port) { for (ProvidedPort eachPort: providedPorts) { if (eachPort.equals(port)) { return true; } } return false; }
/** * Find the destination of an ComponentInstance * * @param a an instance of component * @return a VMInstance */ private ExternalComponentInstance findDestinationWhenNoRequiredExecutionPlatformSpecified(InternalComponentInstance a) { if (getDestination(a) != null) { return getDestination(a); } else { for (RelationshipInstance b : currentModel.getRelationshipInstances()) { if (a.getRequiredPorts().contains(b.getRequiredEnd()) && b.getRequiredEnd().getType().isLocal()) { return getDestination(b.getProvidedEnd().getOwner().get()); } if (a.getProvidedPorts().contains(b.getProvidedEnd()) && b.getProvidedEnd().getType().isLocal()) { return getDestination(b.getRequiredEnd().getOwner().get()); } } return null; } }
int destinationPortNumber = server.getType().getPortNumber(); String ipAddress = getDestination(clientInternal.getOwner().get()).getPublicAddress(); if(clientResource == null)
@Override public String toString() { return "ProvidedPort " + getQualifiedName(); }
private ProvidedPortInstanceGroup instantiateAllProvidedPorts(T type) { final ProvidedPortInstanceGroup instances = new ProvidedPortInstanceGroup(); for (ProvidedPort port: type.getProvidedPorts()) { instances.add(port.instantiate()); } return new LocalProvidedPortInstanceGroup(instances); }
@Override public boolean add(ProvidedPort e) { e.getOwner().set(Component.this); return super.add(e); }
public ProvidedPortInstance ofType(ProvidedPort type) { for (ProvidedPortInstance port: this) { if (port.getType().equals(type)) { return port; } } return null; }
@Override protected void handleLackOfCandidate(Deployment deployment, List<InternalComponent> candidates) { final String string = String.format( "Unable to find a component type matching the provided end of relationship type '%s' (port '%s')", relationshipType.getName(), relationshipType.getProvidedEnd().getQualifiedName()); throw new IllegalStateException(string); }
@Override public boolean equals(Object other) { if (other == null) { return false; } if (other instanceof Relationship) { Relationship relationship = (Relationship) other; return (requiredEnd.getName().equals(relationship.getRequiredEnd().getName()) && providedEnd.getName().equals(relationship.getProvidedEnd().getName())); } return false; } }
@Override public boolean remove(Object o) { if (o instanceof ProvidedPort) { ProvidedPort port = (ProvidedPort) o; port.getOwner().discard(); } return super.remove(o); }
private boolean isCandidate(Relationship bindingType, ProvidedPortInstance serverPort) { return bindingType.getProvidedEnd().equals(serverPort.getType()); }
private Relationship createType() { return new Relationship(typeName, new RequiredPort("required port type"), new ProvidedPort("provided port type")); }