@Override
 public void event(DeviceEvent event) {
   Device device = event.subject();
   switch (event.type()) {
     case DEVICE_ADDED:
       break;
     case DEVICE_AVAILABILITY_CHANGED:
       if (hostRemovalEnabled && !deviceService.isAvailable(device.id())) {
         removeHosts(hostService.getConnectedHosts(device.id()));
       }
       break;
     case DEVICE_SUSPENDED:
     case DEVICE_UPDATED:
       // Nothing to do?
       break;
     case DEVICE_REMOVED:
       if (hostRemovalEnabled) {
         removeHosts(hostService.getConnectedHosts(device.id()));
       }
       break;
     case PORT_ADDED:
       break;
     case PORT_UPDATED:
       if (hostRemovalEnabled) {
         ConnectPoint point = new ConnectPoint(device.id(), event.port().number());
         removeHosts(hostService.getConnectedHosts(point));
       }
       break;
     case PORT_REMOVED:
       // Nothing to do?
       break;
     default:
       break;
   }
 }
示例#2
0
  @Test
  public final void testUpdatePortStatus() {
    putDevice(DID1, SW1);
    List<PortDescription> pds =
        Arrays.<PortDescription>asList(new DefaultPortDescription(P1, true));
    deviceStore.updatePorts(PID, DID1, pds);

    Capture<InternalPortStatusEvent> message = new Capture<>();
    Capture<MessageSubject> subject = new Capture<>();
    Capture<Function<InternalPortStatusEvent, byte[]>> encoder = new Capture<>();

    resetCommunicatorExpectingSingleBroadcast(message, subject, encoder);
    final DefaultPortDescription desc = new DefaultPortDescription(P1, false);
    DeviceEvent event = deviceStore.updatePortStatus(PID, DID1, desc);
    assertEquals(PORT_UPDATED, event.type());
    assertDevice(DID1, SW1, event.subject());
    assertEquals(P1, event.port().number());
    assertFalse("Port is disabled", event.port().isEnabled());
    verify(clusterCommunicator);
    assertInternalPortStatusEvent(NID1, DID1, PID, desc, NO_ANNOTATION, message, subject, encoder);
    assertTrue(message.hasCaptured());
  }
    @Override
    public void run() {

      if (doNotPushFlows) {
        return;
      }

      switch (deviceEvent.type()) {
        case DEVICE_ADDED:
          processDeviceAdded((Device) deviceEvent.subject());
          break;
        case DEVICE_UPDATED:
          Port port = (Port) deviceEvent.subject();
          if (port.isEnabled()) {
            processPortAdded((Device) deviceEvent.subject(), deviceEvent.port());
          }
          break;
        case DEVICE_AVAILABILITY_CHANGED:
          Device device = (Device) deviceEvent.subject();
          if (deviceService.isAvailable(device.id())) {
            processDeviceAdded(device);
          }
          break;
        case PORT_ADDED:
          processPortAdded((Device) deviceEvent.subject(), deviceEvent.port());
          break;
        case PORT_UPDATED:
          processPortAdded((Device) deviceEvent.subject(), deviceEvent.port());
          break;
        case PORT_REMOVED:
          processPortRemoved((Device) deviceEvent.subject(), deviceEvent.port());
          break;
        default:
          break;
      }
    }
示例#4
0
  private void printEvent(Event<?, ?> event) {
    if (event instanceof DeviceEvent) {
      DeviceEvent deviceEvent = (DeviceEvent) event;
      if (event.type().toString().startsWith("PORT")) {
        // Port event
        print(
            "%s %s\t%s/%s [%s]",
            new LocalDateTime(event.time()),
            event.type(),
            deviceEvent.subject().id(),
            deviceEvent.port().number(),
            deviceEvent.port());
      } else {
        // Device event
        print(
            "%s %s\t%s [%s]",
            new LocalDateTime(event.time()),
            event.type(),
            deviceEvent.subject().id(),
            deviceEvent.subject());
      }

    } else if (event instanceof MastershipEvent) {
      print(
          "%s %s\t%s [%s]",
          new LocalDateTime(event.time()),
          event.type(),
          event.subject(),
          ((MastershipEvent) event).roleInfo());

    } else if (event instanceof LinkEvent) {
      LinkEvent linkEvent = (LinkEvent) event;
      Link link = linkEvent.subject();
      print(
          "%s %s\t%s/%s-%s/%s [%s]",
          new LocalDateTime(event.time()),
          event.type(),
          link.src().deviceId(),
          link.src().port(),
          link.dst().deviceId(),
          link.dst().port(),
          link);

    } else if (event instanceof HostEvent) {
      HostEvent hostEvent = (HostEvent) event;
      print(
          "%s %s\t%s [%s->%s]",
          new LocalDateTime(event.time()),
          event.type(),
          hostEvent.subject().id(),
          hostEvent.prevSubject(),
          hostEvent.subject());

    } else if (event instanceof TopologyEvent) {
      TopologyEvent topoEvent = (TopologyEvent) event;
      List<Event> reasons =
          MoreObjects.firstNonNull(topoEvent.reasons(), ImmutableList.<Event>of());
      Topology topo = topoEvent.subject();
      String summary =
          String.format(
              "(d=%d,l=%d,c=%d)", topo.deviceCount(), topo.linkCount(), topo.clusterCount());
      print(
          "%s %s%s [%s]",
          new LocalDateTime(event.time()),
          event.type(),
          summary,
          reasons.stream().map(e -> e.type()).collect(toList()));

    } else if (event instanceof ClusterEvent) {
      print(
          "%s %s\t%s [%s]",
          new LocalDateTime(event.time()),
          event.type(),
          ((ClusterEvent) event).subject().id(),
          event.subject());

    } else {
      // Unknown Event?
      print(
          "%s %s\t%s [%s]", new LocalDateTime(event.time()), event.type(), event.subject(), event);
    }
  }
示例#5
0
  @Test
  public final void testUpdatePortStatusAncillary() throws IOException {
    putDeviceAncillary(DID1, SW1);
    putDevice(DID1, SW1);
    List<PortDescription> pds =
        Arrays.<PortDescription>asList(new DefaultPortDescription(P1, true, A1));
    deviceStore.updatePorts(PID, DID1, pds);

    Capture<InternalPortStatusEvent> message = new Capture<>();
    Capture<MessageSubject> subject = new Capture<>();
    Capture<Function<InternalPortStatusEvent, byte[]>> encoder = new Capture<>();

    // update port from primary
    resetCommunicatorExpectingSingleBroadcast(message, subject, encoder);

    final DefaultPortDescription desc1 = new DefaultPortDescription(P1, false, A1_2);
    DeviceEvent event = deviceStore.updatePortStatus(PID, DID1, desc1);
    assertEquals(PORT_UPDATED, event.type());
    assertDevice(DID1, SW1, event.subject());
    assertEquals(P1, event.port().number());
    assertAnnotationsEquals(event.port().annotations(), A1, A1_2);
    assertFalse("Port is disabled", event.port().isEnabled());
    verify(clusterCommunicator);
    assertInternalPortStatusEvent(
        NID1, DID1, PID, desc1, asList(A1, A1_2), message, subject, encoder);
    assertTrue(message.hasCaptured());

    // update port from ancillary with no attributes
    resetCommunicatorExpectingNoBroadcast(message, subject, encoder);
    final DefaultPortDescription desc2 = new DefaultPortDescription(P1, true);
    DeviceEvent event2 = deviceStore.updatePortStatus(PIDA, DID1, desc2);
    assertNull("Ancillary is ignored if primary exists", event2);
    verify(clusterCommunicator);
    assertFalse(message.hasCaptured());

    // but, Ancillary annotation update will be notified
    resetCommunicatorExpectingSingleBroadcast(message, subject, encoder);
    final DefaultPortDescription desc3 = new DefaultPortDescription(P1, true, A2);
    DeviceEvent event3 = deviceStore.updatePortStatus(PIDA, DID1, desc3);
    assertEquals(PORT_UPDATED, event3.type());
    assertDevice(DID1, SW1, event3.subject());
    assertEquals(P1, event3.port().number());
    assertAnnotationsEquals(event3.port().annotations(), A1, A1_2, A2);
    assertFalse("Port is disabled", event3.port().isEnabled());
    verify(clusterCommunicator);
    assertInternalPortStatusEvent(NID1, DID1, PIDA, desc3, asList(A2), message, subject, encoder);
    assertTrue(message.hasCaptured());

    // port only reported from Ancillary will be notified as down
    resetCommunicatorExpectingSingleBroadcast(message, subject, encoder);
    final DefaultPortDescription desc4 = new DefaultPortDescription(P2, true);
    DeviceEvent event4 = deviceStore.updatePortStatus(PIDA, DID1, desc4);
    assertEquals(PORT_ADDED, event4.type());
    assertDevice(DID1, SW1, event4.subject());
    assertEquals(P2, event4.port().number());
    assertAnnotationsEquals(event4.port().annotations());
    assertFalse("Port is disabled if not given from primary provider", event4.port().isEnabled());
    verify(clusterCommunicator);
    // TODO: verify broadcast message content
    assertInternalPortStatusEvent(
        NID1, DID1, PIDA, desc4, NO_ANNOTATION, message, subject, encoder);
    assertTrue(message.hasCaptured());
  }
示例#6
0
  @Test
  public final void testUpdatePorts() {
    putDevice(DID1, SW1);
    List<PortDescription> pds =
        Arrays.<PortDescription>asList(
            new DefaultPortDescription(P1, true), new DefaultPortDescription(P2, true));
    Capture<InternalDeviceEvent> message = new Capture<>();
    Capture<MessageSubject> subject = new Capture<>();
    Capture<Function<InternalDeviceEvent, byte[]>> encoder = new Capture<>();

    resetCommunicatorExpectingSingleBroadcast(message, subject, encoder);
    List<DeviceEvent> events = deviceStore.updatePorts(PID, DID1, pds);
    verify(clusterCommunicator);
    // TODO: verify broadcast message
    assertTrue(message.hasCaptured());

    Set<PortNumber> expectedPorts = Sets.newHashSet(P1, P2);
    for (DeviceEvent event : events) {
      assertEquals(PORT_ADDED, event.type());
      assertDevice(DID1, SW1, event.subject());
      assertTrue("PortNumber is one of expected", expectedPorts.remove(event.port().number()));
      assertTrue("Port is enabled", event.port().isEnabled());
    }
    assertTrue("Event for all expectedport appeared", expectedPorts.isEmpty());

    List<PortDescription> pds2 =
        Arrays.<PortDescription>asList(
            new DefaultPortDescription(P1, false),
            new DefaultPortDescription(P2, true),
            new DefaultPortDescription(P3, true));

    resetCommunicatorExpectingSingleBroadcast(message, subject, encoder);
    events = deviceStore.updatePorts(PID, DID1, pds2);
    verify(clusterCommunicator);
    // TODO: verify broadcast message
    assertTrue(message.hasCaptured());

    assertFalse("event should be triggered", events.isEmpty());
    for (DeviceEvent event : events) {
      PortNumber num = event.port().number();
      if (P1.equals(num)) {
        assertEquals(PORT_UPDATED, event.type());
        assertDevice(DID1, SW1, event.subject());
        assertFalse("Port is disabled", event.port().isEnabled());
      } else if (P2.equals(num)) {
        fail("P2 event not expected.");
      } else if (P3.equals(num)) {
        assertEquals(PORT_ADDED, event.type());
        assertDevice(DID1, SW1, event.subject());
        assertTrue("Port is enabled", event.port().isEnabled());
      } else {
        fail("Unknown port number encountered: " + num);
      }
    }

    List<PortDescription> pds3 =
        Arrays.<PortDescription>asList(
            new DefaultPortDescription(P1, false), new DefaultPortDescription(P2, true));
    resetCommunicatorExpectingSingleBroadcast(message, subject, encoder);
    events = deviceStore.updatePorts(PID, DID1, pds3);
    verify(clusterCommunicator);
    // TODO: verify broadcast message
    assertTrue(message.hasCaptured());

    assertFalse("event should be triggered", events.isEmpty());
    for (DeviceEvent event : events) {
      PortNumber num = event.port().number();
      if (P1.equals(num)) {
        fail("P1 event not expected.");
      } else if (P2.equals(num)) {
        fail("P2 event not expected.");
      } else if (P3.equals(num)) {
        assertEquals(PORT_REMOVED, event.type());
        assertDevice(DID1, SW1, event.subject());
        assertTrue("Port was enabled", event.port().isEnabled());
      } else {
        fail("Unknown port number encountered: " + num);
      }
    }
  }