git.opendaylight Code Review - vtn.git/blob

   1 /*
   2  * Copyright (c) 2012-2013 NEC Corporation
   3  * All rights reserved.
   4  *
   5  * This program and the accompanying materials are made available under the
   6  * terms of the Eclipse Public License v1.0 which accompanies this
   7  * distribution, and is available at http://www.eclipse.org/legal/epl-v10.html
   8  */
   9 package org.opendaylight.vtn.javaapi.resources.physical;
  10
  11 import java.util.ArrayList;
  12 import java.util.List;
  13
  14 import com.google.gson.JsonArray;
  15 import com.google.gson.JsonNull;
  16 import com.google.gson.JsonObject;
  17 import org.opendaylight.vtn.core.ipc.ClientSession;
  18 import org.opendaylight.vtn.core.ipc.IpcDataUnit;
  19 import org.opendaylight.vtn.core.util.Logger;
  20 import org.opendaylight.vtn.javaapi.annotation.UNCField;
  21 import org.opendaylight.vtn.javaapi.annotation.UNCVtnService;
  22 import org.opendaylight.vtn.javaapi.constants.VtnServiceConsts;
  23 import org.opendaylight.vtn.javaapi.constants.VtnServiceJsonConsts;
  24 import org.opendaylight.vtn.javaapi.exception.VtnServiceException;
  25 import org.opendaylight.vtn.javaapi.init.VtnServiceConfiguration;
  26 import org.opendaylight.vtn.javaapi.init.VtnServiceInitManager;
  27 import org.opendaylight.vtn.javaapi.ipc.IpcRequestProcessor;
  28 import org.opendaylight.vtn.javaapi.ipc.conversion.IpcDataUnitWrapper;
  29 import org.opendaylight.vtn.javaapi.ipc.conversion.IpcPhysicalResponseFactory;
  30 import org.opendaylight.vtn.javaapi.ipc.enums.IpcRequestPacketEnum;
  31 import org.opendaylight.vtn.javaapi.ipc.enums.UncCommonEnum;
  32 import org.opendaylight.vtn.javaapi.ipc.enums.UncCommonEnum.UncResultCode;
  33 import org.opendaylight.vtn.javaapi.ipc.enums.UncJavaAPIErrorCode;
  34 import org.opendaylight.vtn.javaapi.ipc.enums.UncOperationEnum;
  35 import org.opendaylight.vtn.javaapi.ipc.enums.UncUPPLEnums;
  36 import org.opendaylight.vtn.javaapi.resources.AbstractResource;
  37 import org.opendaylight.vtn.javaapi.validation.physical.DomainLogicalPortResourceValidator;
  38
  39 /**
  40  * The Class DomainLogicalPortResource implements get method.
  41  */
  42 @UNCVtnService(path = "/controllers/{controller_id}/domains/{domain_id}/logical_ports/{logical_port_id}")
  43 public class DomainLogicalPortResource extends AbstractResource {
  44         /**
  45          * @return the controllerId
  46          */
  47         @UNCField("controller_id")
  48         private String controllerId;
  49         /**
  50          * Getter for domainId
  51          *
  52          * @return
  53          */
  54         @UNCField("domain_id")
  55         private String domainId;
  56         /**
  57          * Getter for logicalPortId
  58          *
  59          * @return
  60          */
  61         @UNCField("logical_port_id")
  62         private String logicalPortId;
  63         private static final Logger LOG = Logger
  64                         .getLogger(DomainLogicalPortResource.class.getName());
  65
  66         /**
  67          * Instantiates a new DomainLogicalPortResource resource.
  68          */
  69         public DomainLogicalPortResource() {
  70                 super();
  71                 LOG.trace("Start DomainLogicalPortResourceValidator()");
  72                 setValidator(new DomainLogicalPortResourceValidator(this));
  73                 LOG.trace("Complete DomainLogicalPortResourceValidator()");
  74         }
  75
  76         /**
  77          * Implementation of get method of DomainLogicalPort API
  78          *
  79          * @param requestBody
  80          *            the request Json object
  81          *
  82          * @return Error code
  83          * @throws VtnServiceException
  84          */
  85         @Override
  86         public int get(JsonObject queryString) throws VtnServiceException {
  87                 LOG.trace("Start DomainLogicalPortResource#get()");
  88                 ClientSession session = null;
  89                 JsonObject memberLastIndex = null;
  90                 IpcRequestProcessor requestProcessor = null;
  91                 IpcDataUnit[] resp = null;
  92                 int status = ClientSession.RESP_FATAL;
  93                 try {
  94                         LOG.debug("Start Ipc framework call");
  95                         // Get session from connection pool of UPLL server connections
  96                         session = getConnPool().getSession(UncUPPLEnums.UPPL_IPC_CHN_NAME,
  97                                         UncUPPLEnums.UPPL_IPC_SVC_NAME,
  98                                         UncUPPLEnums.ServiceID.UPPL_SVC_READREQ.ordinal(),
  99                                         getExceptionHandler());
 100                         LOG.debug("Session created successfully");
 101                         final IpcPhysicalResponseFactory responseGenerator = new IpcPhysicalResponseFactory();
 102                         String dataType = VtnServiceJsonConsts.STATE;
 103                         if (queryString.has(VtnServiceJsonConsts.TARGETDB)) {
 104                                 dataType = queryString.get(VtnServiceJsonConsts.TARGETDB)
 105                                                 .getAsString();
 106                         }
 107                         requestProcessor = new IpcRequestProcessor(session, getSessionID(),
 108                                         getConfigID(), getExceptionHandler());
 109                         requestProcessor.createIpcRequestPacket(
 110                                         IpcRequestPacketEnum.KT_LOGICAL_PORT_GET, queryString,
 111                                         getUriParameters());
 112                         LOG.debug("Request packet for 1st call created successfully");
 113                         status = requestProcessor.processIpcRequest();
 114                         LOG.debug("Request packet for 1st call processed with status:"+status);
 115                         if (status == ClientSession.RESP_FATAL) {
 116                                 throw new VtnServiceException(
 117                                                 Thread.currentThread().getStackTrace()[1]
 118                                                                 .getClassName()
 119                                                                 + VtnServiceConsts.HYPHEN
 120                                                                 + Thread.currentThread().getStackTrace()[1]
 121                                                                                 .getMethodName(),
 122                                                 UncJavaAPIErrorCode.IPC_SERVER_ERROR.getErrorCode(),
 123                                                 UncJavaAPIErrorCode.IPC_SERVER_ERROR.getErrorMessage());
 124                         }
 125                         JsonObject root = responseGenerator.getDomainLogicalPortResponse(
 126                                         requestProcessor.getIpcResponsePacket(), queryString,
 127                                         VtnServiceJsonConsts.SHOW);
 128                         JsonArray memberArray = null;
 129                         JsonArray memberArrayNew = null;
 130                         if (VtnServiceJsonConsts.STATE.equalsIgnoreCase(dataType) && !(root.get(VtnServiceJsonConsts.LOGICALPORT) instanceof JsonNull)) {
 131                                 requestProcessor.setServiceInfo(UncUPPLEnums.UPPL_IPC_SVC_NAME,
 132                                                 UncUPPLEnums.ServiceID.UPPL_SVC_READREQ.ordinal());
 133                                 requestProcessor.createIpcRequestPacket(
 134                                                 IpcRequestPacketEnum.KT_LOGICAL_PORT_MEMBER_GET,
 135                                                 queryString, getUriParametersMember(root));
 136                                 requestProcessor
 137                                                 .getRequestPacket()
 138                                                 .setOperation(
 139                                                                 IpcDataUnitWrapper
 140                                                                                 .setIpcUint32Value(UncOperationEnum.UNC_OP_READ_SIBLING_BEGIN
 141                                                                                                 .ordinal()));
 142                                 LOG.debug("Request packet  2nd call created successfully");
 143                                 status = requestProcessor.processIpcRequest();
 144                                 LOG.debug("Request packet 2nd call processed with status:"+status);
 145                                 if (status == ClientSession.RESP_FATAL) {
 146                                         throw new VtnServiceException(
 147                                                         Thread.currentThread().getStackTrace()[1]
 148                                                                         .getClassName()
 149                                                                         + VtnServiceConsts.HYPHEN
 150                                                                         + Thread.currentThread().getStackTrace()[1]
 151                                                                                         .getMethodName(),
 152                                                         UncJavaAPIErrorCode.IPC_SERVER_ERROR.getErrorCode(),
 153                                                         UncJavaAPIErrorCode.IPC_SERVER_ERROR
 154                                                                         .getErrorMessage());
 155                                 }
 156                                 memberArray = responseGenerator
 157                                                 .getDomainLogicalPortMemberResponse(requestProcessor
 158                                                                 .getIpcResponsePacket());
 159                                 int memberIndex = 0;
 160                                 VtnServiceConfiguration configuration = VtnServiceInitManager
 161                                                 .getConfigurationMap();
 162                                 int max_rep_count = Integer.parseInt(configuration
 163                                                 .getConfigValue(VtnServiceConsts.MAX_REP_DEFAULT));
 164                                 memberIndex = memberArray.size();
 165                                 if (memberArray.size() >= max_rep_count) {
 166                                         while (memberIndex >= max_rep_count) {
 167                                                 memberIndex = memberArray.size();
 168                                                 memberLastIndex = (JsonObject) memberArray
 169                                                                 .get(memberIndex - 1);
 170                                                 requestProcessor
 171                                                                 .createIpcRequestPacket(
 172                                                                                 IpcRequestPacketEnum.KT_LOGICAL_PORT_MEMBER_GET,
 173                                                                                 queryString,
 174                                                                                 getUriParametersMemberGreaterThanDefault(
 175                                                                                                 root, memberLastIndex));
 176                                                 requestProcessor
 177                                                                 .getRequestPacket()
 178                                                                 .setOperation(
 179                                                                                 IpcDataUnitWrapper
 180                                                                                                 .setIpcUint32Value(UncOperationEnum.UNC_OP_READ_SIBLING
 181                                                                                                                 .ordinal()));
 182                                                 status = requestProcessor.processIpcRequest();
 183                                                 if (status == ClientSession.RESP_FATAL) {
 184                                                         throw new VtnServiceException(
 185                                                                         Thread.currentThread().getStackTrace()[1]
 186                                                                                         .getClassName()
 187                                                                                         + VtnServiceConsts.HYPHEN
 188                                                                                         + Thread.currentThread()
 189                                                                                                         .getStackTrace()[1]
 190                                                                                                         .getMethodName(),
 191                                                                         UncJavaAPIErrorCode.IPC_SERVER_ERROR
 192                                                                                         .getErrorCode(),
 193                                                                         UncJavaAPIErrorCode.IPC_SERVER_ERROR
 194                                                                                         .getErrorMessage());
 195                                                 }
 196                                                 resp = requestProcessor.getIpcResponsePacket();
 197                                                 memberArrayNew = responseGenerator
 198                                                                 .getDomainLogicalPortMemberResponse(resp);
 199                                                 if (null != memberArrayNew
 200                                                                 && !memberArrayNew.isJsonNull()) {
 201                                                         memberArray.getAsJsonArray().addAll(memberArrayNew);
 202                                                 } else {
 203                                                         break;
 204                                                 }
 205                                                 memberIndex++;
 206                                         }
 207                                 }
 208                                 if (null != memberArray) {
 209                                         root.get(VtnServiceJsonConsts.LOGICALPORT)
 210                                                         .getAsJsonObject()
 211                                                         .add(VtnServiceJsonConsts.MEMBER_PORTS, memberArray);
 212                                 }
 213                         }
 214                         setInfo(root);
 215                         LOG.debug("Response object created successfully");
 216                         LOG.debug("Complete Ipc framework call");
 217                 } catch (final VtnServiceException e) {
 218                         getExceptionHandler()
 219                                         .raise(Thread.currentThread().getStackTrace()[1]
 220                                                         .getClassName()
 221                                                         + VtnServiceConsts.HYPHEN
 222                                                         + Thread.currentThread().getStackTrace()[1]
 223                                                                         .getMethodName(),
 224                                                         UncJavaAPIErrorCode.IPC_SERVER_ERROR.getErrorCode(),
 225                                                         UncJavaAPIErrorCode.IPC_SERVER_ERROR
 226                                                                         .getErrorMessage(), e);
 227                         throw e;
 228                 } finally {
 229                         /*
 230                          * Handle the case, where error info required to be set for failures
 231                          * If error cause can be found from UPLL layer then, set the error
 232                          * according to error code Otherwise set the error as IPC server
 233                          * error
 234                          */
 235                         if (status == ClientSession.RESP_FATAL) {
 236                                 if (null != requestProcessor.getErrorJson()) {
 237                                         setInfo(requestProcessor.getErrorJson());
 238                                 } else {
 239                                         createErrorInfo(UncCommonEnum.UncResultCode.UNC_SERVER_ERROR
 240                                                         .getValue());
 241                                 }
 242                                 status = UncResultCode.UNC_SERVER_ERROR.getValue();
 243                         }
 244                         // destroy the session in all cases
 245                         getConnPool().destroySession(session);
 246                 }
 247                 LOG.trace("Completed DomainLogicalPortResource#get()");
 248                 return status;
 249         }
 250
 251         /**
 252          * Getter for controller id
 253          *
 254          * @return
 255          */
 256         public String getControllerId() {
 257                 return controllerId;
 258         }
 259
 260         /**
 261          * Getter for domain id
 262          *
 263          * @return
 264          */
 265         public String getDomainId() {
 266                 return domainId;
 267         }
 268
 269         /**
 270          * Getter for port id
 271          *
 272          * @return
 273          */
 274         public String getLogicalPortId() {
 275                 return logicalPortId;
 276         }
 277
 278         /**
 279          * Add URI parameters to list
 280          *
 281          * @return parameter list
 282          */
 283         private List<String> getUriParameters() {
 284                 LOG.trace("Starts DomainLogicalPortResource#getUriParameters()");
 285                 final List<String> uriParameters = new ArrayList<String>();
 286                 uriParameters.add(controllerId);
 287                 uriParameters.add(domainId);
 288                 uriParameters.add(logicalPortId);
 289                 LOG.trace("Completed DomainLogicalPortResource#getUriParameters()");
 290                 return uriParameters;
 291         }
 292
 293         /**
 294          * Add URI Member parameters to list
 295          *
 296          * @return parameter list
 297          */
 298         private List<String> getUriParametersMember(JsonObject root) {
 299                 LOG.trace("Starts DomainLogicalPortResource#getUriParametersMember()");
 300                 final List<String> uriParameters = new ArrayList<String>();
 301                 uriParameters.add(controllerId);
 302                 uriParameters.add(domainId);
 303                 uriParameters.add(logicalPortId);
 304                 // uriParameters.add(((JsonObject)root.get(VtnServiceJsonConsts.LOGICALPORT)).get(VtnServiceJsonConsts.SWITCHID).getAsString());
 305                 // uriParameters.add(((JsonObject)root.get(VtnServiceJsonConsts.LOGICALPORT)).get(VtnServiceJsonConsts.PORTNAME).getAsString());
 306                 LOG.trace("Completed DomainLogicalPortResource#getUriParametersMember()");
 307                 return uriParameters;
 308         }
 309
 310         private List<String> getUriParametersMemberGreaterThanDefault(
 311                         JsonObject logicalPortsJson, final JsonObject memberLastIndex) {
 312                 LOG.trace("Starts DomainLogicalPortResource#getUriParametersMemberGreaterThanDefault()");
 313                 final List<String> uriParameters = new ArrayList<String>();
 314                 uriParameters.add(controllerId);
 315                 uriParameters.add(domainId);
 316                 uriParameters.add(logicalPortsJson.get(
 317                                 VtnServiceJsonConsts.LOGICAL_PORT_ID).getAsString());
 318                 if (memberLastIndex.has(VtnServiceJsonConsts.SWITCHID)) {
 319                         uriParameters.add(memberLastIndex
 320                                         .get(VtnServiceJsonConsts.SWITCHID).getAsString());
 321                 } else {
 322                         uriParameters.add(VtnServiceJsonConsts.SWITCHID_NOT_FOUND);
 323                 }
 324                 if (memberLastIndex.has(VtnServiceJsonConsts.PORTNAME)) {
 325                         uriParameters.add(memberLastIndex
 326                                         .get(VtnServiceJsonConsts.PORTNAME).getAsString());
 327                 } else {
 328                         uriParameters.add(VtnServiceJsonConsts.PORTID_NOT_FOUND);
 329                 }
 330                 LOG.trace("Completed DomainLogicalPortResource#getUriParametersMemberGreaterThanDefault()");
 331                 return uriParameters;
 332         }
 333 }