ems/boco/src/main/java/org/onap/vfc/nfvo/emsdriver/northbound/client/NorthMessageMgr.java

   1 /**
   2  * Copyright 2017 BOCO Corporation.  CMCC Technologies Co., Ltd
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  *     http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16 package org.onap.vfc.nfvo.emsdriver.northbound.client;
  17
  18 import java.text.ParseException;
  19 import java.text.SimpleDateFormat;
  20 import java.util.Date;
  21 import java.util.Map;
  22 import java.util.Properties;
  23
  24 import org.apache.log4j.Level;
  25 import org.onap.vfc.nfvo.emsdriver.commons.constant.Constant;
  26 import org.onap.vfc.nfvo.emsdriver.commons.utils.DriverThread;
  27 import org.onap.vfc.nfvo.emsdriver.configmgr.ConfigurationInterface;
  28 import org.onap.vfc.nfvo.emsdriver.messagemgr.MessageChannel;
  29 import org.onap.vfc.nfvo.emsdriver.messagemgr.MessageChannelFactory;
  30
  31 import com.alibaba.fastjson.JSONObject;
  32
  33 import evel_javalibrary.att.com.AgentMain;
  34 import evel_javalibrary.att.com.EvelFault;
  35 import evel_javalibrary.att.com.EvelFault.EVEL_SEVERITIES;
  36 import evel_javalibrary.att.com.EvelFault.EVEL_SOURCE_TYPES;
  37 import evel_javalibrary.att.com.EvelFault.EVEL_VF_STATUSES;
  38 import evel_javalibrary.att.com.EvelHeader;
  39 import evel_javalibrary.att.com.EvelScalingMeasurement;
  40
  41 public class NorthMessageMgr extends DriverThread{
  42
  43         private MessageChannel alarmChannel = MessageChannelFactory.getMessageChannel(Constant.RESULT_CHANNEL_KEY);
  44         private MessageChannel collectChannel = MessageChannelFactory.getMessageChannel(Constant.COLLECT_CHANNEL_KEY);
  45         private MessageChannel collectResultChannel = MessageChannelFactory.getMessageChannel(Constant.COLLECT_RESULT_CHANNEL_KEY);
  46         private ConfigurationInterface configurationInterface ;
  47
  48         private boolean threadStop = false;
  49         private Level level = Level.DEBUG;
  50
  51         @Override
  52         public void dispose() {
  53                 Properties properties = configurationInterface.getProperties();
  54                 String event_api_url = properties.getProperty("event_api_url");
  55                 String port = properties.getProperty("port");
  56                 String path = properties.getProperty("path");
  57                 String topic = properties.getProperty("topic");
  58                 String username = properties.getProperty("username");
  59                 String password = properties.getProperty("password");
  60                 String levelStr = properties.getProperty("level");
  61                 if("debug".equals(levelStr)){
  62                         level = Level.DEBUG;
  63                 }else{
  64                         level = Level.INFO;
  65                 }
  66
  67                 //login north
  68                 event_api_url = "http://"+event_api_url;
  69                 try{
  70                         AgentMain.evel_initialize(event_api_url, Integer.parseInt(port),
  71                                         path,topic,
  72                                         username,
  73                                         password,
  74                                         level);
  75                         log.info("AgentMain.evel_initialize sucess ");
  76                 } catch( Exception e ){
  77                         log.error("AgentMain.evel_initialize fail ",e);
  78                 }
  79
  80                 new HeatBeatTread().start();
  81                 //
  82                 new AlarmMessageRecv().start();
  83
  84                 new ResultMessageRecv().start();
  85
  86                 new CollectMessageRecv().start();
  87         }
  88
  89
  90         class HeatBeatTread extends Thread{
  91
  92                 public void run() {
  93
  94                         while(!threadStop){
  95
  96                                 try {
  97                                         EvelHeader header  = EvelHeader.evel_new_heartbeat("Hearbeat_EMS","EMS-driver");
  98                             header.evel_nfnamingcode_set("EMS-driver");
  99                             header.evel_nfcnamingcode_set("EMS-driver");
 100                             AgentMain.evel_post_event(header);
 101                             log.debug("HeatBeat send!");
 102                             try {
 103                                 Thread.sleep(60*1000);
 104                             } catch( Exception e ){
 105                                  e.printStackTrace();
 106                             }
 107                                 } catch (Exception e) {
 108                                         log.error("HeatBeatTread exception",e);
 109                                 }
 110                         }
 111                 }
 112         }
 113
 114         class AlarmMessageRecv extends Thread{
 115                 long timeStamp = System.currentTimeMillis();
 116
 117                 public void run() {
 118                         while(!threadStop){
 119
 120                                 try {
 121                                         if(System.currentTimeMillis() - timeStamp > Constant.ONEMINUTE){
 122                                                 timeStamp = System.currentTimeMillis();
 123
 124                                                 log.debug("ALARM_CHANNEL Msg size :"+alarmChannel.size());
 125                                         }
 126
 127                                         Object obj = alarmChannel.poll();
 128                                         if(obj == null){
 129                                                 continue;
 130                                         }
 131                                         if(obj instanceof String){
 132                                                 String result = (String)obj;
 133                                                 JSONObject reagobj = JSONObject.parseObject(result);
 134
 135                                                 EvelFault evelFault = this.resultEvelFault(reagobj);
 136
 137                                                 //send
 138                                                 AgentMain.evel_post_event(evelFault);
 139                                         }else{
 140                                                 log.error("AlarmMessageRecv receive Object = "+obj);
 141                                         }
 142
 143                                 } catch (Exception e) {
 144                                         log.error("AlarmMessageRecv exception",e);
 145                                 }
 146                         }
 147                 }
 148
 149                 private EvelFault resultEvelFault(JSONObject reagobj) {
 150
 151                         String eventName = null;
 152                         EvelHeader.PRIORITIES pri = null;
 153                         EVEL_SEVERITIES severity = null;
 154                         EVEL_VF_STATUSES status = null;
 155                         String alarmStatus = reagobj.getString("alarmStatus");
 156                         String origSeverity = reagobj.getString("origSeverity");
 157                         if("0".equals(alarmStatus)){
 158                                 status = EVEL_VF_STATUSES.EVEL_VF_STATUS_IDLE;
 159                                 eventName = "Fault_"+reagobj.getString("neType")+"_"+reagobj.getString("alarmTitle")+"Cleared";
 160
 161                                 if("1".equals(origSeverity)){
 162                                         severity = EVEL_SEVERITIES.EVEL_SEVERITY_CRITICAL;
 163                                         pri = EvelHeader.PRIORITIES.EVEL_PRIORITY_HIGH;
 164                                 }else if("2".equals(origSeverity)){
 165                                         severity = EVEL_SEVERITIES.EVEL_SEVERITY_MAJOR;
 166                                         pri = EvelHeader.PRIORITIES.EVEL_PRIORITY_MEDIUM;
 167                                 }else if("3".equals(origSeverity)){
 168                                         severity = EVEL_SEVERITIES.EVEL_SEVERITY_MINOR;
 169                                         pri = EvelHeader.PRIORITIES.EVEL_PRIORITY_NORMAL;
 170                                 }else if("4".equals(origSeverity)){
 171                                         severity = EVEL_SEVERITIES.EVEL_SEVERITY_WARNING;
 172                                         pri = EvelHeader.PRIORITIES.EVEL_PRIORITY_LOW;
 173
 174                                 }
 175                         }else{
 176                                 status = EVEL_VF_STATUSES.EVEL_VF_STATUS_ACTIVE;
 177                                 eventName = "Fault_"+reagobj.getString("neType")+"_"+reagobj.getString("alarmTitle");
 178                                 pri = EvelHeader.PRIORITIES.EVEL_PRIORITY_NORMAL;
 179                                 severity = EVEL_SEVERITIES.EVEL_SEVERITY_NORMAL;
 180                         }
 181
 182                         String evnId = reagobj.getString("alarmId");
 183                         String alarmCondition = reagobj.getString("specificProblem");
 184
 185                         String specificProblem = reagobj.getString("specificProblem");
 186
 187                         EvelFault flt  = new EvelFault(eventName, evnId,alarmCondition,
 188                                         specificProblem,pri,severity,
 189                                         EVEL_SOURCE_TYPES.EVEL_SOURCE_VIRTUAL_NETWORK_FUNCTION,
 190                                         status);
 191                          flt.evel_nfcnamingcode_set("");
 192                          flt.evel_nfnamingcode_set("");
 193                          flt.evel_header_type_set("applicationVnf");
 194                          String eventTime = reagobj.getString("eventTime");
 195                          SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
 196                          Date eventTimeD = new Date();
 197                          try {
 198                                 eventTimeD = format.parse(eventTime);
 199                          } catch (ParseException e) {
 200                                 // TODO Auto-generated catch block
 201                                 e.printStackTrace();
 202                          }
 203                          flt.evel_start_epoch_set(eventTimeD.getTime());
 204                          flt.evel_last_epoch_set(eventTimeD.getTime());
 205
 206                          flt.evel_fault_category_set(reagobj.getString("alarmType"));
 207                          flt.evel_fault_interface_set(reagobj.getString("objectName"));
 208                          String neUID = reagobj.getString("neUID");
 209                          flt.evel_reporting_entity_id_set(neUID.substring(0,9));//
 210                          flt.evel_reporting_entity_name_set(neUID.substring(0,9));
 211                          flt.evel_header_set_sourceid(true, reagobj.getString("neName"));
 212                          flt.evel_header_set_source_name(reagobj.getString("objectName"));
 213
 214                          flt.evel_header_set_priority(pri);
 215                          for(String key : reagobj.keySet()){
 216                                  flt.evel_fault_addl_info_add(key, reagobj.getString(key));
 217                          }
 218
 219              return flt;
 220                 }
 221         }
 222
 223         class ResultMessageRecv extends Thread{
 224                 long timeStamp = System.currentTimeMillis();
 225
 226                 public void run() {
 227                         while(!threadStop){
 228
 229                                 try {
 230                                         if(System.currentTimeMillis() - timeStamp > Constant.ONEMINUTE){
 231                                                 timeStamp = System.currentTimeMillis();
 232
 233                                                 log.debug("COLLECT_RESULT_CHANNEL Msg size :"+collectResultChannel.size());
 234                                         }
 235
 236                                         Object obj = collectResultChannel.poll();
 237                                         if(obj == null){
 238                                                 continue;
 239                                         }
 240                                         if(obj instanceof String){
 241                                                 //http
 242                                                 Properties properties = configurationInterface.getProperties();
 243                                                 String msbAddress = properties.getProperty("msbAddress");
 244                                                 String url = properties.getProperty("dataNotifyUrl");
 245                                                 String postUrl = "http://"+msbAddress+url;
 246                                                 HttpClientUtil.doPost(postUrl, (String)obj, Constant.ENCODING_UTF8);
 247                                         }
 248
 249                                 } catch (Exception e) {
 250                                         log.error("ResultMessageRecv exception",e);
 251                                 }
 252                         }
 253                 }
 254         }
 255
 256         class CollectMessageRecv extends Thread{
 257                 long timeStamp = System.currentTimeMillis();
 258
 259                 public void run() {
 260                         while(!threadStop){
 261
 262                                 try {
 263                                         if(System.currentTimeMillis() - timeStamp > Constant.ONEMINUTE){
 264                                                 timeStamp = System.currentTimeMillis();
 265
 266                                                 log.debug("COLLECT_CHANNEL_KEY Msg size :"+collectChannel.size());
 267                                         }
 268
 269                                         Object obj = collectChannel.poll();
 270                                         if(obj == null){
 271                                                 continue;
 272                                         }
 273                                         if(obj instanceof Map){
 274                                                 @SuppressWarnings("unchecked")
 275                                                 Map<String,String> reMap = (Map<String,String>)obj;
 276                                                 EvelScalingMeasurement evelScalingMeasurement = this.resultEvelScalingMeasurement(reMap);
 277
 278                                                 //send
 279                                                 AgentMain.evel_post_event(evelScalingMeasurement);
 280
 281                                         }else{
 282                                                 log.error("CollectMessageRecv receive Object = "+obj);
 283                                         }
 284
 285                                 } catch (Exception e) {
 286                                         log.error("CollectMessageRecv exception",e);
 287                                 }
 288                         }
 289                 }
 290
 291                 private EvelScalingMeasurement resultEvelScalingMeasurement(Map<String,String> reMap) {
 292                         String evname = "Mfvs_"+reMap.get("ElementType")+reMap.get("ObjectType");
 293                         String evid = reMap.get("startTime")+reMap.get("ObjectType")+reMap.get("rmUID");
 294                         int Period = Integer.parseInt(reMap.get("Period")!=null?reMap.get("Period"):"15");
 295                         EvelScalingMeasurement sm  = new EvelScalingMeasurement(Period,evname, evid);
 296
 297                         for(String key : reMap.keySet()){
 298                                 sm.evel_measurement_custom_measurement_add(reMap.get("ElementType"), key, reMap.get(key));
 299
 300                         }
 301
 302                         sm.evel_nfcnamingcode_set("");
 303                         sm.evel_nfnamingcode_set("");
 304                         sm.evel_header_type_set("applicationVnf");
 305                         String rmUID = reMap.get("rmUID");
 306                         sm.evel_reporting_entity_id_set(rmUID.substring(0,9));//
 307                         String Dn = reMap.get("Dn");
 308                         sm.evel_reporting_entity_name_set(Dn.substring(0, Dn != null && Dn.indexOf(";")>0?Dn.indexOf(";"):Dn.length()));
 309                         sm.evel_header_set_sourceid(true, reMap.get("rmUID"));
 310                         sm.evel_header_set_source_name(reMap.get("rmUID"));
 311
 312                         sm.evel_header_set_priority(EvelHeader.PRIORITIES.EVEL_PRIORITY_NORMAL);
 313            return sm;
 314                 }
 315         }
 316
 317         /**
 318          * @return the configurationInterface
 319          */
 320         public ConfigurationInterface getConfigurationInterface() {
 321                 return configurationInterface;
 322         }
 323
 324         /**
 325          * @param configurationInterface the configurationInterface to set
 326          */
 327         public void setConfigurationInterface(
 328                         ConfigurationInterface configurationInterface) {
 329                 this.configurationInterface = configurationInterface;
 330         }
 331
 332 }