[ONOS-2383]Fixs the DeviceManager.java white-spacing/line-breaks

Change-Id: Ic2f44f5121fa5afbf64a216af301d690106efaf8

[ONOS-2383]Fixs the DeviceManager.java white-spacing/line-breaks
Change-Id: Ic2f44f5121fa5afbf64a216af301d690106efaf8
samuel
Commit e1fa7324f779f03799fa53b8230e8d83272d41bd e1fa7324 1 parent 24c54156
Showing 1 changed file with 62 additions and 83 deletions
core/net/src/main/java/org/onosproject/net/device/impl/DeviceManager.java
--- a/core/net/src/main/java/org/onosproject/net/device/impl/DeviceManager.java
View file @e1fa732
+++ b/core/net/src/main/java/org/onosproject/net/device/impl/DeviceManager.java
View file @e1fa732
@@ -77,6 +77,7 @@ import org.slf4j.Logger;
 import com.google.common.collect.Lists;
+
 /**
  * Provides implementation of the device SB &amp; NB APIs.
  */
@@ -93,7 +94,8 @@ public class DeviceManager
     private final Logger log = getLogger(getClass());
-    protected final ListenerRegistry<DeviceEvent, DeviceListener> listenerRegistry = new ListenerRegistry<>();
+    protected final ListenerRegistry<DeviceEvent, DeviceListener> listenerRegistry =
+            new ListenerRegistry<>();
     private final DeviceStoreDelegate delegate = new InternalStoreDelegate();
@@ -122,8 +124,7 @@ public class DeviceManager
     @Activate
     public void activate() {
-        backgroundService = newSingleThreadScheduledExecutor(groupedThreads("onos/device",
+        backgroundService = newSingleThreadScheduledExecutor(groupedThreads("onos/device", "manager-background"));
-                                                                            "manager-background"));
         localNodeId = clusterService.getLocalNode().id();
         store.setDelegate(delegate);
@@ -263,7 +264,8 @@ public class DeviceManager
     }
     @Override
-    protected DeviceProviderService createProviderService(DeviceProvider provider) {
+    protected DeviceProviderService createProviderService(
+            DeviceProvider provider) {
         return new InternalDeviceProviderService(provider);
     }
@@ -284,8 +286,7 @@ public class DeviceManager
                 continue;
             }
-            log.info("{} is reachable but did not have a valid role, reasserting",
+            log.info("{} is reachable but did not have a valid role, reasserting", deviceId);
-                     deviceId);
             // isReachable but was not MASTER or STANDBY, get a role and apply
             // Note: NONE triggers request to MastershipService
@@ -312,14 +313,13 @@ public class DeviceManager
         private boolean applyRole(DeviceId deviceId, MastershipRole newRole) {
             if (newRole.equals(MastershipRole.NONE)) {
-                // no-op
+                //no-op
                 return true;
             }
             DeviceProvider provider = provider();
             if (provider == null) {
-                log.warn("Provider for {} was not found. Cannot apply role {}",
+                log.warn("Provider for {} was not found. Cannot apply role {}", deviceId, newRole);
-                         deviceId, newRole);
                 return false;
             }
             provider.roleChanged(deviceId, newRole);
@@ -328,6 +328,7 @@ public class DeviceManager
             return true;
         }
+
         @Override
         public void deviceConnected(DeviceId deviceId,
                                     DeviceDescription deviceDescription) {
@@ -337,16 +338,14 @@ public class DeviceManager
             log.info("Device {} connected", deviceId);
             // check my Role
-            CompletableFuture<MastershipRole> role = mastershipService
+            CompletableFuture<MastershipRole> role = mastershipService.requestRoleFor(deviceId);
-                    .requestRoleFor(deviceId);
             try {
                 // Device subsystem must wait for role assignment
                 // to avoid losing Device information.
                 // (This node could be the only Node connected to the Device.)
                 role.get();
             } catch (InterruptedException e) {
-                log.warn("Interrupted while waiting role-assignment for {}",
+                log.warn("Interrupted while waiting role-assignment for {}", deviceId);
-                         deviceId);
                 Thread.currentThread().interrupt();
             } catch (ExecutionException e) {
                 log.error("Exception thrown while waiting role-assignment for {}",
@@ -365,8 +364,7 @@ public class DeviceManager
             }
             DeviceEvent event = store.createOrUpdateDevice(provider().id(),
-                                                           deviceId,
+                                                           deviceId, deviceDescription);
-                                                           deviceDescription);
             if (event != null) {
                 log.trace("event: {} {}", event.type(), event);
@@ -383,8 +381,10 @@ public class DeviceManager
             List<Port> ports = store.getPorts(deviceId);
             List<PortDescription> descs = Lists.newArrayList();
-            ports.forEach(port -> descs.add(new DefaultPortDescription(port
+            ports.forEach(port ->
-                    .number(), false, port.type(), port.portSpeed())));
+                descs.add(new DefaultPortDescription(port.number(),
+                                                     false, port.type(),
+                                                     port.portSpeed())));
             store.updatePorts(this.provider().id(), deviceId, descs);
             try {
                 if (mastershipService.getLocalRole(deviceId) == MASTER) {
@@ -393,49 +393,37 @@ public class DeviceManager
             } catch (IllegalStateException e) {
                 log.warn("Failed to mark {} offline", deviceId);
                 // only the MASTER should be marking off-line in normal cases,
-                // but if I was the last STANDBY connection, etc. and no one
+                // but if I was the last STANDBY connection, etc. and no one else
-                // else
+                // was there to mark the device offline, this instance may need to
-                // was there to mark the device offline, this instance may need
-                // to
                 // temporarily request for Master Role and mark offline.
-                // there are times when this node will correctly have
+                //there are times when this node will correctly have mastership, BUT
-                // mastership, BUT
+                //that isn't reflected in the ClockManager before the device disconnects.
-                // that isn't reflected in the ClockManager before the device
+                //we want to let go of the device anyways, so make sure this happens.
-                // disconnects.
-                // we want to let go of the device anyways, so make sure this
-                // happens.
                 // FIXME: Store semantics leaking out as IllegalStateException.
                 //  Consider revising store API to handle this scenario.
-                CompletableFuture<MastershipRole> roleFuture = mastershipService
+                CompletableFuture<MastershipRole> roleFuture = mastershipService.requestRoleFor(deviceId);
-                        .requestRoleFor(deviceId);
                 roleFuture.whenComplete((role, error) -> {
-                    MastershipTerm term = termService
+                    MastershipTerm term = termService.getMastershipTerm(deviceId);
-                            .getMastershipTerm(deviceId);
+                    // TODO: Move this type of check inside device clock manager, etc.
-                    // TODO: Move this type of check inside device clock
-                    // manager, etc.
                     if (term != null && localNodeId.equals(term.master())) {
                         log.info("Retry marking {} offline", deviceId);
-                            deviceClockProviderService
+                        deviceClockProviderService.setMastershipTerm(deviceId, term);
-                                    .setMastershipTerm(deviceId, term);
                         post(store.markOffline(deviceId));
                     } else {
-                            log.info("Failed again marking {} offline. {}",
+                        log.info("Failed again marking {} offline. {}", deviceId, role);
-                                     deviceId, role);
                     }
                 });
             } finally {
                 try {
-                    // relinquish master role and ability to be backup.
+                    //relinquish master role and ability to be backup.
                     mastershipService.relinquishMastership(deviceId).get();
                 } catch (InterruptedException e) {
-                    log.warn("Interrupted while reliquishing role for {}",
+                    log.warn("Interrupted while reliquishing role for {}", deviceId);
-                             deviceId);
                     Thread.currentThread().interrupt();
                 } catch (ExecutionException e) {
-                    log.error("Exception thrown while relinquishing role for {}",
+                    log.error("Exception thrown while relinquishing role for {}", deviceId, e);
-                              deviceId, e);
                 }
             }
         }
@@ -450,14 +438,12 @@ public class DeviceManager
             if (!deviceClockProviderService.isTimestampAvailable(deviceId)) {
                 // Never been a master for this device
                 // any update will be ignored.
-                log.trace("Ignoring {} port updates on standby node. {}",
+                log.trace("Ignoring {} port updates on standby node. {}", deviceId, portDescriptions);
-                          deviceId, portDescriptions);
                 return;
             }
             List<DeviceEvent> events = store.updatePorts(this.provider().id(),
-                                                         deviceId,
+                                                         deviceId, portDescriptions);
-                                                         portDescriptions);
             for (DeviceEvent event : events) {
                 post(event);
             }
@@ -473,13 +459,12 @@ public class DeviceManager
             if (!deviceClockProviderService.isTimestampAvailable(deviceId)) {
                 // Never been a master for this device
                 // any update will be ignored.
-                log.trace("Ignoring {} port update on standby node. {}",
+                log.trace("Ignoring {} port update on standby node. {}", deviceId, portDescription);
-                          deviceId, portDescription);
                 return;
             }
-            final DeviceEvent event = store.updatePortStatus(this.provider()
+            final DeviceEvent event = store.updatePortStatus(this.provider().id(),
-                    .id(), deviceId, portDescription);
+                                                             deviceId, portDescription);
             if (event != null) {
                 log.info("Device {} port {} status changed", deviceId, event
                         .port().number());
@@ -488,8 +473,7 @@ public class DeviceManager
         }
         @Override
-        public void receivedRoleReply(DeviceId deviceId,
+        public void receivedRoleReply(DeviceId deviceId, MastershipRole requested,
-                                      MastershipRole requested,
                                       MastershipRole response) {
             // Several things can happen here:
             // 1. request and response match
@@ -505,47 +489,40 @@ public class DeviceManager
                      deviceId, requested, response);
             if (requested == null && response == null) {
-                // something was off with DeviceProvider, maybe check channel
+                // something was off with DeviceProvider, maybe check channel too?
-                // too?
+                log.warn("Failed to assert role [{}] onto Device {}", requested, deviceId);
-                log.warn("Failed to assert role [{}] onto Device {}",
-                         requested, deviceId);
                 mastershipService.relinquishMastership(deviceId);
                 return;
             }
             if (Objects.equals(requested, response)) {
-                if (Objects.equals(requested,
+                if (Objects.equals(requested, mastershipService.getLocalRole(deviceId))) {
-                                   mastershipService.getLocalRole(deviceId))) {
                     return;
                 } else {
                     return;
-                    // FIXME roleManager got the device to comply, but doesn't
+                    // FIXME roleManager got the device to comply, but doesn't agree with
-                    // agree with
                     // the store; use the store's view, then try to reassert.
                 }
             } else {
                 // we didn't get back what we asked for. Reelect someone else.
-                log.warn("Failed to assert role [{}] onto Device {}", response,
+                log.warn("Failed to assert role [{}] onto Device {}", response, deviceId);
-                         deviceId);
                 if (response == MastershipRole.MASTER) {
                     mastershipService.relinquishMastership(deviceId);
                     // TODO: Shouldn't we be triggering event?
-                    // final Device device = getDevice(deviceId);
+                    //final Device device = getDevice(deviceId);
-                    // post(new DeviceEvent(DEVICE_MASTERSHIP_CHANGED, device));
+                    //post(new DeviceEvent(DEVICE_MASTERSHIP_CHANGED, device));
                 }
             }
         }
         @Override
-        public void updatePortStatistics(DeviceId deviceId,
+        public void updatePortStatistics(DeviceId deviceId, Collection<PortStatistics> portStatistics) {
-                                         Collection<PortStatistics> portStatistics) {
             checkNotNull(deviceId, DEVICE_ID_NULL);
             checkNotNull(portStatistics, "Port statistics list cannot be null");
             checkValidity();
-            DeviceEvent event = store
+            DeviceEvent event = store.updatePortStatistics(this.provider().id(),
-                    .updatePortStatistics(this.provider().id(), deviceId,
+                                                           deviceId, portStatistics);
-                                          portStatistics);
             post(event);
         }
     }
@@ -567,14 +544,13 @@ public class DeviceManager
      */
     private boolean applyRoleAndProbe(DeviceId deviceId, MastershipRole newRole) {
         if (newRole.equals(MastershipRole.NONE)) {
-            // no-op
+            //no-op
             return true;
         }
         DeviceProvider provider = getProvider(deviceId);
         if (provider == null) {
-            log.warn("Provider for {} was not found. Cannot apply role {}",
+            log.warn("Provider for {} was not found. Cannot apply role {}", deviceId, newRole);
-                     deviceId, newRole);
             return false;
         }
         provider.roleChanged(deviceId, newRole);
@@ -590,10 +566,11 @@ public class DeviceManager
      * Reaasert role for specified device connected to this node.
      *
      * @param did         device identifier
-     * @param nextRole role to apply. If NONE is specified, it will ask
+     * @param nextRole    role to apply. If NONE is specified,
-     *            mastership service for a role and apply it.
+     *        it will ask mastership service for a role and apply it.
      */
-    private void reassertRole(final DeviceId did, final MastershipRole nextRole) {
+    private void reassertRole(final DeviceId did,
+                              final MastershipRole nextRole) {
         MastershipRole myNextRole = nextRole;
         if (myNextRole == NONE) {
@@ -610,17 +587,18 @@ public class DeviceManager
         case MASTER:
             final Device device = getDevice(did);
             if ((device != null) && !isAvailable(did)) {
-                // flag the device as online. Is there a better way to do this?
+                //flag the device as online. Is there a better way to do this?
-                DefaultDeviceDescription deviceDescription = new DefaultDeviceDescription(
+                DefaultDeviceDescription deviceDescription
-                                                                                          did.uri(),
+                    = new DefaultDeviceDescription(did.uri(),
                                                    device.type(),
                                                    device.manufacturer(),
                                                    device.hwVersion(),
                                                    device.swVersion(),
                                                    device.serialNumber(),
                                                    device.chassisId());
-                DeviceEvent devEvent = store.createOrUpdateDevice(device
+                DeviceEvent devEvent =
-                        .providerId(), did, deviceDescription);
+                        store.createOrUpdateDevice(device.providerId(), did,
+                                                   deviceDescription);
                 post(devEvent);
             }
             // TODO: should apply role only if there is mismatch
@@ -662,8 +640,7 @@ public class DeviceManager
         if (localNodeId.equals(event.roleInfo().master())) {
             // confirm latest info
             MastershipTerm term = termService.getMastershipTerm(did);
-            final boolean iHaveControl = term != null
+            final boolean iHaveControl = term != null && localNodeId.equals(term.master());
-                    && localNodeId.equals(term.master());
             if (iHaveControl) {
                 deviceClockProviderService.setMastershipTerm(did, term);
                 myNextRole = MASTER;
@@ -676,13 +653,15 @@ public class DeviceManager
             myNextRole = NONE;
         }
+
         final boolean isReachable = isReachable(did);
         if (!isReachable) {
             // device is not connected to this node
             if (myNextRole != NONE) {
                 log.warn("Node was instructed to be {} role for {}, "
                         + "but this node cannot reach the device.  "
-                        + "Relinquishing role.  ", myNextRole, did);
+                        + "Relinquishing role.  ",
+                         myNextRole, did);
                 mastershipService.relinquishMastership(did);
             }
             return;