ms/blueprintsprocessor/functions/netconf-executor/src/main/kotlin/org/onap/ccsdk/apps/blueprintsprocessor/functions/netconf/executor/core/NetconfRpcServiceImpl.kt

   1 /*
   2  * Copyright © 2017-2019 AT&T, Bell Canada
   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
  17 package org.onap.ccsdk.apps.blueprintsprocessor.functions.netconf.executor.core
  18
  19 import org.onap.ccsdk.apps.blueprintsprocessor.functions.netconf.executor.api.DeviceInfo
  20 import org.onap.ccsdk.apps.blueprintsprocessor.functions.netconf.executor.api.DeviceResponse
  21 import org.onap.ccsdk.apps.blueprintsprocessor.functions.netconf.executor.api.NetconfException
  22 import org.onap.ccsdk.apps.blueprintsprocessor.functions.netconf.executor.api.NetconfRpcService
  23 import org.onap.ccsdk.apps.blueprintsprocessor.functions.netconf.executor.api.NetconfSession
  24 import org.onap.ccsdk.apps.blueprintsprocessor.functions.netconf.executor.utils.NetconfMessageUtils
  25 import org.onap.ccsdk.apps.blueprintsprocessor.functions.netconf.executor.utils.RpcStatus
  26 import org.slf4j.LoggerFactory
  27 import java.util.concurrent.TimeUnit
  28 import java.util.concurrent.atomic.AtomicInteger
  29
  30 class NetconfRpcServiceImpl(private var deviceInfo: DeviceInfo) : NetconfRpcService {
  31
  32     private val log = LoggerFactory.getLogger(NetconfRpcService::class.java)
  33
  34     private var responseTimeout: Int = deviceInfo.replyTimeout
  35
  36     private lateinit var netconfSession: NetconfSession
  37
  38     private val messageIdInteger = AtomicInteger(1)
  39
  40     fun setNetconfSession(netconfSession: NetconfSession) {
  41         this.netconfSession = netconfSession
  42     }
  43
  44     override fun invokeRpc(rpc: String): DeviceResponse {
  45         var output = DeviceResponse()
  46         val messageId = messageIdInteger.getAndIncrement().toString()
  47         log.info("$deviceInfo: invokeRpc: messageId($messageId)")
  48         try {
  49             output = asyncRpc(rpc, messageId)
  50         } catch (e: Exception) {
  51             output.status = RpcStatus.FAILURE
  52             output.errorMessage = "$deviceInfo: failed in invokeRpc command $e.message"
  53         }
  54         return output
  55     }
  56
  57     override fun getConfig(filter: String, configTarget: String): DeviceResponse {
  58         var output = DeviceResponse()
  59         val messageId = messageIdInteger.getAndIncrement().toString()
  60         log.info("$deviceInfo: getConfig: messageId($messageId)")
  61         try {
  62             val message = NetconfMessageUtils.getConfig(messageId, configTarget, filter)
  63             output = asyncRpc(message, messageId)
  64         } catch (e: Exception) {
  65             output.status = RpcStatus.FAILURE
  66             output.errorMessage = "$deviceInfo: failed in get-config command $e.message"
  67         }
  68         return output
  69     }
  70
  71     override fun deleteConfig(configTarget: String): DeviceResponse {
  72         var output = DeviceResponse()
  73         val messageId = messageIdInteger.getAndIncrement().toString()
  74         log.info("$deviceInfo: deleteConfig: messageId($messageId)")
  75         try {
  76             val deleteConfigMessage = NetconfMessageUtils.deleteConfig(messageId, configTarget)
  77             output.requestMessage = deleteConfigMessage
  78             output = asyncRpc(deleteConfigMessage, messageId)
  79         } catch (e: Exception) {
  80             output.status = RpcStatus.FAILURE
  81             output.errorMessage = "$deviceInfo: failed in delete config command $e.message"
  82         }
  83         return output
  84     }
  85
  86     override fun lock(configTarget: String): DeviceResponse {
  87         var output = DeviceResponse()
  88         val messageId = messageIdInteger.getAndIncrement().toString()
  89         log.info("$deviceInfo: lock: messageId($messageId)")
  90         try {
  91             val lockMessage = NetconfMessageUtils.lock(messageId, configTarget)
  92             output.requestMessage = lockMessage
  93             output = asyncRpc(lockMessage, messageId)
  94         } catch (e: Exception) {
  95             output.status = RpcStatus.FAILURE
  96             output.errorMessage = "$deviceInfo: failed in lock command $e.message"
  97         }
  98
  99         return output
 100     }
 101
 102     override fun unLock(configTarget: String): DeviceResponse {
 103         var output = DeviceResponse()
 104         val messageId = messageIdInteger.getAndIncrement().toString()
 105         log.info("$deviceInfo: unLock: messageId($messageId)")
 106         try {
 107             val unlockMessage = NetconfMessageUtils.unlock(messageId, configTarget)
 108             output.requestMessage = unlockMessage
 109             output = asyncRpc(unlockMessage, messageId)
 110         } catch (e: Exception) {
 111             output.status = RpcStatus.FAILURE
 112             output.errorMessage = "$deviceInfo: failed in lock command $e.message"
 113         }
 114         return output
 115     }
 116
 117     override fun commit(confirmed: Boolean, confirmTimeout: Int, persist: String, persistId: String): DeviceResponse {
 118         var output = DeviceResponse()
 119         val messageId = messageIdInteger.getAndIncrement().toString()
 120         log.info("$deviceInfo: commit: messageId($messageId)")
 121         try {
 122             val messageContent = NetconfMessageUtils.commit(messageId, confirmed, confirmTimeout, persist, persistId)
 123             output = asyncRpc(messageContent, messageId)
 124         } catch (e: Exception) {
 125             output.status = RpcStatus.FAILURE
 126             output.errorMessage = "$deviceInfo: failed in commit command $e.message"
 127         }
 128         return output
 129     }
 130
 131     override fun cancelCommit(persistId: String): DeviceResponse {
 132         var output = DeviceResponse()
 133         val messageId = messageIdInteger.getAndIncrement().toString()
 134         log.info("$deviceInfo: cancelCommit: messageId($messageId)")
 135         try {
 136             val messageContent = NetconfMessageUtils.cancelCommit(messageId, persistId)
 137             output = asyncRpc(messageContent, messageId)
 138         } catch (e: Exception) {
 139             output.status = RpcStatus.FAILURE
 140             output.errorMessage = "$deviceInfo: failed in cancelCommit command $e.message"
 141         }
 142         return output
 143     }
 144
 145     override fun discardConfig(): DeviceResponse {
 146         var output = DeviceResponse()
 147         val messageId = messageIdInteger.getAndIncrement().toString()
 148         log.info("$deviceInfo: discard: messageId($messageId)")
 149         try {
 150             val discardChangesMessage = NetconfMessageUtils.discardChanges(messageId)
 151             output.requestMessage = discardChangesMessage
 152             output = asyncRpc(discardChangesMessage, messageId)
 153         } catch (e: Exception) {
 154             output.status = RpcStatus.FAILURE
 155             output.errorMessage = "$deviceInfo: failed in discard changes command " + e.message
 156         }
 157         return output
 158     }
 159
 160     override fun editConfig(messageContent: String, configTarget: String,
 161                             editDefaultOperation: String): DeviceResponse {
 162         var response = DeviceResponse()
 163         val messageId = messageIdInteger.getAndIncrement().toString()
 164         log.info("$deviceInfo: editConfig: messageId($messageId)")
 165         try {
 166             val editMessage =
 167                 NetconfMessageUtils.editConfig(messageId, configTarget, editDefaultOperation, messageContent)
 168             response.requestMessage = editMessage
 169             response = asyncRpc(editMessage, messageId)
 170         } catch (e: Exception) {
 171             response.status = RpcStatus.FAILURE
 172             response.errorMessage = e.message
 173         }
 174         return response
 175     }
 176
 177     override fun validate(configTarget: String): DeviceResponse {
 178         var output = DeviceResponse()
 179         val messageId = messageIdInteger.getAndIncrement().toString()
 180         try {
 181             val validateMessage = NetconfMessageUtils.validate(messageId, configTarget)
 182             output.requestMessage = validateMessage
 183             output = asyncRpc(validateMessage, messageId)
 184         } catch (e: Exception) {
 185             output.status = RpcStatus.FAILURE
 186             output.errorMessage = "$deviceInfo: failed in validate command " + e.message
 187         }
 188         return output
 189     }
 190
 191     override fun closeSession(force: Boolean): DeviceResponse {
 192         var output = DeviceResponse()
 193         val messageId = messageIdInteger.getAndIncrement().toString()
 194         log.info("$deviceInfo: closeSession: messageId($messageId)")
 195         try {
 196             val messageContent = NetconfMessageUtils.closeSession(messageId, force)
 197             output = asyncRpc(messageContent, messageId)
 198         } catch (e: Exception) {
 199             output.status = RpcStatus.FAILURE
 200             output.errorMessage = "$deviceInfo: failed in closeSession command " + e.message
 201         }
 202         return output
 203     }
 204
 205     @Throws(NetconfException::class)
 206     override fun asyncRpc(request: String, messageId: String): DeviceResponse {
 207         val response = DeviceResponse()
 208         log.info("$deviceInfo: send asyncRpc with messageId($messageId)")
 209         response.requestMessage = request
 210
 211         val rpcResponse = netconfSession.asyncRpc(request, messageId).get(responseTimeout.toLong(), TimeUnit.SECONDS)
 212         if (!NetconfMessageUtils.checkReply(rpcResponse)) {
 213             throw NetconfException(rpcResponse)
 214         }
 215         response.responseMessage = rpcResponse
 216         response.status = RpcStatus.SUCCESS
 217         response.errorMessage = null
 218         return response
 219     }
 220 }