opendaylight/northbound/commons/src/main/java/org/opendaylight/controller/northbound/commons/utils/NorthboundUtils.java

   1 package org.opendaylight.controller.northbound.commons.utils;
   2
   3 import java.util.HashMap;
   4 import java.util.Map;
   5
   6 import javax.ws.rs.core.Response;
   7
   8 import org.opendaylight.controller.containermanager.IContainerAuthorization;
   9 import org.opendaylight.controller.sal.authorization.Privilege;
  10 import org.opendaylight.controller.sal.authorization.UserLevel;
  11 import org.opendaylight.controller.sal.core.Description;
  12 import org.opendaylight.controller.sal.core.Name;
  13 import org.opendaylight.controller.sal.core.Node;
  14 import org.opendaylight.controller.sal.core.NodeConnector;
  15 import org.opendaylight.controller.sal.utils.GlobalConstants;
  16 import org.opendaylight.controller.sal.utils.ServiceHelper;
  17 import org.opendaylight.controller.sal.utils.Status;
  18 import org.opendaylight.controller.sal.utils.StatusCode;
  19 import org.opendaylight.controller.switchmanager.ISwitchManager;
  20 import org.opendaylight.controller.usermanager.IUserManager;
  21 import org.slf4j.Logger;
  22 import org.slf4j.LoggerFactory;
  23
  24 public class NorthboundUtils {
  25
  26     private static final Map<StatusCode, Response.Status> ResponseStatusMapping = new HashMap<StatusCode, Response.Status>() {
  27         private static final long serialVersionUID = 1L;
  28         {
  29             put(StatusCode.SUCCESS, Response.Status.OK);
  30             put(StatusCode.BADREQUEST, Response.Status.BAD_REQUEST);
  31             put(StatusCode.UNAUTHORIZED, Response.Status.UNAUTHORIZED);
  32             put(StatusCode.FORBIDDEN, Response.Status.FORBIDDEN);
  33             put(StatusCode.NOTFOUND, Response.Status.NOT_FOUND);
  34             put(StatusCode.NOTALLOWED, Response.Status.FORBIDDEN);
  35             put(StatusCode.NOTACCEPTABLE, Response.Status.NOT_ACCEPTABLE);
  36             put(StatusCode.TIMEOUT, Response.Status.GONE);
  37             put(StatusCode.CONFLICT, Response.Status.CONFLICT);
  38             put(StatusCode.GONE, Response.Status.GONE);
  39             put(StatusCode.UNSUPPORTED, Response.Status.BAD_REQUEST);
  40             put(StatusCode.INTERNALERROR, Response.Status.INTERNAL_SERVER_ERROR);
  41             put(StatusCode.NOTIMPLEMENTED, Response.Status.NOT_ACCEPTABLE);
  42             put(StatusCode.NOSERVICE, Response.Status.SERVICE_UNAVAILABLE);
  43             put(StatusCode.UNDEFINED, Response.Status.BAD_REQUEST);
  44         }
  45     };
  46
  47     private static final String AUDIT = "audit";
  48
  49     private static final Logger logger = LoggerFactory.getLogger(AUDIT);
  50
  51     // Suppress default constructor for noninstantiability
  52     private NorthboundUtils() {
  53     }
  54
  55     /**
  56      * Returns Response.Status for a given status. If the status is null or if
  57      * the corresponding StatusCode is not present in the ResponseStatusMapping,
  58      * it returns null.
  59      *
  60      * @param status
  61      *            The Status
  62      * @return The Response.Status for a given status
  63      */
  64     public static Response.Status getResponseStatus(Status status) {
  65         return ResponseStatusMapping.get(status.getCode());
  66     }
  67
  68     /**
  69      * Returns Response for a given status. If the status provided is null or if
  70      * the corresponding StatusCode is not present in the ResponseStatusMapping,
  71      * it returns Response with StatusType as INTERNAL_SERVER_ERROR.
  72      *
  73      * @param status
  74      *            The Status
  75      * @return The Response for a given status.
  76      */
  77     public static Response getResponse(Status status) {
  78         if ((status == null) || (!ResponseStatusMapping.containsKey(status.getCode()))) {
  79             return Response.status(Response.Status.INTERNAL_SERVER_ERROR).entity("Action Result Unknown").build();
  80         }
  81         return Response.status(ResponseStatusMapping.get(status.getCode())).entity(status.getDescription()).build();
  82     }
  83
  84     /**
  85      * Returns whether the current user has the required privilege on the
  86      * specified container
  87      *
  88      * @param userName
  89      *            The user name
  90      * @param containerName
  91      *            The container name
  92      * @param required
  93      *            Operation to be performed - READ/WRITE
  94      * @param bundle
  95      *            Class from where the function is invoked
  96      * @return The Status of the request, either Success or Unauthorized
  97      */
  98     public static boolean isAuthorized(String userName, String containerName, Privilege required, Object bundle) {
  99
 100         if (containerName.equals(GlobalConstants.DEFAULT.toString())) {
 101             IUserManager auth = (IUserManager) ServiceHelper.getGlobalInstance(IUserManager.class, bundle);
 102
 103             switch (required) {
 104             case WRITE:
 105                 return (auth.getUserLevel(userName).ordinal() <= UserLevel.NETWORKADMIN.ordinal());
 106             case READ:
 107                 return (auth.getUserLevel(userName).ordinal() <= UserLevel.NETWORKOPERATOR.ordinal());
 108             default:
 109                 return false;
 110             }
 111
 112         } else {
 113             IContainerAuthorization auth = (IContainerAuthorization) ServiceHelper.getGlobalInstance(
 114                     IContainerAuthorization.class, bundle);
 115
 116             if (auth == null) {
 117                 return false;
 118             }
 119
 120             Privilege current = auth.getResourcePrivilege(userName, containerName);
 121             if (required.ordinal() > current.ordinal()) {
 122                 return false;
 123             }
 124         }
 125         return true;
 126     }
 127
 128     public static void auditlog(String moduleName, String user, String action, String resource,
 129             String containerName) {
 130         String auditMsg = "";
 131         String mode = "REST";
 132         if (containerName != null) {
 133             auditMsg = "Mode: " + mode + " User " + user + " "  + action + " " + moduleName + " " + resource + " in container "
 134                     + containerName;
 135         } else {
 136             auditMsg = "Mode: " + mode + " User " + user + " "  + action + " " + moduleName + " " + resource;
 137         }
 138         logger.info(auditMsg);
 139     }
 140
 141     public static void auditlog(String moduleName, String user, String action, String resource) {
 142         auditlog(moduleName, user, action, resource, null);
 143     }
 144
 145     public static String getNodeDesc(Node node, ISwitchManager switchManager) {
 146         Description desc = (Description) switchManager.getNodeProp(node,
 147                 Description.propertyName);
 148         String description = (desc == null) ? "" : desc.getValue();
 149         return (description.isEmpty() || description.equalsIgnoreCase("none")) ? node
 150                 .toString() : description;
 151     }
 152
 153     public static String getNodeDesc(Node node, String containerName,
 154             Object bundle) {
 155         ISwitchManager switchManager = (ISwitchManager) ServiceHelper
 156                 .getInstance(ISwitchManager.class, containerName, bundle);
 157         if (switchManager == null) {
 158             return null;
 159         }
 160
 161         return getNodeDesc(node, switchManager);
 162     }
 163
 164     public static String getNodeDesc(Node node, Object bundle) {
 165         ISwitchManager switchManager = (ISwitchManager) ServiceHelper
 166                 .getInstance(ISwitchManager.class,
 167                         GlobalConstants.DEFAULT.toString(), bundle);
 168         if (switchManager == null) {
 169             return null;
 170         }
 171
 172         return getNodeDesc(node, switchManager);
 173     }
 174
 175     public static String getPortName(NodeConnector nodeConnector,
 176             String container, Object bundle) {
 177         ISwitchManager switchManager = (ISwitchManager) ServiceHelper
 178                 .getInstance(ISwitchManager.class, container, bundle);
 179         return getPortName(nodeConnector, switchManager);
 180     }
 181
 182     public static String getPortName(NodeConnector nodeConnector, Object bundle) {
 183         return getPortName(nodeConnector, GlobalConstants.DEFAULT.toString(), bundle);
 184     }
 185
 186     public static String getPortName(NodeConnector nodeConnector,
 187             ISwitchManager switchManager) {
 188         Name ncName = ((Name) switchManager.getNodeConnectorProp(nodeConnector,
 189                 Name.NamePropName));
 190         String nodeConnectorName = (ncName != null) ? ncName.getValue() : nodeConnector.getNodeConnectorIdAsString();
 191         nodeConnectorName = nodeConnectorName + "@"
 192                 + getNodeDesc(nodeConnector.getNode(), switchManager);
 193         return nodeConnectorName.substring(0, nodeConnectorName.length());
 194     }
 195 }