gerrit.onap Code Review - so.git/blob

   1 /*-
   2  * ============LICENSE_START=======================================================
   3  * ONAP - SO
   4  * ================================================================================
   5  * Copyright (C) 2017 AT&T Intellectual Property. All rights reserved.
   6  * ================================================================================
   7  * Licensed under the Apache License, Version 2.0 (the "License");
   8  * you may not use this file except in compliance with the License.
   9  * You may obtain a copy of the License at
  10  *
  11  *      http://www.apache.org/licenses/LICENSE-2.0
  12  *
  13  * Unless required by applicable law or agreed to in writing, software
  14  * distributed under the License is distributed on an "AS IS" BASIS,
  15  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  16  * See the License for the specific language governing permissions and
  17  * limitations under the License.
  18  * ============LICENSE_END=========================================================
  19  */
  20
  21 package org.openecomp.mso.bpmn.infrastructure.workflow.serviceTask;
  22
  23 import com.fasterxml.jackson.annotation.JsonInclude;
  24 import com.fasterxml.jackson.core.JsonProcessingException;
  25 import com.fasterxml.jackson.databind.ObjectMapper;
  26 import org.apache.commons.lang3.StringUtils;
  27 import org.apache.http.client.ClientProtocolException;
  28 import org.apache.http.client.methods.CloseableHttpResponse;
  29 import org.apache.http.client.methods.HttpGet;
  30 import org.apache.http.client.methods.HttpPost;
  31 import org.apache.http.entity.ContentType;
  32 import org.apache.http.entity.StringEntity;
  33 import org.apache.http.impl.client.CloseableHttpClient;
  34 import org.apache.http.impl.client.HttpClients;
  35 import org.apache.http.util.EntityUtils;
  36 import org.camunda.bpm.engine.delegate.DelegateExecution;
  37 import org.json.JSONObject;
  38 import org.onap.msb.sdk.discovery.common.RouteException;
  39 import org.onap.msb.sdk.httpclient.RestServiceCreater;
  40 import org.onap.msb.sdk.httpclient.msb.MSBServiceClient;
  41 import org.openecomp.mso.bpmn.core.BaseTask;
  42 import org.openecomp.mso.bpmn.core.PropertyConfiguration;
  43 import org.openecomp.mso.bpmn.infrastructure.workflow.serviceTask.client.GenericResourceApi;
  44 import org.openecomp.mso.logger.MessageEnum;
  45 import org.openecomp.mso.logger.MsoLogger;
  46 import org.openecomp.mso.requestsdb.RequestsDatabase;
  47 import org.openecomp.mso.requestsdb.ResourceOperationStatus;
  48 import org.slf4j.Logger;
  49 import org.slf4j.LoggerFactory;
  50
  51 import java.io.IOException;
  52 import java.util.HashMap;
  53 import java.util.Iterator;
  54 import java.util.Map;
  55
  56 /**
  57  * Created by 10112215 on 2017/9/16.
  58  */
  59 public abstract class AbstractSdncOperationTask extends BaseTask {
  60
  61     private static final Logger logger = LoggerFactory.getLogger(AbstractSdncOperationTask.class);
  62
  63     private static final String DEFAULT_MSB_IP = "127.0.0.1";
  64     private static final int DEFAULT_MSB_Port = 80;
  65     private static final String SDCADAPTOR_INPUTS = "resourceParameters";
  66     public static final String ONAP_IP = "ONAP_IP";
  67     private RequestsDatabase requestsDB = RequestsDatabase.getInstance();
  68
  69     private static final String postBodyTemplate = "<soapenv:Envelope xmlns:soapenv=\"http://schemas.xmlsoap.org/soap/envelope/\" xmlns:ns=\"http://org.openecomp.mso/requestsdb\"><soapenv:Header/><soapenv:Body>\n"+
  70             "     <ns:updateResourceOperationStatus>\n"+
  71             "                <errorCode>$errorCode</errorCode>\n"+
  72             "                <jobId>$jobId</jobId>\n"+
  73             "                <operType>$operType</operType>\n"+
  74             "                <operationId>$operationId</operationId>\n"+
  75             "                <progress>$progress</progress>\n"+
  76             "                <resourceTemplateUUID>$resourceTemplateUUID</resourceTemplateUUID>\n"+
  77             "                <serviceId>$serviceId</serviceId>\n"+
  78             "                <status>$status</status>\n"+
  79             "                <statusDescription>$statusDescription</statusDescription>\n"+
  80             "     </ns:updateResourceOperationStatus></soapenv:Body></soapenv:Envelope>";
  81
  82     private static final String getBodyTemplate = " <soapenv:Envelope xmlns:soapenv=\"http://schemas.xmlsoap.org/soap/envelope/\" xmlns:ns=\"http://org.openecomp.mso/requestsdb\"><soapenv:Header/><soapenv:Body>\n" +
  83             "     <ns:getResourceOperationStatus>\n" +
  84             "                <operationId>$operationId</operationId>\n" +
  85             "                <resourceTemplateUUID>$resourceTemplateUUID</resourceTemplateUUID>\n" +
  86             "                <serviceId>$serviceId</serviceId>\n" +
  87             "     </ns:getResourceOperationStatus></soapenv:Body></soapenv:Envelope>";
  88
  89
  90     private void updateResOperStatus(ResourceOperationStatus resourceOperationStatus) throws RouteException {
  91         logger.info("AbstractSdncOperationTask.updateResOperStatus begin!");
  92         String url = "http://mso:8080/dbadapters/RequestsDbAdapter";
  93         HttpPost httpPost = new HttpPost(url);
  94         httpPost.addHeader("Authorization", "Basic QlBFTENsaWVudDpwYXNzd29yZDEk");
  95         httpPost.addHeader("Content-type", "application/soap+xml");
  96         String postBody = getPostStringBody(resourceOperationStatus);
  97         httpPost.setEntity(new StringEntity(postBody, ContentType.APPLICATION_XML));
  98         httpPost(url, httpPost);
  99         logger.info("AbstractSdncOperationTask.updateResOperStatus end!");
 100         //requestsDB.updateResOperStatus(resourceOperationStatus);
 101     }
 102
 103     protected String getPostbody(Object inputEntity) {
 104         ObjectMapper objectMapper = new ObjectMapper();
 105         String postBody = null;
 106         try {
 107             objectMapper.setSerializationInclusion(JsonInclude.Include.NON_EMPTY);
 108             postBody = objectMapper.writeValueAsString(inputEntity);
 109         } catch (JsonProcessingException e) {
 110             e.printStackTrace();
 111         }
 112         return postBody;
 113     }
 114
 115     protected String httpPost(String url, HttpPost httpPost) throws RouteException {
 116         logger.info("AbstractSdncOperationTask.httpPost begin!");
 117         CloseableHttpClient httpClient = HttpClients.createDefault();
 118         String result = null;
 119         boolean var15 = false;
 120
 121         String errorMsg;
 122         label91: {
 123             try {
 124                 var15 = true;
 125                 CloseableHttpResponse closeableHttpResponse = httpClient.execute(httpPost);
 126                 result = EntityUtils.toString(closeableHttpResponse.getEntity());
 127                 logger.info("result = {}", result);
 128 //                LOGGER.info(MessageEnum.RA_RESPONSE_FROM_SDNC, result.toString(), "SDNC", "");
 129                 if(closeableHttpResponse.getStatusLine().getStatusCode() != 200) {
 130                     logger.info("exception: fail for status code = {}", closeableHttpResponse.getStatusLine().getStatusCode());
 131                     throw new RouteException(result, "SERVICE_GET_ERR");
 132                 }
 133
 134                 closeableHttpResponse.close();
 135                 var15 = false;
 136                 break label91;
 137             } catch (IOException var19) {
 138                 errorMsg = url + ":httpPostWithJSON connect faild";
 139                 logger.info("exception: POST_CONNECT_FAILD : {}", errorMsg);
 140                 throwsRouteException(errorMsg, var19, "POST_CONNECT_FAILD");
 141                 var15 = false;
 142             } finally {
 143                 if(var15) {
 144                     try {
 145                         httpClient.close();
 146                     } catch (IOException var16) {
 147                         String errorMsg1 = url + ":close  httpClient faild";
 148                         logger.info("exception: CLOSE_CONNECT_FAILD : {}", errorMsg1);
 149                         throwsRouteException(errorMsg1, var16, "CLOSE_CONNECT_FAILD");
 150                     }
 151
 152                 }
 153             }
 154
 155             try {
 156                 httpClient.close();
 157             } catch (IOException var17) {
 158                 errorMsg = url + ":close  httpClient faild";
 159                 logger.info("exception: CLOSE_CONNECT_FAILD : {}", errorMsg);
 160                 throwsRouteException(errorMsg, var17, "CLOSE_CONNECT_FAILD");
 161             }
 162         }
 163
 164         try {
 165             httpClient.close();
 166         } catch (IOException var18) {
 167             errorMsg = url + ":close  httpClient faild";
 168             logger.info("exception: CLOSE_CONNECT_FAILD : {}", errorMsg);
 169             throwsRouteException(errorMsg, var18, "CLOSE_CONNECT_FAILD");
 170         }
 171         logger.info("AbstractSdncOperationTask.httpPost end!");
 172         return result;
 173     }
 174
 175     private static void throwsRouteException(String errorMsg, Exception e, String errorCode) throws RouteException {
 176         String msg = errorMsg + ".errorMsg:" + e.getMessage();
 177         logger.info("exception: {}", msg);
 178         throw new RouteException(errorMsg, errorCode);
 179     }
 180
 181     private String getPostStringBody(ResourceOperationStatus resourceOperationStatus) {
 182         logger.info("AbstractSdncOperationTask.getPostStringBody begin!");
 183         String postBody = new String(postBodyTemplate);
 184         postBody = postBody.replace("$errorCode", resourceOperationStatus.getErrorCode());
 185         postBody = postBody.replace("$jobId", resourceOperationStatus.getJobId());
 186         postBody = postBody.replace("$operType", resourceOperationStatus.getOperType());
 187         postBody = postBody.replace("$operationId", resourceOperationStatus.getOperationId());
 188         postBody = postBody.replace("$progress", resourceOperationStatus.getProgress());
 189         postBody = postBody.replace("$resourceTemplateUUID", resourceOperationStatus.getResourceTemplateUUID());
 190         postBody = postBody.replace("$serviceId", resourceOperationStatus.getServiceId());
 191         postBody = postBody.replace("$status", resourceOperationStatus.getStatus());
 192         postBody = postBody.replace("$statusDescription", resourceOperationStatus.getStatusDescription());
 193         logger.info("AbstractSdncOperationTask.getPostStringBody end!");
 194         return postBody;
 195     }
 196
 197     private String getGetStringBody(String serviceId, String operationId, String resourceTemplateUUID) {
 198         logger.info("AbstractSdncOperationTask.getGetStringBody begin!");
 199         String getBody = new String(getBodyTemplate);
 200         getBody = getBody.replace("$operationId", operationId);
 201         getBody = getBody.replace("$resourceTemplateUUID", resourceTemplateUUID);
 202         getBody = getBody.replace("$serviceId", serviceId);
 203         logger.info("AbstractSdncOperationTask.getGetStringBody end!");
 204         return getBody;
 205     }
 206
 207     private ResourceOperationStatus getResourceOperationStatus(String serviceId, String operationId, String resourceTemplateUUID) throws RouteException {
 208         logger.info("AbstractSdncOperationTask.getResourceOperationStatus begin!");
 209         String url = "http://mso:8080/dbadapters/RequestsDbAdapter";
 210         HttpPost httpPost = new HttpPost(url);
 211         httpPost.addHeader("Authorization", "Basic QlBFTENsaWVudDpwYXNzd29yZDEk");
 212         httpPost.addHeader("Content-type", "application/soap+xml");
 213         String getBody = getGetStringBody(serviceId, operationId, resourceTemplateUUID);
 214         httpPost.setEntity(new StringEntity(getBody, ContentType.APPLICATION_XML));
 215         String result = httpPost(url, httpPost);
 216         ResourceOperationStatus resourceOperationStatus = getResourceOperationStatusFromXmlString(result);
 217         logger.info("AbstractSdncOperationTask.getResourceOperationStatus end!");
 218         return resourceOperationStatus;
 219
 220         //return requestsDB.getResourceOperationStatus(serviceId, operationId, resourceTemplateUUID);
 221     }
 222
 223     private String httpGet(String url, HttpGet httpGet) throws RouteException {
 224         logger.info("AbstractSdncOperationTask.httpGet begin!");
 225         boolean var16 = false;
 226         CloseableHttpClient httpClient = HttpClients.createDefault();
 227         String result = "";
 228         String errorMsg;
 229         label109:
 230         {
 231             label110:
 232             {
 233                 try {
 234                     var16 = true;
 235                     CloseableHttpResponse e = httpClient.execute(httpGet);
 236                     result = EntityUtils.toString(e.getEntity());
 237                     logger.info("result = {}", result);
 238                     if (e.getStatusLine().getStatusCode() != 200) {
 239                         logger.info("exception: fail for status code = {}", e.getStatusLine().getStatusCode());
 240                         throw new RouteException(result, "SERVICE_GET_ERR");
 241                     }
 242
 243                     e.close();
 244                     var16 = false;
 245                     break label110;
 246                 } catch (ClientProtocolException var21) {
 247                     errorMsg = url + ":httpGetWithJSON connect faild";
 248                     logger.info("exception: GET_CONNECT_FAILD {}", errorMsg);
 249                     throwsRouteException(errorMsg, var21, "GET_CONNECT_FAILD");
 250                     var16 = false;
 251                 } catch (IOException var22) {
 252                     errorMsg = url + ":httpGetWithJSON connect faild";
 253                     logger.info("exception: GET_CONNECT_FAILD {}", errorMsg);
 254                     throwsRouteException(errorMsg, var22, "GET_CONNECT_FAILD");
 255                     var16 = false;
 256                     break label109;
 257                 } finally {
 258                     if (var16) {
 259                         try {
 260                             httpClient.close();
 261                         } catch (IOException var17) {
 262                             String errorMsg1 = url + ":close  httpClient faild";
 263                             logger.info("exception: CLOSE_CONNECT_FAILD {}", errorMsg1);
 264                             throwsRouteException(errorMsg1, var17, "CLOSE_CONNECT_FAILD");
 265                         }
 266
 267                     }
 268                 }
 269
 270                 try {
 271                     httpClient.close();
 272                 } catch (IOException var19) {
 273                     errorMsg = url + ":close  httpClient faild";
 274                     logger.info("exception: CLOSE_CONNECT_FAILD {}", errorMsg);
 275                     throwsRouteException(errorMsg, var19, "CLOSE_CONNECT_FAILD");
 276                 }
 277
 278             }
 279
 280             try {
 281                 httpClient.close();
 282             } catch (IOException var20) {
 283                 errorMsg = url + ":close  httpClient faild";
 284                 logger.info("exception: CLOSE_CONNECT_FAILD {}", errorMsg);
 285                 throwsRouteException(errorMsg, var20, "CLOSE_CONNECT_FAILD");
 286             }
 287
 288         }
 289
 290         try {
 291             httpClient.close();
 292         } catch (IOException var18) {
 293             errorMsg = url + ":close  httpClient faild";
 294             logger.info("exception: CLOSE_CONNECT_FAILD {}", errorMsg);
 295             throwsRouteException(errorMsg, var18, "CLOSE_CONNECT_FAILD");
 296         }
 297         logger.info("AbstractSdncOperationTask.httpGet end!");
 298         return result;
 299     }
 300
 301     private ResourceOperationStatus getResourceOperationStatusFromXmlString(String result) {
 302         logger.info("AbstractSdncOperationTask.getResourceOperationStatusFromXmlString begin!");
 303         ResourceOperationStatus resourceOperationStatus = new ResourceOperationStatus();
 304         resourceOperationStatus.setErrorCode(getValueByName("errorCode", result));
 305         resourceOperationStatus.setJobId(getValueByName("jobId", result));
 306         resourceOperationStatus.setOperType(getValueByName("operType", result));
 307         resourceOperationStatus.setOperationId(getValueByName("operationId", result));
 308         resourceOperationStatus.setProgress(getValueByName("progress", result));
 309         resourceOperationStatus.setResourceTemplateUUID(getValueByName("resourceTemplateUUID", result));
 310         resourceOperationStatus.setServiceId(getValueByName("serviceId", result));
 311         resourceOperationStatus.setStatus(getValueByName("status", result));
 312         resourceOperationStatus.setStatusDescription(getValueByName("statusDescription", result));
 313         logger.info("AbstractSdncOperationTask.getResourceOperationStatusFromXmlString end!");
 314         return resourceOperationStatus;
 315     }
 316
 317     private String getValueByName(String Name, String xml) {
 318         if (!StringUtils.isBlank(xml) && xml.contains(Name)) {
 319             String start = "<" + Name + ">";
 320             String end = "</" + Name + ">";
 321             return xml.substring(xml.indexOf(start), xml.indexOf(end)).replace(start, "");
 322         }
 323         return "";
 324     }
 325
 326     protected static MsoLogger LOGGER = MsoLogger.getMsoLogger(MsoLogger.Catalog.RA);
 327
 328     @Override
 329     public void execute(DelegateExecution execution) {
 330         logger.info("AbstractSdncOperationTask.execute begin!");
 331         GenericResourceApi genericResourceApiClient = getGenericResourceApiClient(execution);
 332 //        updateProgress(execution, RequestsDbConstant.Status.PROCESSING, null, "10", "execute begin!");
 333         try {
 334             Map<String, String> inputs = getInputs(execution);
 335 //        updateProgress(execution, null, null, "30", "getGenericResourceApiClient finished!");
 336
 337             sendRestrequestAndHandleResponse(execution, inputs, genericResourceApiClient);
 338             execution.setVariable("SDNCA_SuccessIndicator", true);
 339 //            updateProgress(execution, RequestsDbConstant.Status.FINISHED, null, RequestsDbConstant.Progress.ONE_HUNDRED, "execute finished!");
 340         } catch (Exception e) {
 341             logger.info("exception: AbstractSdncOperationTask.fail!");
 342             logger.error("exception: AbstractSdncOperationTask.fail!:", e);
 343             e.printStackTrace();
 344             execution.setVariable("SDNCA_SuccessIndicator", false);
 345         }
 346         logger.info("AbstractSdncOperationTask.execute end!");
 347     }
 348
 349     protected Map<String, String> getInputs(DelegateExecution execution) {
 350         logger.info("AbstractSdncOperationTask.getInputs begin!");
 351         Map<String, String> inputs = new HashMap<>();
 352         String json = (String) execution.getVariable(SDCADAPTOR_INPUTS);
 353         JSONObject jsonObject = new JSONObject(json);
 354         JSONObject paras = jsonObject.getJSONObject("additionalParamForNs");
 355         Iterator<String> iterator = paras.keys();
 356         while (iterator.hasNext()) {
 357             String key = iterator.next();
 358             inputs.put(key, paras.getString(key));
 359         }
 360 /*        if (paras.keys().hasNext()) {
 361             paras.keySet().stream().forEach(key -> inputs.put(key, paras.getString((String) key)));
 362         }*/
 363         logger.info("AbstractSdncOperationTask.getInputs end!");
 364         return inputs;
 365     }
 366
 367     public abstract void sendRestrequestAndHandleResponse(DelegateExecution execution,
 368                                                           Map<String, String> inputs,
 369                                                           GenericResourceApi genericResourceApiClient) throws Exception;
 370
 371     public void updateProgress(DelegateExecution execution,
 372                                String status,
 373                                String errorCode,
 374                                String progress,
 375                                String statusDescription) {
 376         logger.info("AbstractSdncOperationTask.updateProgress begin!");
 377         String serviceId = (String) execution.getVariable("serviceId");
 378         String operationId = (String) execution.getVariable("operationId");
 379         String resourceTemplateUUID = (String) execution.getVariable("resourceUUID");
 380         try {
 381             ResourceOperationStatus resourceOperationStatus = getResourceOperationStatus(serviceId, operationId, resourceTemplateUUID);
 382             if (!StringUtils.isBlank(status)) {
 383                 resourceOperationStatus.setStatus(status);
 384             }
 385             if (!StringUtils.isBlank(errorCode)) {
 386                 resourceOperationStatus.setErrorCode(errorCode);
 387             }
 388             if (!StringUtils.isBlank(progress)) {
 389                 resourceOperationStatus.setProgress(progress);
 390             }
 391             if (!StringUtils.isBlank(statusDescription)) {
 392                 resourceOperationStatus.setStatusDescription(statusDescription);
 393             }
 394             updateResOperStatus(resourceOperationStatus);
 395             logger.info("AbstractSdncOperationTask.updateProgress end!");
 396         } catch (Exception exception) {
 397             System.out.println(exception);
 398             logger.info("exception: AbstractSdncOperationTask.updateProgress fail!");
 399             logger.error("exception: AbstractSdncOperationTask.updateProgress fail:", exception);
 400             LOGGER.error(MessageEnum.GENERAL_EXCEPTION, " updateProgress catch exception: ", "", this.getTaskName(), MsoLogger.ErrorCode.UnknownError, exception.getClass().toString());
 401         }
 402     }
 403
 404
 405     protected boolean isSend2SdncDirectly() {
 406         logger.info("AbstractSdncOperationTask.isSend2SdncDirectly begin!");
 407         Map<String, String> properties = PropertyConfiguration.getInstance().getProperties("topology.properties");
 408         if (properties != null) {
 409             String sdncIp = properties.get("sdnc-ip");
 410             String sdncPort = properties.get("sdnc-port");
 411             if (!StringUtils.isBlank(sdncIp) && isIp(sdncIp) && !StringUtils.isBlank(sdncPort)) {
 412                 logger.info("AbstractSdncOperationTask.isSend2SdncDirectly = true.");
 413                 return true;
 414             }
 415         }
 416         logger.info("AbstractSdncOperationTask.isSend2SdncDirectly = false.");
 417         return false;
 418     }
 419
 420     protected String getSdncIp() {
 421         logger.info("AbstractSdncOperationTask.getSdncIp begin.");
 422         String sdncIp = null;
 423         Map<String, String> properties = PropertyConfiguration.getInstance().getProperties("topology.properties");
 424         if (properties != null) {
 425             sdncIp = properties.get("sdnc-ip");
 426         }
 427         String returnIp = StringUtils.isBlank(sdncIp) || !isIp(sdncIp) ? null : sdncIp;
 428         logger.info("AbstractSdncOperationTask.getSdncIp: sdncIp = {}", returnIp);
 429         return returnIp;
 430     }
 431
 432     protected String getSdncPort() {
 433         logger.info("AbstractSdncOperationTask.getSdncPort begin.");
 434         String sdncPort = null;
 435         Map<String, String> properties = PropertyConfiguration.getInstance().getProperties("topology.properties");
 436         if (properties != null) {
 437             sdncPort = properties.get("sdnc-port");
 438         }
 439         String returnPort = StringUtils.isBlank(sdncPort) ? null : sdncPort;
 440         logger.info("AbstractSdncOperationTask.getSdncPort: returnPort = {}", sdncPort);
 441         return returnPort;
 442     }
 443
 444     private GenericResourceApi getGenericResourceApiClient(DelegateExecution execution) {
 445         logger.info("AbstractSdncOperationTask.getGenericResourceApiClient begin!");
 446 //        updateProgress(execution, null, null, "20", "getGenericResourceApiClient begin!");
 447         String msbIp = System.getenv().get(ONAP_IP);
 448         int msbPort = DEFAULT_MSB_Port;
 449         Map<String, String> properties = PropertyConfiguration.getInstance().getProperties("topology.properties");
 450         if (properties != null) {
 451             if (StringUtils.isBlank(msbIp) || !isIp(msbIp)) {
 452                 msbIp = properties.get("msb-ip");
 453                 if (StringUtils.isBlank(msbIp)) {
 454                     msbIp = getString(properties, "msb.address", DEFAULT_MSB_IP);
 455                 }
 456             }
 457             String strMsbPort = properties.get("msb-port");
 458             if (StringUtils.isBlank(strMsbPort)) {
 459                 strMsbPort = getString(properties, "msb.port", String.valueOf(DEFAULT_MSB_Port));
 460             }
 461             msbPort = Integer.valueOf(strMsbPort);
 462         }
 463         logger.info("AbstractSdncOperationTask.getGenericResourceApiClient msbIp = " + msbIp + " msbPort = " + msbPort);
 464         MSBServiceClient msbClient = new MSBServiceClient(msbIp, msbPort);
 465         RestServiceCreater restServiceCreater = new RestServiceCreater(msbClient);
 466         logger.info("AbstractSdncOperationTask.getGenericResourceApiClient end!");
 467         return restServiceCreater.createService(GenericResourceApi.class);
 468     }
 469
 470     protected boolean isIp(String msbIp) {
 471         return !StringUtils.isBlank(msbIp) && msbIp.split("\\.").length == 4;
 472     }
 473
 474     private String getString(Map<String, String> properties, String name, String defaultValue) {
 475         String vlaue = properties.get(name);
 476         try {
 477             if (!StringUtils.isBlank(vlaue)) {
 478                 return vlaue;
 479             }
 480         } catch (Exception e) {
 481             System.out.println(e);
 482             LOGGER.error(MessageEnum.GENERAL_EXCEPTION, " getMsbIp catch exception: ", "", this.getTaskName(), MsoLogger.ErrorCode.UnknownError, e.getClass().toString());
 483         }
 484         return defaultValue;
 485     }
 486
 487     private Integer getInteger(DelegateExecution execution, String name, Integer defaultValue) {
 488         Integer vlaue = (Integer) execution.getVariable(name);
 489         try {
 490             if (vlaue != null) {
 491                 return vlaue;
 492             }
 493         } catch (Exception e) {
 494             System.out.println(e);
 495             LOGGER.error(MessageEnum.GENERAL_EXCEPTION, " getMsbIp catch exception: ", "", this.getTaskName(), MsoLogger.ErrorCode.UnknownError, e.getClass().toString());
 496         }
 497         return defaultValue;
 498     }
 499
 500     public String getProcessKey(DelegateExecution execution) {
 501         return execution.getProcessEngineServices().getRepositoryService().getProcessDefinition(execution.getProcessDefinitionId()).getKey();
 502     }
 503 }