/** * {@inheritDoc} */ @Override public void from(io.cattle.platform.core.model.Port from) { setId(from.getId()); setName(from.getName()); setAccountId(from.getAccountId()); setKind(from.getKind()); setUuid(from.getUuid()); setDescription(from.getDescription()); setState(from.getState()); setCreated(from.getCreated()); setRemoved(from.getRemoved()); setRemoveTime(from.getRemoveTime()); setData(from.getData()); setPublicPort(from.getPublicPort()); setPrivatePort(from.getPrivatePort()); setInstanceId(from.getInstanceId()); setPublicIpAddressId(from.getPublicIpAddressId()); setProtocol(from.getProtocol()); setPrivateIpAddressId(from.getPrivateIpAddressId()); }
Integer privatePort = (Integer) allocatedIp.get(PRIVATE_PORT); for (Port port : objectManager.children(instance, Port.class)) { if (port.getPrivatePort().equals(privatePort) && StringUtils.equals(port.getProtocol(), protocol) && (port.getPublicPort() == null || port.getPublicPort().equals(publicPort))) { DataAccessor.setField(port, BIND_ADDRESS, ipAddress); port.setPublicPort(publicPort); objectManager.persist(port); break;
protected String toKey(Port port) { return String.format("%d:%d/%s", port.getPublicPort(), port.getPrivatePort(), port.getProtocol()); }
@Override public String toString() { StringBuilder sb = new StringBuilder(); for (Port port: ports) { if (sb.length() > 0) { sb.append(", "); } sb.append(port.getPublicPort()); sb.append("/"); sb.append(port.getProtocol()); } return String.format("host needs ports %s available", sb.toString()); } }
protected void activatePorts(Instance instance, ProcessState state) { for (Port port : getObjectManager().children(instance, Port.class)) { // ports can be removed while instance is still present (lb instance is an example) if (port.getRemoved() == null && !(port.getState().equalsIgnoreCase(CommonStatesConstants.REMOVED) || port.getState() .equalsIgnoreCase(CommonStatesConstants.REMOVING))) { createThenActivate(port, state.getData()); } } }
existing.put(port.getPrivatePort(), port); portObj.setAccountId(instance.getAccountId()); portObj.setKind(PortConstants.KIND_IMAGE); portObj.setInstanceId(instance.getId()); portObj.setPublicPort(spec.getPublicPort()); portObj.setPrivatePort(spec.getPrivatePort()); portObj.setProtocol(spec.getProtocol()); if (StringUtils.isNotEmpty(spec.getIpAddress()) && !"0.0.0.0".equals(spec.getIpAddress())) { DataAccessor.fields(portObj).withKey(PortConstants.FIELD_BIND_ADDR).set(spec.getIpAddress()); } else { portObj.setPublicIpAddressId(publicIpAddressId); portObj.setPrivateIpAddressId(privateIpAddressId); portObj = objectManager.create(portObj); } else { String bindAddress = DataAccessor.fields(port).withKey(PortConstants.FIELD_BIND_ADDR).as(String.class); boolean bindAddressNull = bindAddress == null; if (!ObjectUtils.equals(port.getPublicPort(), spec.getPublicPort()) || !ObjectUtils.equals(port.getPrivateIpAddressId(), privateIpAddressId) || (bindAddressNull && !ObjectUtils.equals(port.getPublicIpAddressId(), publicIpAddressId)) || (!bindAddressNull && !bindAddress.equals(spec.getIpAddress()))){ if (spec.getPublicPort() != null) { port.setPublicPort(spec.getPublicPort()); port.setPrivateIpAddressId(privateIpAddressId); if (StringUtils.isNotEmpty(spec.getIpAddress()) && !"0.0.0.0".equals(spec.getIpAddress())) { DataAccessor.fields(port).withKey(PortConstants.FIELD_BIND_ADDR).set(spec.getIpAddress()); } else {
if (port.getRemoved() != null || port.getState().equalsIgnoreCase(CommonStatesConstants.REMOVING)) { continue; portObj.setAccountId(instance.getAccountId()); portObj.setKind(PortConstants.KIND_USER); portObj.setInstanceId(instance.getId()); portObj.setPublicPort(newPortSpec.getPublicPort()); portObj.setPrivatePort(newPortSpec.getPrivatePort()); portObj.setProtocol(newPortSpec.getProtocol()); if (StringUtils.isNotEmpty(newPortSpec.getIpAddress())) { DataAccessor.fields(portObj).withKey(PortConstants.FIELD_BIND_ADDR).set(newPortSpec.getIpAddress());
@Override public HandlerResult handle(ProcessState state, ProcessInstance process) { Port port = (Port)state.getResource(); Instance instance = getObjectManager().loadResource(Instance.class, port.getInstanceId()); Long privateIpAddress = port.getPrivateIpAddressId(); Long publicIpAddress = port.getPublicIpAddressId();
@Override public HandlerResult handle(ProcessState state, ProcessInstance process) { Port port = (Port) state.getResource(); List<? extends Host> hosts = instanceDao.findHosts(port.getAccountId(), port.getInstanceId()); Instance instance = objectManager.loadResource(Instance.class, port.getInstanceId()); List<? extends Service> services = instanceDao.findServicesFor(instance); for (Host host : hosts) { sdService.reconcileHostEndpoints(host); } for (Service service : services) { sdService.reconcileServiceEndpoints(service); } return null; }
private boolean publicIpTheSame(Port requestedPort, Port portUsed) { if (requestedPort.getPublicIpAddressId() != null) { return requestedPort.getPublicIpAddressId().equals(portUsed.getPublicIpAddressId()); } else { String requestedIp = DataAccessor.fields(requestedPort).withKey(PortConstants.FIELD_BIND_ADDR).as(String.class); String usedIp = DataAccessor.fields(portUsed).withKey(PortConstants.FIELD_BIND_ADDR).as(String.class); return StringUtils.equals(requestedIp, usedIp); } }
@Override protected PublicEndpoint map(List<Object> input) { Instance instance = (Instance) input.get(0); Port port = (Port) input.get(1); Host host = (Host) input.get(2); String address = ""; address = DataAccessor.fieldString(port, PortConstants.FIELD_BIND_ADDR); if (StringUtils.isEmpty(address) || "0.0.0.0".equals(address)) { IpAddress ip = (IpAddress) input.get(3); if (ip != null) { address = ip.getAddress(); } else { IpAddress hostIp = (IpAddress) input.get(4); if (hostIp != null) { address = hostIp.getAddress(); } } } ServiceExposeMap exposeMap = (ServiceExposeMap) input.get(5); Long serviceId = exposeMap != null ? exposeMap.getServiceId() : null; PublicEndpoint data = new PublicEndpoint(address, port.getPublicPort(), host.getId(), instance.getId(), serviceId); return data; } };
protected void processPorts(Instance instance) { Set<String> portSpecs = new HashSet<>(); for (Port port : objectManager.children(instance, Port.class)) { if (port.getRemoved() != null) { continue; } portSpecs.add(new PortSpec(port).toSpec()); } objectManager.setFields(instance, InstanceConstants.FIELD_PORTS, new ArrayList<>(portSpecs)); Event event = EventVO.newEvent(IaasEvents.INVALIDATE_INSTANCE_DATA_CACHE) .withResourceType(instance.getKind()) .withResourceId(instance.getId().toString()); eventService.publish(event); }
@Override public HandlerResult handle(ProcessState state, ProcessInstance process) { Port port = (Port)state.getResource(); final Instance instance = getObjectManager().loadResource(Instance.class, port.getInstanceId()); if (instance == null) { return null; } lockManager.lock(new InstancePortsLock(instance), new LockCallbackNoReturn() { @Override public void doWithLockNoResult() { processPorts(instance); } }); return null; }
public PortSpec(Port port) { this.ipAddress = DataAccessor.fieldString(port, PortConstants.FIELD_BIND_ADDR); this.publicPort = port.getPublicPort(); this.privatePort = port.getPrivatePort(); this.protocol = port.getProtocol(); }
@Override public boolean matches(AllocationCandidate candidate) { if (candidate.getHost() == null) { return false; } // TODO: Performance improvement. Move more of the filtering into the DB query itself List<Port> portsUsedByHost = candidate.getUsedPorts(); for (Port portUsed : portsUsedByHost) { for (Port requestedPort : ports) { if (requestedPort.getPublicPort() != null && requestedPort.getPublicPort().equals(portUsed.getPublicPort()) && publicIpTheSame(requestedPort, portUsed) && requestedPort.getProtocol().equals(portUsed.getProtocol())) { return false; } } } return true; }
protected void network(Instance instance) { List<Nic> nics = getObjectManager().children(instance, Nic.class); for (Nic nic : nics) { if (nic.getRemoved() == null && !nic.getState().equals(CommonStatesConstants.REMOVED)) { deactivate(nic, null); } } for (Port port : getObjectManager().children(instance, Port.class)) { if (port.getRemoved() == null && !port.getState().equals(CommonStatesConstants.REMOVED)) { deactivate(port, null); } } for (InstanceLink link : getObjectManager().children(instance, InstanceLink.class, InstanceLinkConstants.FIELD_INSTANCE_ID)) { if (link.getRemoved() == null && !link.getState().equals(CommonStatesConstants.REMOVED)) { deactivate(link, null); } } }
private ResourceRequest populateResourceRequestFromInstanceForPort(Instance instance, String resourceType, String poolType, String schedulerVersion, List<Port> newPorts) { PortBindingResourceRequest request = new PortBindingResourceRequest(); if (useLegacyPortAllocation(schedulerVersion)) { return null; } request.setResource(resourceType); request.setInstanceId(instance.getId().toString()); request.setResourceUuid(instance.getUuid()); List<PortSpec> portReservation = new ArrayList<>(); for (Port port : newPorts) { PortSpec spec = new PortSpec(); String bindAddress = DataAccessor.fieldString(port, BIND_ADDRESS); if (bindAddress != null) { spec.setIpAddress(bindAddress); } spec.setPrivatePort(port.getPrivatePort()); spec.setPublicPort(port.getPublicPort()); String proto = StringUtils.isEmpty(port.getProtocol()) ? "tcp" : port.getProtocol(); spec.setProtocol(proto); portReservation.add(spec); } if (portReservation.isEmpty()) { return null; } request.setPortRequests(portReservation); request.setType(poolType); return request; }
@Override public void appendConstraints(AllocationAttempt attempt, AllocationLog log, List<Constraint> constraints) { Set<String> duplicatePorts = new HashSet<String>(); boolean checkForDupes = attempt.getInstances().size() > 1; for (Instance instance : attempt.getInstances()) { List<Port> ports = objectManager.find(Port.class, PORT.INSTANCE_ID, instance.getId(), PORT.REMOVED, null); if (checkForDupes) { for (Port port : ports) { String p = String.format("%s/%s", port.getPublicPort(), port.getProtocol()); if (!duplicatePorts.add(p)) { throw new FailedToAllocate(String.format("Port %s requested more than once.", p)); } } } if (ports.size() > 0) { constraints.add(new PortsConstraint(instance.getId(), ports)); } } }
spec.setIpAddress(bindAddress); spec.setPrivatePort(port.getPrivatePort()); spec.setPublicPort(port.getPublicPort()); String proto = StringUtils.isEmpty(port.getProtocol()) ? "tcp" : port.getProtocol(); spec.setProtocol(proto); portReservation.add(spec);
for (Port port : ports) { locks.add(new AllocateConstraintLock(AllocateConstraintLock.Type.PORT, String.format("%s.%s", port.getProtocol(), port.getPublicPort())));