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

   1 /*
   2  * Copyright © 2017-2019 AT&T, Bell Canada
   3  * Modifications Copyright (c) 2019 IBM, Bell Canada
   4  *
   5  * Licensed under the Apache License, Version 2.0 (the "License");
   6  * you may not use this file except in compliance with the License.
   7  * You may obtain a copy of the License at
   8  *
   9  *     http://www.apache.org/licenses/LICENSE-2.0
  10  *
  11  * Unless required by applicable law or agreed to in writing, software
  12  * distributed under the License is distributed on an "AS IS" BASIS,
  13  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  14  * See the License for the specific language governing permissions and
  15  * limitations under the License.
  16  */
  17
  18 package org.onap.ccsdk.cds.blueprintsprocessor.functions.netconf.executor.core
  19
  20 import org.onap.ccsdk.cds.blueprintsprocessor.functions.netconf.executor.api.DeviceInfo
  21 import org.onap.ccsdk.cds.blueprintsprocessor.functions.netconf.executor.api.DeviceResponse
  22 import org.onap.ccsdk.cds.blueprintsprocessor.functions.netconf.executor.api.NetconfException
  23 import org.onap.ccsdk.cds.blueprintsprocessor.functions.netconf.executor.api.NetconfRpcService
  24 import org.onap.ccsdk.cds.blueprintsprocessor.functions.netconf.executor.api.NetconfSession
  25 import org.onap.ccsdk.cds.blueprintsprocessor.functions.netconf.executor.utils.NetconfMessageUtils
  26 import org.onap.ccsdk.cds.blueprintsprocessor.functions.netconf.executor.utils.RpcStatus
  27 import org.slf4j.LoggerFactory
  28 import java.util.concurrent.TimeUnit
  29 import java.util.concurrent.atomic.AtomicInteger
  30
  31 class NetconfRpcServiceImpl(private var deviceInfo: DeviceInfo) : NetconfRpcService {
  32
  33     private val log = LoggerFactory.getLogger(NetconfRpcService::class.java)
  34
  35     private var responseTimeout: Int = deviceInfo.replyTimeout
  36
  37     private lateinit var netconfSession: NetconfSession
  38
  39     private val messageIdInteger = AtomicInteger(1)
  40
  41     fun setNetconfSession(netconfSession: NetconfSession) {
  42         this.netconfSession = netconfSession
  43     }
  44
  45     override fun invokeRpc(rpc: String): DeviceResponse {
  46         var output = DeviceResponse()
  47         val messageId = messageIdInteger.getAndIncrement().toString()
  48         log.info("$deviceInfo: invokeRpc: messageId($messageId)")
  49         try {
  50             output = asyncRpc(rpc, messageId)
  51         } catch (e: Exception) {
  52             output.status = RpcStatus.FAILURE
  53             output.errorMessage = "$deviceInfo: failed in 'invokeRpc' command ${e.message}"
  54         }
  55         return output
  56     }
  57
  58     override fun get(filter: String): DeviceResponse {
  59         var output = DeviceResponse()
  60         val messageId = messageIdInteger.getAndIncrement().toString()
  61         log.info("$deviceInfo: get operational config: messageId($messageId)")
  62         try {
  63             val message = NetconfMessageUtils.get(messageId, filter)
  64             output = asyncRpc(message, messageId)
  65         } catch (e: Exception) {
  66             output.status = RpcStatus.FAILURE
  67             output.errorMessage = "$deviceInfo: failed in 'get' command ${e.message}"
  68         }
  69         return output
  70     }
  71
  72     override fun getConfig(filter: String, configTarget: String): DeviceResponse {
  73         var output = DeviceResponse()
  74         val messageId = messageIdInteger.getAndIncrement().toString()
  75         log.info("$deviceInfo: getConfig: messageId($messageId)")
  76         try {
  77             val message = NetconfMessageUtils.getConfig(messageId, configTarget, filter)
  78             output = asyncRpc(message, messageId)
  79         } catch (e: Exception) {
  80             output.status = RpcStatus.FAILURE
  81             output.errorMessage = "$deviceInfo: failed in 'get-config' command ${e.message}"
  82         }
  83         return output
  84     }
  85
  86     override fun deleteConfig(configTarget: String): DeviceResponse {
  87         var output = DeviceResponse()
  88         val messageId = messageIdInteger.getAndIncrement().toString()
  89         log.info("$deviceInfo: deleteConfig: messageId($messageId)")
  90         try {
  91             val deleteConfigMessage = NetconfMessageUtils.deleteConfig(messageId, configTarget)
  92             output.requestMessage = deleteConfigMessage
  93             output = asyncRpc(deleteConfigMessage, messageId)
  94         } catch (e: Exception) {
  95             output.status = RpcStatus.FAILURE
  96             output.errorMessage = "$deviceInfo: failed in 'delete-config' command ${e.message}"
  97         }
  98         return output
  99     }
 100
 101     override fun lock(configTarget: String): DeviceResponse {
 102         var output = DeviceResponse()
 103         val messageId = messageIdInteger.getAndIncrement().toString()
 104         log.info("$deviceInfo: lock: messageId($messageId)")
 105         try {
 106             val lockMessage = NetconfMessageUtils.lock(messageId, configTarget)
 107             output.requestMessage = lockMessage
 108             output = asyncRpc(lockMessage, messageId)
 109         } catch (e: Exception) {
 110             output.status = RpcStatus.FAILURE
 111             output.errorMessage = "$deviceInfo: failed in 'lock' command ${e.message}"
 112         }
 113
 114         return output
 115     }
 116
 117     override fun unLock(configTarget: String): DeviceResponse {
 118         var output = DeviceResponse()
 119         val messageId = messageIdInteger.getAndIncrement().toString()
 120         log.info("$deviceInfo: unLock: messageId($messageId)")
 121         try {
 122             val unlockMessage = NetconfMessageUtils.unlock(messageId, configTarget)
 123             output.requestMessage = unlockMessage
 124             output = asyncRpc(unlockMessage, messageId)
 125         } catch (e: Exception) {
 126             output.status = RpcStatus.FAILURE
 127             output.errorMessage = "$deviceInfo: failed in 'unLock' command ${e.message}"
 128         }
 129         return output
 130     }
 131
 132     override fun commit(confirmed: Boolean, confirmTimeout: Int, persist: String, persistId: String): DeviceResponse {
 133         var output = DeviceResponse()
 134         val messageId = messageIdInteger.getAndIncrement().toString()
 135         log.info("$deviceInfo: commit: messageId($messageId)")
 136         try {
 137             val messageContent = NetconfMessageUtils.commit(messageId, confirmed, confirmTimeout, persist, persistId)
 138             output = asyncRpc(messageContent, messageId)
 139         } catch (e: Exception) {
 140             output.status = RpcStatus.FAILURE
 141             output.errorMessage = "$deviceInfo: failed in 'commit' command ${e.message}"
 142         }
 143         return output
 144     }
 145
 146     override fun cancelCommit(persistId: String): DeviceResponse {
 147         var output = DeviceResponse()
 148         val messageId = messageIdInteger.getAndIncrement().toString()
 149         log.info("$deviceInfo: cancelCommit: messageId($messageId)")
 150         try {
 151             val messageContent = NetconfMessageUtils.cancelCommit(messageId, persistId)
 152             output = asyncRpc(messageContent, messageId)
 153         } catch (e: Exception) {
 154             output.status = RpcStatus.FAILURE
 155             output.errorMessage = "$deviceInfo: failed in 'cancelCommit' command ${e.message}"
 156         }
 157         return output
 158     }
 159
 160     override fun discardConfig(): DeviceResponse {
 161         var output = DeviceResponse()
 162         val messageId = messageIdInteger.getAndIncrement().toString()
 163         log.info("$deviceInfo: discard: messageId($messageId)")
 164         try {
 165             val discardChangesMessage = NetconfMessageUtils.discardChanges(messageId)
 166             output.requestMessage = discardChangesMessage
 167             output = asyncRpc(discardChangesMessage, messageId)
 168         } catch (e: Exception) {
 169             output.status = RpcStatus.FAILURE
 170             output.errorMessage = "$deviceInfo: failed in 'discard-config' command ${e.message}"
 171         }
 172         return output
 173     }
 174
 175     override fun editConfig(messageContent: String, configTarget: String,
 176                             editDefaultOperation: String): DeviceResponse {
 177         var response = DeviceResponse()
 178         val messageId = messageIdInteger.getAndIncrement().toString()
 179         log.info("$deviceInfo: editConfig: messageId($messageId)")
 180         try {
 181             val editMessage =
 182                 NetconfMessageUtils.editConfig(messageId, configTarget, editDefaultOperation, messageContent)
 183             response.requestMessage = editMessage
 184             response = asyncRpc(editMessage, messageId)
 185         } catch (e: Exception) {
 186             response.status = RpcStatus.FAILURE
 187             response.errorMessage = "$deviceInfo: failed in 'editConfig' command ${e.message}"
 188         }
 189         return response
 190     }
 191
 192     override fun validate(configTarget: String): DeviceResponse {
 193         var output = DeviceResponse()
 194         val messageId = messageIdInteger.getAndIncrement().toString()
 195         try {
 196             val validateMessage = NetconfMessageUtils.validate(messageId, configTarget)
 197             output.requestMessage = validateMessage
 198             output = asyncRpc(validateMessage, messageId)
 199         } catch (e: Exception) {
 200             output.status = RpcStatus.FAILURE
 201             output.errorMessage = "$deviceInfo: failed in 'validate' command ${e.message}"
 202         }
 203         return output
 204     }
 205
 206     override fun closeSession(force: Boolean): DeviceResponse {
 207         var output = DeviceResponse()
 208         val messageId = messageIdInteger.getAndIncrement().toString()
 209         log.info("$deviceInfo: closeSession: messageId($messageId)")
 210         try {
 211             val messageContent = NetconfMessageUtils.closeSession(messageId, force)
 212             output = asyncRpc(messageContent, messageId)
 213         } catch (e: Exception) {
 214             output.status = RpcStatus.FAILURE
 215             output.errorMessage = "$deviceInfo: failed in 'closeSession' command ${e.message}"
 216         }
 217         return output
 218     }
 219
 220     @Throws(NetconfException::class)
 221     override fun asyncRpc(request: String, messageId: String): DeviceResponse {
 222         val response = DeviceResponse()
 223         log.info("$deviceInfo: send asyncRpc with messageId($messageId)")
 224         response.requestMessage = request
 225
 226         val rpcResponse = netconfSession.asyncRpc(request, messageId).get(responseTimeout.toLong(), TimeUnit.SECONDS)
 227         if (!NetconfMessageUtils.checkReply(rpcResponse)) {
 228             throw NetconfException(rpcResponse)
 229         }
 230         response.responseMessage = rpcResponse
 231         response.status = RpcStatus.SUCCESS
 232         response.errorMessage = null
 233         return response
 234     }
 235 }