| /* |
| * Copyright 2018-present Open Networking Foundation |
| * |
| * Licensed under the Apache License, Version 2.0 (the "License"); |
| * you may not use this file except in compliance with the License. |
| * You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| */ |
| |
| package org.onosproject.drivers.server; |
| |
| import org.onosproject.drivers.server.devices.RestServerSBDevice; |
| |
| import org.onosproject.net.DeviceId; |
| import org.onosproject.net.driver.AbstractHandlerBehaviour; |
| import org.onosproject.net.driver.DriverHandler; |
| import org.onosproject.protocol.rest.RestSBController; |
| import org.onosproject.protocol.rest.RestSBDevice; |
| |
| import org.slf4j.Logger; |
| |
| import com.fasterxml.jackson.databind.JsonNode; |
| |
| import java.util.EnumSet; |
| import javax.ws.rs.core.Response; |
| |
| import static com.google.common.base.Preconditions.checkNotNull; |
| import static org.onosproject.drivers.server.Constants.MSG_CONTROLLER_NULL; |
| import static org.onosproject.drivers.server.Constants.MSG_HANDLER_NULL; |
| import static org.onosproject.drivers.server.Constants.MSG_DEVICE_NULL; |
| import static org.slf4j.LoggerFactory.getLogger; |
| |
| /** |
| * The basic functionality of the server driver. |
| */ |
| public class BasicServerDriver extends AbstractHandlerBehaviour { |
| |
| private final Logger log = getLogger(getClass()); |
| |
| /** |
| * Successful HTTP status codes. |
| */ |
| private static final int STATUS_OK = Response.Status.OK.getStatusCode(); |
| private static final int STATUS_CREATED = Response.Status.CREATED.getStatusCode(); |
| private static final int STATUS_ACCEPTED = Response.Status.ACCEPTED.getStatusCode(); |
| |
| /** |
| * A unique controller that handles the REST-based communication. |
| */ |
| protected static RestSBController controller = null; |
| protected static DriverHandler handler = null; |
| protected static final Object CONTROLLER_LOCK = new Object(); |
| |
| public BasicServerDriver() {}; |
| |
| /** |
| * Retrieve an instance of the driver handler. |
| * |
| * @return DriverHandler instance |
| */ |
| protected DriverHandler getHandler() { |
| if (handler == null) { |
| synchronized (CONTROLLER_LOCK) { |
| handler = super.handler(); |
| checkNotNull(handler, MSG_HANDLER_NULL); |
| } |
| } |
| |
| return handler; |
| } |
| |
| /** |
| * Retrieve an instance of the REST SB controller. |
| * |
| * @return RestSBController instance |
| */ |
| public RestSBController getController() { |
| synchronized (CONTROLLER_LOCK) { |
| if (controller == null) { |
| controller = getHandler().get(RestSBController.class); |
| checkNotNull(controller, MSG_CONTROLLER_NULL); |
| } |
| } |
| |
| return controller; |
| } |
| |
| /** |
| * Retrieve an instance of the REST SB device, given its ID. |
| * |
| * @param deviceId a device ID |
| * @return RestSBDevice instance |
| */ |
| public RestSBDevice getDevice(DeviceId deviceId) { |
| return getController().getDevice(deviceId); |
| } |
| |
| /** |
| * Retrieve a REST SB device ID. |
| * |
| * @return a device Id |
| */ |
| public DeviceId getDeviceId() { |
| return getHandler().data().deviceId(); |
| } |
| |
| /** |
| * Finds the NIC name that corresponds to a device's port number. |
| * |
| * @param deviceId a device ID |
| * @param port a NIC port number |
| * @return device's NIC name |
| */ |
| public static String findNicInterfaceWithPort(DeviceId deviceId, long port) { |
| if (controller == null) { |
| return null; |
| } |
| |
| RestServerSBDevice device = null; |
| try { |
| device = (RestServerSBDevice) controller.getDevice(deviceId); |
| } catch (ClassCastException ccEx) { |
| return null; |
| } |
| checkNotNull(device, MSG_DEVICE_NULL); |
| |
| return device.portNameFromNumber(port); |
| } |
| |
| /** |
| * Return all the enumeration's types in a space-separated string. |
| * |
| * @param <E> the expected class of the enum |
| * @param enumType the enum class to get its types |
| * @return String with all enumeration types |
| */ |
| public static <E extends Enum<E>> String enumTypesToString(Class<E> enumType) { |
| String allTypes = ""; |
| for (E en : EnumSet.allOf(enumType)) { |
| allTypes += en.toString() + " "; |
| } |
| |
| return allTypes.trim(); |
| } |
| |
| /** |
| * Return a string value after reading the input |
| * attribute from the input JSON node. |
| * |
| * @param jsonNode JSON node to read from |
| * @param attribute to lookup in the JSON node |
| * @return string value mapped to the attribute |
| */ |
| public static String get(JsonNode jsonNode, String attribute) { |
| if (jsonNode == null || (attribute == null || attribute.isEmpty())) { |
| return null; |
| } |
| |
| String result = ""; |
| |
| try { |
| result = jsonNode.get(attribute).asText(); |
| } catch (Exception ex) { |
| throw new IllegalArgumentException( |
| "Failed to read JSON attribute: " + attribute |
| ); |
| } |
| |
| return result; |
| } |
| |
| /** |
| * Assess a given HTTP status code. |
| * |
| * @param statusCode the HTTP status code to check |
| * @return boolean status (success or failure) |
| */ |
| public static boolean checkStatusCode(int statusCode) { |
| if (statusCode == STATUS_OK || statusCode == STATUS_CREATED || statusCode == STATUS_ACCEPTED) { |
| return true; |
| } |
| |
| return false; |
| } |
| |
| /** |
| * Check whether a server device is active or not. |
| * |
| * @param device a device to check |
| * @return boolean status (true for active or false for inactive) |
| */ |
| protected boolean deviceIsActive(RestSBDevice device) { |
| return device.isActive(); |
| } |
| |
| /** |
| * Raise a connect event by setting the |
| * activity flag of this device. |
| * |
| * @param device a device to connect |
| */ |
| protected void raiseDeviceReconnect(RestSBDevice device) { |
| // Already done! |
| if (device.isActive()) { |
| return; |
| } |
| |
| log.debug("Setting device {} active", device.deviceId()); |
| device.setActive(true); |
| } |
| |
| /** |
| * Upon a failure to contact a device, the driver |
| * raises a disconnect event by resetting the |
| * activity flag of this device. |
| * |
| * @param device a device to disconnect |
| */ |
| protected void raiseDeviceDisconnect(RestSBDevice device) { |
| // Already done! |
| if (!device.isActive()) { |
| return; |
| } |
| |
| log.info("Setting device {} inactive", device.deviceId()); |
| device.setActive(false); |
| } |
| |
| } |