Exemplo n.º 1
0
  private boolean handleProtectionChangeEvent(
      AbstractNe ne, Map<String, String> values, CHANGE oper) {
    try {
      String workingAid = values.get("AID1");
      String protectionAid = values.get("AID2");
      NetworkElement omeNe = (NetworkElement) ne;

      // Set up the data for event
      HashMap<String, String> eventData = new HashMap<String, String>();
      eventData.put("workingAid", workingAid);
      eventData.put("proctectingAid", protectionAid);
      eventData.put("operation", oper.asString());
      dbchgEvent.addDataElement(eventData);
      getParameters().put(AbstractCommandlet.RESULT_KEY, dbchgEvent);
      // String command = values.get("COMMAND");
      if (oper == CHANGE.DELETE) {
        // don't handle any thing, for now
        log.debug("Got the DLT-FFP report for " + workingAid + ":" + protectionAid);

        DbUtility.INSTANCE.updateOrAddFacilityAttr(
            ne, workingAid, AbstractFacilityXml.PROTECTIONSCHEME_ATTR, "N/A");
        DbUtility.INSTANCE.updateOrAddFacilityAttr(
            ne, protectionAid, AbstractFacilityXml.PROTECTIONSCHEME_ATTR, "N/A");
        omeNe.getProtectionAid().remove(workingAid);
        omeNe.getProtectionAid().remove(protectionAid);
        eventData.put(AbstractFacilityXml.PROTECTIONSCHEME_ATTR, "N/A");
        return true;
      }
      log.debug("Got the ENT-FFP report for " + workingAid + ":" + protectionAid);
      String[] aidMap = workingAid.split("-");
      Map<String, String> paramList = new HashMap<String, String>();
      paramList.put(ObjectElement.OPERATION_KEY, "RTRV-FFP-" + aidMap[0]);
      paramList.put("WRKGAID", aidMap[0] + "-1-ALL");

      List<Map<String, String>> result = omeNe.getTl1Session().sendToNE(paramList);
      if (result != null) {
        Iterator<Map<String, String>> ir = result.iterator();
        while (ir.hasNext()) {
          Map<String, String> aResult = ir.next();
          String protectionScheme = aResult.get("PS");
          omeNe.getProtectionAid().add(workingAid);
          omeNe.getProtectionAid().add(protectionAid);

          DbUtility.INSTANCE.updateOrAddFacilityAttr(
              ne, workingAid, AbstractFacilityXml.PROTECTIONSCHEME_ATTR, protectionScheme);
          DbUtility.INSTANCE.updateOrAddFacilityAttr(
              ne, protectionAid, AbstractFacilityXml.PROTECTIONSCHEME_ATTR, protectionScheme);
          eventData.put(AbstractFacilityXml.PROTECTIONSCHEME_ATTR, protectionScheme);
        }
        return true;
      }
    } catch (Exception e) {
      log.error("Failed to handle FFP event", e);
    }
    return false;
  }
Exemplo n.º 2
0
  @Override
  public boolean start() throws Exception {
    /*
     * "DBCHGSEQ=1038,DATE=05-03-30,TIME=20-45-53,USERID=ADMIN,SOURCE=1,
     * PRIORITY=GEN_TL1_CMD:ENT-CRS-STS1:STS1-1-9-1-8,STS1-1-10-1-8::
     * CKTID=\"Performance Testing 8\":"
     */
    AbstractNe ne = (AbstractNe) getParameters().get(NePoxyDefinitionsParser.NETWORKELEMENT_KEY);
    ne.upDateLocalInfo();
    dbchgEvent = new Tl1XmlDbChangeEvent(ne);
    TL1AlarmEvent anEvent =
        (TL1AlarmEvent) getParameters().get(AbstractNetworkElement.EVENTRECV_KEY);
    Map<String, String> values = anEvent.getPayloads().get(0);
    // dbchgEvent.setReportType(anEvent.getCommandCode());

    log.debug("Process DBCHG event: " + values);
    dbchgEvent.setOccurrentDate(values.get("DATE"));
    dbchgEvent.setOccurrentTime(values.get("TIME"));

    String neId = ne.getNeId();
    dbchgEvent.setEventId(neId + "_" + values.get("DBCHGSEQ"));
    dbchgEvent.setOwnerId(ne.getTerminalId());
    String command = values.get("COMMAND");
    // String cktid = values.get("CKTID");
    dbchgEvent.updateDescription(values.get("PRIOR"));
    // dbchgEvent.setReportType(command);

    boolean result = false;
    if (command.indexOf("ENT-") >= 0 || command.indexOf("DLT-") >= 0) {
      if (command.indexOf("ENT-") >= 0) {
        operation = CHANGE.ADD;
      } else {
        operation = CHANGE.DELETE;
      }

      if (command.indexOf("-CRS-") >= 0) {
        dbchgEvent.setReportType("connection");
        result = handleConnectionEvent(ne, values, dbchgEvent);
      } else if (command.indexOf("-OC") >= 0
          || command.indexOf("-WAN") >= 0
          || command.indexOf("-ETH") >= 0) {
        dbchgEvent.setReportType("facility");
        result = handleStateChangeEvent(ne, values, operation);
      } else if (command.indexOf("-BLSRMAP") >= 0) {
        dbchgEvent.setReportType("facility");
        result = handleBlsrChangeEvent(ne, values, operation);
      } else if (command.indexOf("-FFP-") >= 0) {
        dbchgEvent.setReportType("facility");
        result = handleProtectionChangeEvent(ne, values, operation);
      }
    } else if (command.indexOf("-TNE") >= 0) {
      /*
       * Provisioned Tunnel Endpoints operations ignored, this statement stops
       * us entering the next bloc and thinking we are dealing with ETH or WAN
       * changes
       */

    } else if (command.indexOf("STCHG-") >= 0
        || command.indexOf("ED-") >= 0
        || command.indexOf("RST-") >= 0
        || command.indexOf("RMV-") >= 0) {
      /*
       * for the ED-ETH, ED-WAN, ..., we can process the event based on the data
       * included in the report without going back to the NE for the changed
       * attributes, but we perform a complete retrieval anyway, just in case...
       */
      dbchgEvent.setReportType("facility");
      operation = CHANGE.MODIFY;
      result = handleStateChangeEvent(ne, values, operation);
    }

    return result;
  }
Exemplo n.º 3
0
  private boolean updateFacilityAttribute(
      AbstractNe ne, Map<String, String> aResult, String aid, CHANGE oper) throws Exception {
    /*
     * TODO: Much of the logic here is a duplicate of what has to be done on
     * retrievals, in GetAllEthWanFacility. There should be one copy of this
     * processing code called from both retrievals and dbchg events.
     */

    Map<String, String> facilityMap = null;
    int layer = 1;
    String layerStr;
    Element newFacElem = null;
    String changedFac = null;
    Map<String, String> currentNeAttrValue = new HashMap<String, String>();

    if (Facility.isWan(aid)) {
      // If the WAN is a standalone, it is / will be explicitly stored in the
      // db.
      // If it's part of an EthWan EPL port, it'll be the ETH in our db.
      // Therefore, do the lookup based on shelf/slot/port

      // Note: For Eth/Wan EPL-like facility pairs, we rely on the ETH being
      // processed
      // ahead of the Wan.
      boolean wanIntoEthMapping = false;
      Element changedElement = null;
      String[] aidArr = aid.split("-");
      changedFac = DbUtility.INSTANCE.retrieveAFacility(ne, aidArr[1], aidArr[2], aidArr[3]);

      if (changedFac != null) {
        changedElement = DbOpsHelper.xmlToElement(changedFac);
        String type = changedElement.getAttributeValue(FacilityConstants.TYPE_ATTR);
        if (Facility.isEth(type)) {
          wanIntoEthMapping = true;
        }
      }

      if (wanIntoEthMapping) {
        // A WAN that belongs to an Eth/Wan EPL port
        // Flip input "WAN" aid to found facility "ETHxxx" aid
        aid = changedElement.getAttributeValue(AbstractFacilityXml.AID_ATTR);
        layer = 2;
        layerStr = AbstractFacilityXml.LAYER2_ELEMENT;
        newFacElem = new Element(layerStr);

        facilityMap = OmeFacilityXML.wanToEthEPLNeToXmlMapping;

        // DRAC FLAG: to indicate this ETH is actually a WAN-backed ETH (see
        // GetAllEthWanFacility)
        newFacElem.setAttribute(FacilityConstants.IS_EPL, "true");
        currentNeAttrValue.put(FacilityConstants.IS_EPL, "true");
      } else {
        // Standalone WAN
        // WAN as Layer2 selectable UNI
        layer = 2;
        layerStr = AbstractFacilityXml.LAYER2_ELEMENT;
        newFacElem = new Element(layerStr);

        facilityMap = OmeFacilityXML.wanNeToXmlMapping;
      }
    } else if (Facility.isEth(aid)) {
      layer = 2;
      layerStr = AbstractFacilityXml.LAYER2_ELEMENT;
      newFacElem = new Element(layerStr);

      facilityMap = OmeFacilityXML.ethNeToXmlMapping;

      // Nov.1, 2010
      // At the time of writing, the OME R7 load was not emitting a dbchange
      // report
      // for FE (ETH100) in such a way that the primary state could be parsed.
      // The ETH100 would only appear on toggling association (thereby learning
      // of
      // of the ETH100 via retrievals.
      // TEMPORARY FIX: assume worst case 'OOS'
      if (aid.startsWith("ETH100") && oper == CHANGE.ADD) {
        newFacElem.setAttribute(FacilityConstants.PRISTATE_ATTR, "OOS");
      }
    } else {
      layer = 1;
      layerStr = AbstractFacilityXml.LAYER1_ELEMENT;
      newFacElem = new Element(layerStr);

      facilityMap = OmeFacilityXML.commonNeToXmlMapping;
    }

    // DRAC FLAG: for L2SS-based facilities
    String[] aidArr = aid.split("-");
    if (ne.slotIsL2SS(aidArr[1], aidArr[2])) {
      newFacElem.setAttribute(FacilityConstants.IS_L2SS_FACILITY, "true");
      currentNeAttrValue.put(FacilityConstants.IS_L2SS_FACILITY, "true");
    }

    // Build the list of XML attributes based on the NE key/value.
    Iterator<String> keyIr = facilityMap.keySet().iterator();
    while (keyIr.hasNext()) {
      String neKey = keyIr.next();
      String xmlKey = facilityMap.get(neKey);
      String aValue = aResult.get(neKey);
      if (aValue != null) {
        if (aid.indexOf("ETH10G") >= 0 && xmlKey.equals(AbstractFacilityXml.SPEED_ATTR)) {
          // Only one value is reported: always 10G. Normalize to Mb/s ...
          aValue = "10000";
        }

        currentNeAttrValue.put(xmlKey, aValue);
        newFacElem.setAttribute(xmlKey, aValue);
      }
    }

    if (changedFac == null) {
      changedFac = DbUtility.INSTANCE.retrieveAFacility(ne, aid);
    }

    XMLOutputter outXml = new XMLOutputter(Format.getCompactFormat());

    if (changedFac == null) {
      // Create new entry and setup the data for the event as well
      HashMap<String, String> eventData = new HashMap<String, String>();
      eventData.put(AbstractFacilityXml.AID_ATTR, aid);
      eventData.put("operation", CHANGE.ADD.asString());
      eventData.put(AbstractFacilityXml.ID_ATTR, Integer.toString(layer));

      newFacElem.setAttribute(AbstractFacilityXml.VALID_ATTR, "true");
      newFacElem.setAttribute(AbstractFacilityXml.ID_ATTR, Integer.toString(layer));
      newFacElem.setAttribute(AbstractFacilityXml.AID_ATTR, aid);

      List<Attribute> staticAttr = OmeFacilityXML.getStaticAttributes();
      for (int i = 0; i < staticAttr.size(); i++) {
        Attribute anAttr = staticAttr.get(i);
        if (newFacElem.getAttributeValue(anAttr.getName()) == null) {
          newFacElem.setAttribute(anAttr.getName(), anAttr.getValue());
        }
        eventData.put(anAttr.getName(), anAttr.getValue());
      }
      String[] aidMap = aid.split("-");
      eventData.put(AbstractFacilityXml.PORT_ATTR, aidMap[3]);
      eventData.put(AbstractFacilityXml.SHELF_ATTR, aidMap[1]);
      eventData.put(AbstractFacilityXml.SLOT_ATTR, aidMap[2]);
      eventData.put(AbstractFacilityXml.TYPE_ATTR, aidMap[0]);

      newFacElem.setAttribute(AbstractFacilityXml.PORT_ATTR, aidMap[3]);
      newFacElem.setAttribute(AbstractFacilityXml.SHELF_ATTR, aidMap[1]);
      newFacElem.setAttribute(AbstractFacilityXml.SLOT_ATTR, aidMap[2]);
      newFacElem.setAttribute(AbstractFacilityXml.TYPE_ATTR, aidMap[0]);

      // PREPARE THE EVENT FOR LPCP_PORT
      dbchgEvent.addDataElement(eventData);
      dbchgEvent.addDataElement(currentNeAttrValue);

      String newFacStr = outXml.outputString(newFacElem);

      if (oper == CHANGE.ADD) {
        log.debug("Create new Facility: " + newFacStr);
        DbUtility.INSTANCE.addNewFacility(ne, newFacStr);
      }
    } else {
      OmeFacilityXML changedFacXML = new OmeFacilityXML(changedFac);
      Map<String, String> updateList = changedFacXML.updateFacilityAttr(aid, currentNeAttrValue);
      if (updateList != null || oper != CHANGE.MODIFY) {
        // If there are no changes and the operation is ADD or DELETE, then
        // we still want to update the Valid field accordingly
        if (updateList == null) {
          updateList = new HashMap<String, String>();
        }
        if (oper == CHANGE.ADD) {
          updateList.put(AbstractFacilityXml.VALID_ATTR, "true");
        } else if (oper == CHANGE.DELETE) {
          updateList.put(AbstractFacilityXml.VALID_ATTR, "false");
        }

        updateList.put(AbstractFacilityXml.AID_ATTR, aid);
        updateList.put("operation", oper.asString());

        dbchgEvent.addDataElement(updateList);
        //

        // DbUtility.INSTANCE.updateAFacility(ne, updateList, aid);
        // Add missing attributes here. This will be the case when an
        // an Eth/Wan pair enrol; when the Wan enrols, its attributes of
        // interest will be added to its associated Eth:

        boolean addNewAttributes = true;
        DbUtility.INSTANCE.updateAFacility(ne, updateList, aid, addNewAttributes);
      } else {

        return false;
      }
    }
    return true;
  }
Exemplo n.º 4
0
  private boolean handleConnectionEvent(
      AbstractNe ne, Map<String, String> values, Tl1XmlDbChangeEvent dbchgEvent) {
    Map<String, String> data = new HashMap<String, String>();
    String neId = ne.getNeId();
    String command = values.get("COMMAND");
    String cktid = values.get("CKTID");
    String fromAid = values.get("AID1"); // STS3C-1-1-1-1
    String toAid = values.get("AID2"); // STS3C-1-12-1-1
    String swmateAid = null;

    try {
      /*
       * Notice that, in deleting case, the CKTID is null, so we have to compare
       * the AIDs in the database. The AID coming from OME doesn't contain the
       * type of facility (ie. STS1-1-4-1-2) so extra database querying has to
       * be done.
       */

      // Notify the internal utility that keeps track of all Xconnections
      // being created, not deleted
      if (command.startsWith("ENT")) {
        CheckAllComplete.INSTANCE.iAmDone(cktid);
      }

      // SOURCE
      String[] fromAidArr = fromAid.split("-");
      String fromShelf = fromAidArr[1];
      String fromSlot = fromAidArr[2];
      String fromPort = fromAidArr[3];
      @SuppressWarnings("unused")
      boolean fromSideIsL2SS = ne.slotIsL2SS(fromShelf, fromSlot);
      String fromFacilityRecord =
          DbUtility.INSTANCE.retrieveAFacility(ne, fromShelf, fromSlot, fromPort);
      int startTypeIndex = fromFacilityRecord.indexOf("type=") + 6;
      int endTypeIndex = fromFacilityRecord.indexOf('"', startTypeIndex);
      String fromFacilityType = fromFacilityRecord.substring(startTypeIndex, endTypeIndex);
      StringBuilder tempBuff = new StringBuilder(fromFacilityType);
      for (int i = 1; i < fromAidArr.length; i++) {
        tempBuff.append("-" + fromAidArr[i]);
      }
      fromAid = tempBuff.toString();

      // Rate
      getParameters().put("replaceRate", fromAidArr[0]);
      data.put(NetworkElementConnectionCols.RATE, fromAidArr[0]);

      // TARGET
      String[] toAidArr = toAid.split("-");
      String toShelf = toAidArr[1];
      String toSlot = toAidArr[2];
      String toPort = toAidArr[3];
      @SuppressWarnings("unused")
      boolean toSideIsL2SS = ne.slotIsL2SS(toAidArr[1], toAidArr[2]);
      String toFacilityRecord = DbUtility.INSTANCE.retrieveAFacility(ne, toShelf, toSlot, toPort);
      startTypeIndex = toFacilityRecord.indexOf("type=") + 6;
      endTypeIndex = toFacilityRecord.indexOf('"', startTypeIndex);
      String toFacilityType = toFacilityRecord.substring(startTypeIndex, endTypeIndex);
      tempBuff = new StringBuilder(toFacilityType);
      for (int i = 1; i < toAidArr.length; i++) {
        tempBuff.append("-" + toAidArr[i]);
      }
      toAid = tempBuff.toString();

      // Validation of the case
      String existConnection = DbUtility.INSTANCE.retrieveAXConnect(ne, fromAid, toAid);
      if (existConnection != null) {
        if (command.startsWith("ENT")) {
          log.error(ne.getNeName() + ": connection " + fromAid + ":" + toAid + " already exists");
          return false;
        }
      } else if (!command.startsWith("ENT")) {
        log.warn(ne.getNeName() + ": connection " + fromAid + ":" + toAid + " doesn't exist");
        log.debug("Trying the switched values: " + toAid + " to" + fromAid);
        existConnection = DbUtility.INSTANCE.retrieveAXConnect(ne, toAid, fromAid);
        if (existConnection == null) {
          log.error(ne.getNeName() + ": connection " + toAid + ":" + fromAid + " doesn't exist");
          return false;
        }
        String temp = fromAid;
        fromAid = toAid;
        toAid = temp;
      }

      if (cktid == null) {
        cktid = "N/A";
      }

      // SWMATE
      String swMate = null;
      Object tempSwmate = values.get("KEYWORDPARAMS");
      if (tempSwmate != null) {
        String[] keyWords = ((String) tempSwmate).split(",");
        for (String keyWord : keyWords) {
          if (keyWord.indexOf("SWMATE") >= 0) {
            swMate = keyWord.split("=")[1];
            break;
          }
        }
      }

      String[] swmateAidArr = null;
      String swmateFacilityRecord = null;
      String swmateShelf = null;
      String swmateSlot = null;
      String swmatePort = null;
      String swmateFacilityType = null;
      if (swMate != null && swMate.length() > 0) {
        swmateAidArr = swMate.split("-");
        swmateShelf = swmateAidArr[1];
        swmateSlot = swmateAidArr[2];
        swmatePort = swmateAidArr[3];
        swmateFacilityRecord =
            DbUtility.INSTANCE.retrieveAFacility(ne, swmateShelf, swmateSlot, swmatePort);
        startTypeIndex = swmateFacilityRecord.indexOf("type=") + 6;
        endTypeIndex = swmateFacilityRecord.indexOf('"', startTypeIndex);
        swmateFacilityType = swmateFacilityRecord.substring(startTypeIndex, endTypeIndex);
        tempBuff = new StringBuilder(swmateFacilityType);
        for (int i = 1; i < swmateAidArr.length; i++) {
          tempBuff.append("-" + swmateAidArr[i]);
        }
        swmateAid = tempBuff.toString();
      }

      log.debug("Handling DRAC's connection event CKTID: " + cktid);

      getParameters().put("replaceSourceAddress", neId);
      getParameters().put("replaceTargetAddress", neId);
      getParameters().put("replaceId", cktid);
      getParameters().put("replaceType", values.get("POS1"));
      getParameters().put("replaceCommitted", "true");

      data.put(NetworkElementConnectionCols.ID, cktid);

      data.put(NetworkElementConnectionCols.SOURCEAID, fromAid);
      getParameters().put("replaceSourceAid", fromAid);

      data.put(NetworkElementConnectionCols.TARGETAID, toAid);
      getParameters().put("replaceTargetAid", toAid);

      data.put(NetworkElementConnectionCols.SWMATEAID, swmateAid);
      getParameters().put("replaceSwmate", swmateAid);

      // Update the database and re-use the "parameters"
      if (command.startsWith("ENT")) {
        data.put(NetworkElementEventXML.OPERATION_ATTR, OperationType.OPERATION_ADD.toString());
        DbUtility.INSTANCE.addOneXConnect(ne, getParameters());
      } else {
        data.put(NetworkElementEventXML.OPERATION_ATTR, OperationType.OPERATION_DELETE.toString());

        ByteArrayInputStream aByteStream = new ByteArrayInputStream(existConnection.getBytes());
        SAXBuilder builder = new SAXBuilder();
        Document aDoc = builder.build(aByteStream);
        Element root = aDoc.getRootElement();
        data.put(NetworkElementConnectionCols.ID, root.getAttributeValue("id"));

        DbUtility.INSTANCE.deleteXConnect(ne, fromAid, toAid);
      }
      dbchgEvent.addDataElement(data);

      // *** FOR an Eth/Wan EPL port ***
      //
      // The act of cross-connecting can change some of the WAN attributes, such
      // as provUnits,
      // state, and most importantly, the RATE (e.g. for WAN port pairs,
      // connecting to one
      // port at STS1 requires that the other take only STS1 ... same for
      // STS3C).
      //
      // So, with the connection provisioned, check for db changes on the WAN
      // (...the NE doesn't emit a dbchange report?!)

      // Ignoring L2SS-based WAN facilities for state changes

      Element fromElement = DbOpsHelper.xmlToElement(fromFacilityRecord);
      String eplFlag = fromElement.getAttributeValue(FacilityConstants.IS_EPL);
      if (eplFlag != null && Boolean.parseBoolean(eplFlag)) {
        // The found fromFacilityRecord is an EthXXX/Wan EPL port
        checkForEplWanDbChange(
            ne,
            Tl1CommandCode.RTRV_WAN,
            FacilityConstants.WAN,
            fromFacilityType,
            fromShelf,
            fromSlot,
            fromPort);
      }

      Element toElement = DbOpsHelper.xmlToElement(toFacilityRecord);
      eplFlag = toElement.getAttributeValue(FacilityConstants.IS_EPL);
      if (eplFlag != null && Boolean.parseBoolean(eplFlag)) {
        // The found toFacilityRecord is an EthXXX/Wan EPL port
        tempBuff = new StringBuilder(FacilityConstants.WAN);
        for (int i = 1; i < toAidArr.length; i++) {
          tempBuff.append("-" + toAidArr[i]);
        }
        // String wanAid = tempBuff.toString();

        checkForEplWanDbChange(
            ne,
            Tl1CommandCode.RTRV_WAN,
            FacilityConstants.WAN,
            toFacilityType,
            toShelf,
            toSlot,
            toPort);
      }

      if (swmateFacilityRecord != null) {
        Element swmateElement = DbOpsHelper.xmlToElement(swmateFacilityRecord);
        eplFlag = swmateElement.getAttributeValue(FacilityConstants.IS_EPL);
        if (eplFlag != null && Boolean.parseBoolean(eplFlag)) {
          // The found swmateFacilityRecord is an EthXXX/Wan EPL port
          tempBuff = new StringBuilder(FacilityConstants.WAN);
          for (int i = 1; i < swmateAidArr.length; i++) {
            tempBuff.append("-" + swmateAidArr[i]);
          }
          // String wanAid = tempBuff.toString();

          checkForEplWanDbChange(
              ne,
              Tl1CommandCode.RTRV_WAN,
              FacilityConstants.WAN,
              swmateFacilityType,
              swmateShelf,
              swmateSlot,
              swmatePort);
        }
      }
    } catch (Exception e) {
      log.error(
          "Failed to handle connection db change event from ne:"
              + ne.getNeId()
              + " values:"
              + values,
          e);
      return false;
    }
    getParameters().put(AbstractCommandlet.RESULT_KEY, dbchgEvent);

    // LPCP_PORT connection event handling only considers OSS connections (i.e.
    // connections whose
    // IDs don't begin with 'DRAC-1'. Connection events for DRAC services is
    // handled
    // elsewhere.
    if (CrossConnection.isDracConnection(cktid)) {
      return false;
    }

    return true;
  }
Exemplo n.º 5
0
  private boolean handleBlsrChangeEvent(AbstractNe ne, Map<String, String> values, CHANGE oper) {
    try {
      String workingAid = values.get("AID1");
      String protectionAid = values.get("AID2");
      NetworkElement omeNe = (NetworkElement) ne;

      // Set up the data for event
      HashMap<String, String> eventData = new HashMap<String, String>();
      eventData.put("workingAid", workingAid);
      eventData.put("proctectingAid", protectionAid);
      eventData.put("operation", oper.asString());
      dbchgEvent.addDataElement(eventData);
      getParameters().put(AbstractCommandlet.RESULT_KEY, dbchgEvent);
      // String command = values.get("COMMAND");
      if (oper == CHANGE.DELETE) {
        // don't handle any thing, for now
        log.debug("Got the DLT-BLSRMAP report for " + workingAid + ":" + protectionAid);

        DbUtility.INSTANCE.updateOrAddFacilityAttr(
            ne, workingAid, AbstractFacilityXml.APSID_ATTR, "N/A");
        DbUtility.INSTANCE.updateOrAddFacilityAttr(
            ne, protectionAid, AbstractFacilityXml.APSID_ATTR, "N/A");
        omeNe.getRingName().remove(workingAid);
        omeNe.getRingName().remove(protectionAid);
        omeNe.setApsId(null);
        eventData.put(AbstractFacilityXml.APSID_ATTR, "N/A");
        return true;
      }

      log.debug("Got the ENT-BLSRMAP report for " + workingAid + ":" + protectionAid);
      Map<String, String> paramList = new HashMap<String, String>();
      paramList.put(ObjectElement.OPERATION_KEY, Tl1CommandCode.RTRV_BLSRMAP.toString());
      paramList.put("WRKGAID", workingAid);
      paramList.put("PROTAID", protectionAid);

      List<Map<String, String>> result = omeNe.getTl1Session().sendToNE(paramList);
      if (result != null) {
        Iterator<Map<String, String>> ir = result.iterator();
        while (ir.hasNext()) {
          Map<String, String> blsrResult = ir.next();
          String ringName = blsrResult.get("LABEL");
          omeNe.getRingName().put(workingAid, ringName);
          omeNe.getRingName().put(protectionAid, ringName);

          // ringMap is expected to have the following format
          // "3:3/0:0/1:1/2:2/3:3"
          try {
            String ringMap = blsrResult.get("RINGMAP");
            log.debug("got ringMap info for " + ringName + " in " + ringMap);

            String apsIdStr = ringMap.split("/")[0].split(":")[0];
            omeNe.setApsId(Integer.valueOf(apsIdStr));

            // update the facility in the database with the apsId.
            DbUtility.INSTANCE.updateOrAddFacilityAttr(
                ne, workingAid, AbstractFacilityXml.APSID_ATTR, apsIdStr);
            DbUtility.INSTANCE.updateOrAddFacilityAttr(
                ne, protectionAid, AbstractFacilityXml.APSID_ATTR, apsIdStr);
            eventData.put(AbstractFacilityXml.APSID_ATTR, apsIdStr);
          } catch (Exception ex) {
            log.error("Fail to obtain the ring information", ex);
          }
        }
        return true;
      }

    } catch (Exception e) {
      log.error("Failed to handle BLSRMAP event", e);
    }
    return false;
  }
Exemplo n.º 6
0
  private void checkForEplWanDbChange(
      AbstractNe ne,
      Tl1CommandCode mod,
      String wanType,
      String ethType,
      String shelf,
      String slot,
      String port) {
    // ethType can vary: ETH, ETH10G, ETH100, etc.

    String wanAid = wanType + "-" + shelf + "-" + slot + "-" + port;
    String ethAid = ethType + "-" + shelf + "-" + slot + "-" + port;

    log.debug("Checking for change in DB due to Connection event: aid: " + wanAid);

    Map<String, String> paramList = new HashMap<String, String>();
    paramList.put(ObjectElement.OPERATION_KEY, mod.toString());
    paramList.put("AID", wanAid);

    try {
      ArrayList<Map<String, String>> temp = new ArrayList<Map<String, String>>();
      temp.add(new HashMap<String, String>());
      List<Map<String, String>> wanResult =
          ((NetworkElement) ne).getTl1Session().sendToNE(paramList);

      if (wanResult != null) {
        Map<String, String> aWanResult = wanResult.get(0);

        String ethEplFac = DbUtility.INSTANCE.retrieveAFacility(ne, shelf, slot, port);
        if (ethEplFac == null) {

          return;
        }
        OmeFacilityXML eplFacXML = new OmeFacilityXML(ethEplFac);

        // Build the list of EPL WAN->ETH*** XML attributes based on the NE
        // key/value.
        Map<String, String> currentNeAttrValue = new HashMap<String, String>();
        Iterator<String> keyIr = OmeFacilityXML.wanToEthEPLNeToXmlMapping.keySet().iterator();
        while (keyIr.hasNext()) {
          String neKey = keyIr.next();
          String xmlKey = OmeFacilityXML.wanToEthEPLNeToXmlMapping.get(neKey);
          String aValue = aWanResult.get(neKey);
          if (aValue != null) {
            currentNeAttrValue.put(xmlKey, aValue);
          }
        }

        Map<String, String> updateList = eplFacXML.updateFacilityAttr(ethAid, currentNeAttrValue);

        if (updateList != null) {
          // TODO: The WAN event from here up to LPCP_PORT should be screened
          // first...
          // to evaluate whether or not the updated attributes are of interest
          // to LPCP_PORT. WAN attributes of interest currently are:
          // - VCAT
          // - Basic Rate (?)

          log.debug("Facility's attr to update in checkForDbChange:" + updateList);
          DbUtility.INSTANCE.updateAFacility(ne, updateList, ethAid);
          updateList.put("operation", "modify");
          updateList.put("aid", ethAid);

          Tl1XmlDbChangeEvent additionalEvent = new Tl1XmlDbChangeEvent(ne);
          additionalEvent.setOccurrentDate(dbchgEvent.getOccurrentDate());
          additionalEvent.setOccurrentTime(dbchgEvent.getOccurrentTime());
          additionalEvent.setEventId(ne.getNeId() + "_" + System.currentTimeMillis());
          additionalEvent.setOwnerId(ne.getTerminalId());
          additionalEvent.setNotificationType("facility");
          additionalEvent.updateDescription("PROXY_GEN");
          additionalEvent.addDataElement(updateList);
          getParameters().put(AbstractCommandlet.ADDITIONALEVENT_KEY, additionalEvent);
        } else {

        }
      } else {
        log.error("Got empty result from querying new state of " + wanAid + " from NE");
      }
    } catch (Exception e) {
      log.error("Failed to perform " + mod + " from " + ne.getNeName(), e);
    }
  }