private static Ip createIpModel(VmInitNetworkIpInfoFetcher ipInfoFetcher) { Ip ip = new Ip(); ip.setAddress(ipInfoFetcher.fetchIp()); ip.setNetmask(ipInfoFetcher.fetchNetmask()); ip.setGateway(ipInfoFetcher.fetchGateway()); return ip; }
private static void mapIpv4FromModel(HostNic model, VdsNetworkInterface entity) { if (model.isSetIp()) { if (model.getIp().isSetAddress()) { entity.setIpv4Address(model.getIp().getAddress()); } if (model.getIp().isSetGateway()) { entity.setIpv4Gateway(model.getIp().getGateway()); } if (model.getIp().isSetNetmask()) { entity.setIpv4Subnet(model.getIp().getNetmask()); } } if (model.isSetBootProtocol()) { Ipv4BootProtocol ipv4BootProtocol = Ipv4BootProtocolMapper.map(model.getBootProtocol()); if (ipv4BootProtocol != null) { entity.setIpv4BootProtocol(ipv4BootProtocol); } } }
@Override public V3IP adapt(Ip from) { V3IP to = new V3IP(); if (from.isSetAddress()) { to.setAddress(from.getAddress()); } if (from.isSetGateway()) { to.setGateway(from.getGateway()); } if (from.isSetNetmask()) { to.setNetmask(from.getNetmask()); } if (from.isSetVersion()) { to.setVersion(from.getVersion().value()); } return to; } }
private static void addIpsByVersion(Ips ips, List<String> entityIps, IpVersion ipVersion) { if (entityIps != null) { for (String entityIp : entityIps) { Ip ip = new Ip(); ip.setAddress(entityIp); ip.setVersion(ipVersion); ips.getIps().add(ip); } } }
if (ip.isSetVersion()) { return ip.getVersion(); String address = ip.getAddress(); if (address == null) { return null;
@Test public void testMapFromEntityIpv6Assignment() { final IpV6Address entity = new IpV6Address(); entity.setBootProtocol(Ipv6BootProtocol.AUTOCONF); entity.setAddress(ADDRESS); entity.setGateway(GATEWAY); entity.setPrefix(PREFIX); final IpAddressAssignment actual = NetworkAttachmentMapper.mapIpv6AddressAssignment(entity); assertEquals(BootProtocol.AUTOCONF, actual.getAssignmentMethod()); assertEquals(ADDRESS, actual.getIp().getAddress()); assertEquals(GATEWAY, actual.getIp().getGateway()); assertEquals(PREFIX_STR, actual.getIp().getNetmask()); }
/** * Checks that when the version isn't given explicitly, and the address is a valid IPv4 address, the returned * version is IPv4. */ @Test public void testReturnsV4WhenGivenValidV4Address() { Ip ip = new Ip(); ip.setAddress("127.0.0.1"); IpVersion version = IpHelper.getVersion(ip); assertEquals(IpVersion.V4, version); }
@Override protected ReportedDevice postPopulate(ReportedDevice model) { model.setType(ReportedDeviceType.NETWORK); for (Ip ip : model.getIps().getIps()) { ip.setVersion(IpVersion.V4); ip.setGateway(null); ip.setNetmask(null); } return model; }
@Override protected void verify(ReportedDevice model, ReportedDevice transform) { assertNotNull(transform); assertEquals(model.getName(), transform.getName()); assertNotNull(transform.getVm()); assertEquals(model.getVm().getId(), transform.getVm().getId()); assertNotNull(transform.getMac()); assertEquals(model.getMac().getAddress(), transform.getMac().getAddress()); assertNotNull(transform.getType()); assertEquals(model.getType(), transform.getType()); assertNotNull(transform.getIps()); assertTrue(transform.getIps().isSetIps()); assertEquals(transform.getIps().getIps().size(), model.getIps().getIps().size()); for (int i = 0; i < transform.getIps().getIps().size(); i++) { assertEquals(transform.getIps().getIps().get(i).getAddress(), model.getIps().getIps().get(i).getAddress()); assertEquals(transform.getIps().getIps().get(i).getVersion(), model.getIps().getIps().get(i).getVersion()); } } }
private void verifyIps(ReportedDevice device) { List<Ip> ips = device.getIps().getIps(); assertEquals(ADDRESSES.length, ips.size()); for (int i = 0; i < ADDRESSES.length; i++) { assertEquals(ADDRESSES[i], ips.get(i).getAddress()); } }
/** * A session is not a business-entity in the engine and does not have an ID. This method generates an ID for the * session object, based on its attributes. */ private void setSessionId(Session session) { String idString = session.getUser().getName(); if (session.isSetIp() && session.getIp().isSetAddress()) { idString += session.getIp().getAddress(); } if (session.isSetProtocol()) { idString += session.getProtocol(); } session.setId(GuidUtils.generateGuidUsingMd5(idString).toString()); }
@Override protected org.ovirt.engine.api.model.NetworkAttachment postPopulate(org.ovirt.engine.api.model.NetworkAttachment model) { model.getIpAddressAssignments().getIpAddressAssignments().get(0).setAssignmentMethod(BootProtocol.DHCP); model.getQos().setType(QosType.HOSTNETWORK); for (IpAddressAssignment ipAddressAssignment : model.getIpAddressAssignments().getIpAddressAssignments()) { if (IpVersion.V6 == ipAddressAssignment.getIp().getVersion()) { ipAddressAssignment.getIp().setNetmask(String.valueOf(new Random().nextInt(128))); } } return super.postPopulate(model); } }
/** * Create an instance of {@link Ip } * */ public Ip createIp() { return new Ip(); }
@Override protected void verify(org.ovirt.engine.api.model.NetworkAttachment model, org.ovirt.engine.api.model.NetworkAttachment transform) { assertNotNull(transform); assertEquals(model.getId(), transform.getId()); assertNotNull(transform.getNetwork()); assertEquals(model.getNetwork().getId(), transform.getNetwork().getId()); assertNotNull(transform.getHostNic()); assertEquals(model.getHostNic().getId(), transform.getHostNic().getId()); assertNotNull(transform.getProperties()); assertEquals(CustomPropertiesParser.toMap(model.getProperties()), CustomPropertiesParser.toMap(transform.getProperties())); assertNotNull(transform.getIpAddressAssignments()); List<IpAddressAssignment> transformAddresses = transform.getIpAddressAssignments().getIpAddressAssignments(); assertNotNull(transformAddresses); List<IpAddressAssignment> modelAddresses = model.getIpAddressAssignments().getIpAddressAssignments(); assertEquals(modelAddresses.size(), transformAddresses.size()); for (int i = 0; i < modelAddresses.size(); i++) { assertEquals(modelAddresses.get(i).getAssignmentMethod(), transformAddresses.get(i).getAssignmentMethod()); Ip modelAddress = modelAddresses.get(i).getIp(); Ip transformAddress = transformAddresses.get(i).getIp(); assertEquals(modelAddress.getAddress(), transformAddress.getAddress()); assertEquals(modelAddress.getNetmask(), transformAddress.getNetmask()); assertEquals(modelAddress.getGateway(), transformAddress.getGateway()); } }
/** * Checks that when explicitly given IPv4 it ignores the address. */ @Test public void testIgnoreAddressWhenV4ExplicitlyGiven() { Ip ip = new Ip(); ip.setAddress("::1"); ip.setVersion(IpVersion.V4); IpVersion version = IpHelper.getVersion(ip); assertEquals(IpVersion.V4, version); }
/** * Checks that when the version isn't given explicitly, and the address is a valid IPv6 address, the returned * version is IPv6. */ @Test public void testReturnsV6WhenGivenValidV6Address() { Ip ip = new Ip(); ip.setAddress("::1"); IpVersion version = IpHelper.getVersion(ip); assertEquals(IpVersion.V6, version); } }
switch (version) { case V4: ipv4.add(ip.getAddress()); break; case V6: ipv6.add(ip.getAddress()); break;
@Override public Ip adapt(V3IP from) { Ip to = new Ip(); if (from.isSetAddress()) { to.setAddress(from.getAddress()); } if (from.isSetGateway()) { to.setGateway(from.getGateway()); } if (from.isSetNetmask()) { to.setNetmask(from.getNetmask()); } if (from.isSetVersion()) { to.setVersion(IpVersion.fromValue(from.getVersion())); } return to; } }
private static IPv4Address mapIpv4AddressAssignment(IpAddressAssignment ipAddressAssignment) { IPv4Address iPv4Address = new IPv4Address(); if (ipAddressAssignment.isSetAssignmentMethod()) { Ipv4BootProtocol assignmentMethod = Ipv4BootProtocolMapper.map(ipAddressAssignment.getAssignmentMethod()); iPv4Address.setBootProtocol(assignmentMethod); } if (ipAddressAssignment.isSetIp()) { if (ipAddressAssignment.getIp().isSetAddress()) { iPv4Address.setAddress(ipAddressAssignment.getIp().getAddress()); } if (ipAddressAssignment.getIp().isSetGateway()) { iPv4Address.setGateway(ipAddressAssignment.getIp().getGateway()); } if (ipAddressAssignment.getIp().isSetNetmask()) { iPv4Address.setNetmask(ipAddressAssignment.getIp().getNetmask()); } } return iPv4Address; }
@Override protected void verify(Network model, Network transform) { assertNotNull(transform); assertEquals(model.getName(), transform.getName()); assertEquals(model.getId(), transform.getId()); assertEquals(model.getDescription(), transform.getDescription()); assertEquals(model.getComment(), transform.getComment()); assertNotNull(transform.getDataCenter()); assertEquals(model.getDataCenter().getId(), transform.getDataCenter().getId()); assertNotNull(transform.getIp()); assertEquals(model.getIp().getAddress(), transform.getIp().getAddress()); assertEquals(model.getIp().getNetmask(), transform.getIp().getNetmask()); assertEquals(model.getIp().getGateway(), transform.getIp().getGateway()); assertNotNull(transform.getVlan()); assertEquals(model.getVlan().getId(), transform.getVlan().getId()); assertEquals(model.isStp(), transform.isStp()); final Set<NetworkUsage> usagesSet = new HashSet<>(model.getUsages().getUsages()); assertTrue(usagesSet.contains(NetworkUsage.DISPLAY)); assertTrue(usagesSet.contains(NetworkUsage.MIGRATION)); assertTrue(usagesSet.contains(NetworkUsage.MANAGEMENT)); assertTrue(usagesSet.contains(NetworkUsage.VM)); assertTrue(usagesSet.contains(NetworkUsage.DEFAULT_ROUTE)); }