gerrit.onap Code Review - ccsdk/cds.git/blob

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