Java MacAddress类代码示例

import org.projectfloodlight.openflow.types.MacAddress; //导入依赖的package包/类
/**
 * Checks whether the frame is destined to or from a gateway.
 * @param frame The ethernet frame to check.
 * @return True if it is to/from a gateway, false otherwise.
 */
protected boolean isDefaultGateway(Ethernet frame) {
	if (macToGateway.containsKey(frame.getSourceMACAddress()))
		return true;

	IPv4Address gwIp = macToGateway.get(frame.getDestinationMACAddress());
	if (gwIp != null) {
		MacAddress host = frame.getSourceMACAddress();
		String srcNet = macToGuid.get(host);
		if (srcNet != null) {
			IPv4Address gwIpSrcNet = guidToGateway.get(srcNet);
			if ((gwIpSrcNet != null) && (gwIp.equals(gwIpSrcNet)))
				return true;
		}
	}

	return false;
}
 

import org.projectfloodlight.openflow.types.MacAddress; //导入依赖的package包/类
@Test
public void testUncastPacket() {
    // Generate the VerificationPacket
    OFPacketOut packet = pvs.generateVerificationPacket(sw1, OFPort.of(1), sw2);

    // Source MAC will always be that of sw1 for both Unicast and Broadcast
    byte[] srcMacActual = Arrays.copyOfRange(packet.getData(), 6, 12);
    assertArrayEquals(MacAddress.of(sw1HwAddrTarget).getBytes(), srcMacActual);

    // Destination MAC should be that of sw2 for Unicast Packet
    byte[] dstMacActual = Arrays.copyOfRange(packet.getData(), 0, 6);
    assertArrayEquals(MacAddress.of(sw2HwAddrTarget).getBytes(), dstMacActual);

    // Source and Destination IP's are the respective switch IP's
    byte[] srcIpActual = Arrays.copyOfRange(packet.getData(), 26, 30);
    assertArrayEquals(srcIpTarget.getAddress().getAddress(), srcIpActual);
    byte[] dstIpActual = Arrays.copyOfRange(packet.getData(), 30, 34);
    assertArrayEquals(dstIpTarget.getAddress().getAddress(), dstIpActual);
}
 

import org.projectfloodlight.openflow.types.MacAddress; //导入依赖的package包/类
/**
 * Verify that the given device exactly matches the given fields. E.g.,
 * if ip is not null we expect the device to have exactly one IP address.
 * swId and port are the attachment point port.
 * Vlan and ip are optional all other fields must be specified.
 * @return
 */
private static void verifyDevice(IDevice d, MacAddress mac, VlanVid vlan, IPv4Address ipv4,
		IPv6Address ipv6, DatapathId swId, OFPort port) {
	assertNotNull(d);
	if (!mac.equals(MacAddress.NONE)) {
		assertEquals(mac, d.getMACAddress());
	}
	if (vlan != null) {
		assertArrayEquals(new VlanVid[] { vlan }, d.getVlanId());
	}
	if (!ipv4.equals(IPv4Address.NONE)) {
		assertArrayEquals(new IPv4Address[] { ipv4 }, d.getIPv4Addresses());
	}
	if (!ipv6.equals(IPv6Address.NONE)) {
		assertArrayEquals(new IPv6Address[] { ipv6 }, d.getIPv6Addresses());
	}
	if (!swId.equals(DatapathId.NONE) && !port.equals(OFPort.ZERO)) {
		SwitchPort expectedAp = new SwitchPort(swId, port);
		assertArrayEquals(new SwitchPort[] { expectedAp }, d.getAttachmentPoints());
	}
}
 

import org.projectfloodlight.openflow.types.MacAddress; //导入依赖的package包/类
@Test
public void testGetSwitchPortVlanId() {
	Entity entity1 = new Entity(MacAddress.of(1L), VlanVid.ofVlan(1), IPv4Address.NONE, IPv6Address.NONE, DatapathId.of(10L), OFPort.of(1), new Date());
	Entity entity2 = new Entity(MacAddress.of(1L), VlanVid.ZERO, IPv4Address.NONE, IPv6Address.NONE, DatapathId.of(10L), OFPort.of(1), new Date());
	Entity entity3 = new Entity(MacAddress.of(1L), VlanVid.ofVlan(3), IPv4Address.NONE, IPv6Address.NONE,  DatapathId.of(1L), OFPort.of(1), new Date());
	Entity entity4 = new Entity(MacAddress.of(1L), VlanVid.ofVlan(42), IPv4Address.NONE, IPv6Address.NONE,  DatapathId.of(1L), OFPort.of(1), new Date());
	Entity[] entities = new Entity[] { entity1, entity2,
			entity3, entity4
	};
	Device d = new Device(null,1L, null, null, null,
			Arrays.asList(entities), null);
	SwitchPort swp1x1 = new SwitchPort(DatapathId.of(1L), OFPort.of(1));
	SwitchPort swp1x2 = new SwitchPort(DatapathId.of(1L), OFPort.of(2));
	SwitchPort swp2x1 = new SwitchPort(DatapathId.of(2L), OFPort.of(1));
	SwitchPort swp10x1 = new SwitchPort(DatapathId.of(10L), OFPort.of(1));
	assertArrayEquals(new VlanVid[] { VlanVid.ZERO, VlanVid.ofVlan(1)},
			d.getSwitchPortVlanIds(swp10x1));
	assertArrayEquals(new VlanVid[] { VlanVid.ofVlan(3), VlanVid.ofVlan(42)},
			d.getSwitchPortVlanIds(swp1x1));
	assertArrayEquals(new VlanVid[0],
			d.getSwitchPortVlanIds(swp1x2));
	assertArrayEquals(new VlanVid[0],
			d.getSwitchPortVlanIds(swp2x1));
}
 

import org.projectfloodlight.openflow.types.MacAddress; //导入依赖的package包/类
/**
 * Construct a new device iterator over the key fields
 * @param subIterator an iterator over the full data structure to scan
 * @param entityClasses the entity classes to search for
 * @param macAddress The MAC address
 * @param vlan the VLAN
 * @param ipv4Address the ipv4 address
 * @param ipv6Address the ipv6 address
 * @param switchDPID the switch DPID
 * @param switchPort the switch port
 */
public DeviceIterator(Iterator<Device> subIterator, 
                      IEntityClass[] entityClasses,
                      MacAddress macAddress,
                      VlanVid vlan, 
                      IPv4Address ipv4Address, 
                      IPv6Address ipv6Address,
                      DatapathId switchDPID,
                      OFPort switchPort) {
    super(subIterator);
    this.entityClasses = entityClasses;
    this.subIterator = subIterator;
    this.macAddress = macAddress;
    this.vlan = vlan;
    this.ipv4Address = ipv4Address;
    this.ipv6Address = ipv6Address;
    this.switchDPID = switchDPID;
    this.switchPort = switchPort;
}
 

import org.projectfloodlight.openflow.types.MacAddress; //导入依赖的package包/类
@Override
public void init(FloodlightModuleContext context)
		throws FloodlightModuleException {
	floodlightProviderService = context.getServiceImpl(IFloodlightProviderService.class);
	restApiService = context.getServiceImpl(IRestApiService.class);
	deviceService = context.getServiceImpl(IDeviceService.class);

	vNetsByGuid = new ConcurrentHashMap<String, VirtualNetwork>();
	nameToGuid = new ConcurrentHashMap<String, String>();
	guidToGateway = new ConcurrentHashMap<String, IPv4Address>();
	gatewayToGuid = new ConcurrentHashMap<IPv4Address, Set<String>>();
	macToGuid = new ConcurrentHashMap<MacAddress, String>();
	portToMac = new ConcurrentHashMap<String, MacAddress>();
	macToGateway = new ConcurrentHashMap<MacAddress, IPv4Address>();
	deviceListener = new DeviceListenerImpl();

}
 

import org.projectfloodlight.openflow.types.MacAddress; //导入依赖的package包/类
@Override
public void addHost(MacAddress mac, String guid, String port) {
	if (guid != null) {
		if (log.isDebugEnabled()) {
			log.debug("Adding {} to network ID {} on port {}",
					new Object[] {mac, guid, port});
		}
		// We ignore old mappings
		macToGuid.put(mac, guid);
		portToMac.put(port, mac);
		if (vNetsByGuid.get(guid) != null)
			vNetsByGuid.get(guid).addHost(port, mac);
	} else {
		log.warn("Could not add MAC {} to network ID {} on port {}, the network does not exist",
				new Object[] {mac.toString(), guid, port});
	}
}
 

import org.projectfloodlight.openflow.types.MacAddress; //导入依赖的package包/类
protected Match createMatchFromPacket(IOFSwitch sw, OFPort inPort, FloodlightContext cntx) {
	// The packet in match will only contain the port number.
	// We need to add in specifics for the hosts we're routing between.
	Ethernet eth = IFloodlightProviderService.bcStore.get(cntx, IFloodlightProviderService.CONTEXT_PI_PAYLOAD);
	VlanVid vlan = VlanVid.ofVlan(eth.getVlanID());
	MacAddress srcMac = eth.getSourceMACAddress();
	MacAddress dstMac = eth.getDestinationMACAddress();

	Match.Builder mb = sw.getOFFactory().buildMatch();
	mb.setExact(MatchField.IN_PORT, inPort)
	.setExact(MatchField.ETH_SRC, srcMac)
	.setExact(MatchField.ETH_DST, dstMac);

	if (!vlan.equals(VlanVid.ZERO)) {
		mb.setExact(MatchField.VLAN_VID, OFVlanVidMatch.ofVlanVid(vlan));
	}

	return mb.build();
}
 

import org.projectfloodlight.openflow.types.MacAddress; //导入依赖的package包/类
@Put
public String addHost(String postData) {
    IVirtualNetworkService vns =
            (IVirtualNetworkService)getContext().getAttributes().
                get(IVirtualNetworkService.class.getCanonicalName());
    HostDefinition host = new HostDefinition();
    host.port = (String) getRequestAttributes().get("port");
    host.guid = (String) getRequestAttributes().get("network");
    try {
        jsonToHostDefinition(postData, host);
    } catch (IOException e) {
        log.error("Could not parse JSON {}", e.getMessage());
    }
    vns.addHost(MacAddress.of(host.mac), host.guid, host.port);
    setStatus(Status.SUCCESS_OK);
    return "{\"status\":\"ok\"}";
}
 

import org.projectfloodlight.openflow.types.MacAddress; //导入依赖的package包/类
@Test
public void testLastSeen() throws Exception {
	Calendar c = Calendar.getInstance();
	Date d1 = c.getTime();
	Entity entity1 = new Entity(MacAddress.of(1L), null, null, null, null, d1);
	c.add(Calendar.SECOND, 1);
	Entity entity2 = new Entity(MacAddress.of(1L), null, IPv4Address.of(1), null, null, c.getTime());

	IDevice d = deviceManager.learnDeviceByEntity(entity2);
	assertEquals(c.getTime(), d.getLastSeen());
	d = deviceManager.learnDeviceByEntity(entity1);
	assertEquals(c.getTime(), d.getLastSeen());

	deviceManager.startUp(null);
	d = deviceManager.learnDeviceByEntity(entity1);
	assertEquals(d1, d.getLastSeen());
	d = deviceManager.learnDeviceByEntity(entity2);
	assertEquals(c.getTime(), d.getLastSeen());
}
 

import org.projectfloodlight.openflow.types.MacAddress; //导入依赖的package包/类
@Override
public void deleteHost(MacAddress mac, String port) {
	if (log.isDebugEnabled()) {
		log.debug("Removing host {} from port {}", mac, port);
	}
	if (mac == null && port == null) return;
	if (port != null) {
		MacAddress host = portToMac.remove(port);
		if (host != null && vNetsByGuid.get(macToGuid.get(host)) != null)
			vNetsByGuid.get(macToGuid.get(host)).removeHost(host);
		if (host != null)
			macToGuid.remove(host);
	} else if (mac != null) {
		if (!portToMac.isEmpty()) {
			for (Entry<String, MacAddress> entry : portToMac.entrySet()) {
				if (entry.getValue().equals(mac)) {
					if (vNetsByGuid.get(macToGuid.get(entry.getValue())) != null)
						vNetsByGuid.get(macToGuid.get(entry.getValue())).removeHost(entry.getValue());
					portToMac.remove(entry.getKey());
					macToGuid.remove(entry.getValue());
					return;
				}
			}
		}
	}
}
 

import org.projectfloodlight.openflow.types.MacAddress; //导入依赖的package包/类
public LBVip() {
    this.id = String.valueOf((int) (Math.random()*10000));
    this.name = null;
    this.tenantId = null;
    this.netId = null;
    this.address = 0;
    this.protocol = 0;
    this.lbMethod = 0;
    this.port = 0;
    this.pools = new ArrayList<String>();
    this.sessionPersistence = false;
    this.connectionLimit = 0;
    this.address = 0;
    this.status = 0;
    
    this.proxyMac = MacAddress.of(LB_PROXY_MAC);
}
 

import org.projectfloodlight.openflow.types.MacAddress; //导入依赖的package包/类
/**
 * Parse set_dl_src actions.
 * The key and delimiter for the action should be omitted, and only the
 * data should be presented to this decoder.
 * 
 * TODO should consider using MacAddress's built-in parser....
 * 
 * @param actionToDecode; The action as a string to decode
 * @param version; The OF version to create the action for
 * @param log
 * @return
 */
private static OFActionSetDlSrc decode_set_src_mac(String actionToDecode, OFVersion version, Logger log) {
	Matcher n = Pattern.compile("(?:(\\p{XDigit}+)\\:(\\p{XDigit}+)\\:(\\p{XDigit}+)\\:(\\p{XDigit}+)\\:(\\p{XDigit}+)\\:(\\p{XDigit}+))").matcher(actionToDecode); 
	if (n.matches()) {
		MacAddress macaddr = MacAddress.of(get_mac_addr(n, actionToDecode, log));
		if (macaddr != null) {
			OFActionSetDlSrc.Builder ab = OFFactories.getFactory(version).actions().buildSetDlSrc();
			ab.setDlAddr(macaddr);
			log.debug("action {}", ab.build());
			return ab.build();
		}            
	}
	else {
		log.debug("Invalid action: '{}'", actionToDecode);
		return null;
	}
	return null;
}
 

import org.projectfloodlight.openflow.types.MacAddress; //导入依赖的package包/类
/**
 * Generates a DHCP request OFPacketIn.
 * @param hostMac The host MAC address of for the request.
 * @return An OFPacketIn that contains a DHCP request packet.
 */
public static OFPacketIn DhcpDiscoveryRequestOFPacketIn(IOFSwitch sw,
        MacAddress hostMac) {
    byte[] serializedPacket = DhcpDiscoveryRequestEthernet(hostMac).serialize();
    OFFactory factory = sw.getOFFactory();
    OFPacketIn.Builder packetInBuilder = factory.buildPacketIn();
    if (factory.getVersion() == OFVersion.OF_10) {
    	packetInBuilder
    		.setInPort(OFPort.of(1))
            .setData(serializedPacket)
            .setReason(OFPacketInReason.NO_MATCH);
    } else {
    	packetInBuilder
    	.setMatch(factory.buildMatch().setExact(MatchField.IN_PORT, OFPort.of(1)).build())
        .setData(serializedPacket)
        .setReason(OFPacketInReason.NO_MATCH);
    }
    return packetInBuilder.build();
}
 

import org.projectfloodlight.openflow.types.MacAddress; //导入依赖的package包/类
/**
 * Construct a new device iterator over the key fields
 * @param subIterator an iterator over the full data structure to scan
 * @param entityClasses the entity classes to search for
 * @param macAddress The MAC address
 * @param vlan the VLAN
 * @param ipv4Address the ipv4 address
 * @param switchDPID the switch DPID
 * @param switchPort the switch port
 */
public DeviceIterator(Iterator<Device> subIterator, 
                      IEntityClass[] entityClasses,
                      MacAddress macAddress,
                      VlanVid vlan, 
                      IPv4Address ipv4Address, 
                      DatapathId switchDPID,
                      OFPort switchPort) {
    super(subIterator);
    this.entityClasses = entityClasses;
    this.subIterator = subIterator;
    this.macAddress = macAddress;
    this.vlan = vlan;
    this.ipv4Address = ipv4Address;
    this.switchDPID = switchDPID;
    this.switchPort = switchPort;
}