/** * {@inheritDoc} */ @Override public void from(io.cattle.platform.core.model.IpAddress 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()); setAddress(from.getAddress()); setSubnetId(from.getSubnetId()); setNetworkId(from.getNetworkId()); setIsPublic(from.getIsPublic()); setRole(from.getRole()); setHostname(from.getHostname()); }
protected IpAddress getIpAddress(Host host) { IpAddress choice = null; for (IpAddress ip : objectManager.mappedChildren(host, IpAddress.class)) { if (ip.getAddress() == null || !CommonStatesConstants.ACTIVE.equals(ip.getState())) { continue; } if (IpAddressConstants.ROLE_PRIMARY.equals(ip.getRole())) { choice = ip; break; } else if (choice == null || choice.getCreated() == null) { choice = ip; } else if (ip.getCreated() != null && ip.getCreated().before(choice.getCreated())) { choice = ip; } } return choice; }
protected IpAddress processDockerIp(Instance instance, Nic nic, IpAddress primaryIp, String dockerIp) { if (primaryIp != null && !DockerIpAddressConstants.KIND_DOCKER.equals(primaryIp.getKind())) { return primaryIp; } if (nic == null || StringUtils.isBlank(dockerIp)) { return null; } if (primaryIp == null) { primaryIp = ipAddressDao.mapNewIpAddress(nic, IP_ADDRESS.KIND, DockerIpAddressConstants.KIND_DOCKER, IP_ADDRESS.ROLE, IpAddressConstants.ROLE_PRIMARY, IP_ADDRESS.ADDRESS, dockerIp); } else if (!dockerIp.equals(primaryIp.getAddress())) { getObjectManager().setFields(primaryIp, IP_ADDRESS.ADDRESS, dockerIp); } createThenActivate(primaryIp, null); return primaryIp; }
@Override protected HostMetaData map(List<Object> input) { Host host = (Host) input.get(0); IpAddress hostIp = (IpAddress) input.get(1); HostMetaData data = new HostMetaData(hostIp.getAddress(), host, account); return data; } };
@Override public HandlerResult handle(ProcessState state, ProcessInstance process) { IpAddress ipAddress = (IpAddress) state.getResource(); Network network = objectManager.loadResource(Network.class, ipAddress.getNetworkId()); if (!networkService.shouldAssignIpAddress(network)) { return null; } String assignedIp = ipAddress.getAddress(); Long subnetId = ipAddress.getSubnetId(); IPAssignment assignment = allocateIp(ipAddress, network); if (assignment != null) { assignedIp = assignment.getIpAddress(); if (assignment.getSubnet() != null) { subnetId = assignment.getSubnet().getId(); } } return new HandlerResult( IP_ADDRESS.ADDRESS, assignedIp, IP_ADDRESS.SUBNET_ID, subnetId, IP_ADDRESS.NAME, StringUtils.isBlank(ipAddress.getName()) ? assignedIp : ipAddress.getName()); }
boolean primaryIp = localIp == null ? firstNic : IpAddressConstants.ROLE_PRIMARY.equals(localIp.getRole()); String localIpAddress = localIp == null ? null : localIp.getAddress(); String addressKey = localIpAddress == null ? nic.getMacAddress() : localIpAddress; setIfTrueOrNull(primaryIp, instanceMetadata, "local-hostname", localHostname); setIfTrueOrNull(primaryIp, instanceMetadata, "local-ipv4", localIpAddress); if (localIp != null && localIp.getSubnetId() != null && subnet != null && StringUtils.isNotBlank(subnet.getGateway())) { setIfTrueOrNull(primaryIp, instanceMetadata, "local-ipv4-gateway", subnet.getGateway());
@Override public HandlerResult handle(ProcessState state, ProcessInstance process) { IpAddress ip = (IpAddress) state.getResource(); Host host = hostDao.getHostForIpAddress(ip.getId()); if (host == null) { return null; } sdService.reconcileHostEndpoints(host); return null; }
protected Instance getInstanceForPrimaryIp(IpAddress ipAddress) { if (IpAddressConstants.ROLE_PRIMARY.equals(ipAddress.getRole())) { for (Nic nic : getObjectManager().mappedChildren(ipAddress, Nic.class)) { if (nic.getDeviceNumber() != null && nic.getDeviceNumber() == 0) { Instance instance = getObjectManager().loadResource(Instance.class, nic.getInstanceId()); if (instance != null) { return instance; } } } } return null; }
@Override public HandlerResult handle(ProcessState state, ProcessInstance process) { IpAddress ipAddress = (IpAddress) state.getResource(); if (DockerIpAddressConstants.KIND_DOCKER.equals(ipAddress.getKind())) { return new HandlerResult(IP_ADDRESS.ADDRESS, (Object) null).withShouldContinue(true); } return null; }
@Override public IpAddress updateIpAddress(IpAddress ipAddress, String newIpAddress) { Map<String, Object> data = new HashMap<>(); if ( ipAddress.getAddress() != null ) { Map<String, Object> old = new HashMap<>(); old.put(IpAddressConstants.FIELD_ADDRESS, ipAddress.getAddress()); data.put("old", old); } objectManager.setFields(ipAddress, IP_ADDRESS.ADDRESS, newIpAddress); processManager.scheduleStandardProcess(StandardProcess.UPDATE, ipAddress, data); return ipAddress; }
@Override public IpAddress mapNewIpAddress(Nic nic, Object key, Object... values) { if ( nic.getNetworkId() == null ) { throw new IllegalStateException("Can not map new IP to nic with no network assigned to nic"); } Map<Object,Object> inputProperties = key == null ? Collections.emptyMap() : CollectionUtils.asMap(key, values); Map<Object,Object> properties = CollectionUtils.asMap((Object)IP_ADDRESS.ACCOUNT_ID, nic.getAccountId()); properties.putAll(inputProperties); IpAddress ipAddress = objectManager.create(IpAddress.class, objectManager.convertToPropertiesFor(IpAddress.class, properties)); objectManager.create(IpAddressNicMap.class, IP_ADDRESS_NIC_MAP.IP_ADDRESS_ID, ipAddress.getId(), IP_ADDRESS_NIC_MAP.NIC_ID, nic.getId()); return ipAddress; }
@Override public IpAddress getPrimaryIpAddress(Nic nic) { List<? extends IpAddress> ipAddresses = create() .select(IP_ADDRESS.fields()) .from(IP_ADDRESS) .join(IP_ADDRESS_NIC_MAP) .on(IP_ADDRESS_NIC_MAP.IP_ADDRESS_ID.eq(IP_ADDRESS.ID) .and(IP_ADDRESS_NIC_MAP.NIC_ID.eq(nic.getId()))) .where(IP_ADDRESS_NIC_MAP.REMOVED.isNull()) .fetchInto(IpAddressRecord.class); if (ipAddresses.size() == 1) { return ipAddresses.get(0); } for (IpAddress ipAddress : ipAddresses) { if (IpAddressConstants.ROLE_PRIMARY.equals(ipAddress.getRole())) { return ipAddress; } } return null; }
@Override public HandlerResult handle(ProcessState state, ProcessInstance process) { /* Release requested IPs on delete, not on purge */ Nic nic = (Nic) state.getResource(); for (IpAddressNicMap map : mapDao.findToRemove(IpAddressNicMap.class, Nic.class, nic.getId())) { IpAddress ipAddress = getObjectManager().loadResource(IpAddress.class, map.getIpAddressId()); if (DockerIpAddressConstants.KIND_DOCKER.equals(ipAddress.getKind())) { /* Deactivate Docker IPs on stop */ deactivate(ipAddress, state.getData()); } } return null; }
@Override protected HostMetaData map(List<Object> input) { Host host = (Host) input.get(0); IpAddress hostIp = (IpAddress) input.get(1); HostMetaData data = new HostMetaData(hostIp.getAddress(), host, accounts.get(host.getAccountId())); return data; } };
@Override public IpAddress assignAndActivateNewAddress(Host host, String ipAddress) { IpAddress ipAddressObj = objectManager.create(IpAddress.class, IP_ADDRESS.ADDRESS, ipAddress, IP_ADDRESS.ACCOUNT_ID, host.getAccountId()); HostIpAddressMap map = objectManager.create(HostIpAddressMap.class, HOST_IP_ADDRESS_MAP.IP_ADDRESS_ID, ipAddressObj.getId(), HOST_IP_ADDRESS_MAP.HOST_ID, host.getId()); processManager.scheduleStandardProcess(StandardProcess.CREATE, ipAddressObj, null); processManager.scheduleStandardProcess(StandardProcess.CREATE, map, null); return ipAddressObj; }
@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; } };
IpAddress ipAddress = ipAddressDao.getPrimaryIpAddress(nic); if (ipAddress != null) { privateIpAddress = ipAddress.getId(); outer: for (Host host : getObjectManager().mappedChildren(instance, Host.class)) { for (IpAddress ipAddress : getObjectManager().mappedChildren(host, IpAddress.class)) { publicIpAddress = ipAddress.getId(); break outer;
protected void assignPrimaryIpAddress(Instance instance, Map<String, Object> resultData) { int min = Integer.MAX_VALUE; IpAddress ip = null; IpAddress fallBackIp = null; for (Nic nic : getObjectManager().children(instance, Nic.class)) { if (nic.getDeviceNumber().intValue() < min) { min = nic.getDeviceNumber(); ip = ipAddressDao.getPrimaryIpAddress(nic); if (ip == null) { List<IpAddress> ips = getObjectManager().mappedChildren(nic, IpAddress.class); if (ips.size() > 0) { fallBackIp = ips.get(0); } } } } String address = null; if (ip == null) { address = fallBackIp == null ? null : fallBackIp.getAddress(); } else { address = ip.getAddress(); } if (address != null) { resultData.put(InstanceConstants.FIELD_PRIMARY_IP_ADDRESS, address); } }
boolean publish = false; IpAddress ip = ips.get(0); if (!address.equalsIgnoreCase(ip.getAddress())) { publish = true; ipAddressDao.updateIpAddress(ip, address); if (!ObjectUtils.equals(currentIp, ip.getAddress())) { try { objectManager.setFields(host, HostConstants.FIELD_IP_ADDRESS, ip.getAddress()); publish = true; } catch (DataChangedException e) {