| /*- | |
| * ============LICENSE_START======================================================= | |
| * OSAM Core | |
| * ================================================================================ | |
| * Copyright (C) 2018 Netsia | |
| * ================================================================================ | |
| * Licensed under the Apache License, Version 2.0 (the "License"); | |
| * you may not use this file except in compliance with the License. | |
| * You may obtain a copy of the License at | |
| * | |
| * http://www.apache.org/licenses/LICENSE-2.0 | |
| * | |
| * Unless required by applicable law or agreed to in writing, software | |
| * distributed under the License is distributed on an "AS IS" BASIS, | |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. | |
| * See the License for the specific language governing permissions and | |
| * limitations under the License. | |
| * ============LICENSE_END========================================================= | |
| */ | |
| /* | |
| * Copyright 2015, Google Inc. All rights reserved. | |
| * | |
| * Redistribution and use in source and binary forms, with or without | |
| * modification, are permitted provided that the following conditions are | |
| * met: | |
| * | |
| * * Redistributions of source code must retain the above copyright | |
| * notice, this list of conditions and the following disclaimer. | |
| * * Redistributions in binary form must reproduce the above | |
| * copyright notice, this list of conditions and the following disclaimer | |
| * in the documentation and/or other materials provided with the | |
| * distribution. | |
| * | |
| * * Neither the name of Google Inc. nor the names of its | |
| * contributors may be used to endorse or promote products derived from | |
| * this software without specific prior written permission. | |
| * | |
| * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS | |
| * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT | |
| * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR | |
| * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT | |
| * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, | |
| * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT | |
| * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, | |
| * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY | |
| * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT | |
| * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE | |
| * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. | |
| */ | |
| package org.onap.osam.external.grpc; | |
| import io.grpc.ManagedChannel; | |
| import io.grpc.ManagedChannelBuilder; | |
| import lombok.extern.slf4j.Slf4j; | |
| import org.onap.osam.common.exception.AbstractOLTException; | |
| import org.onap.osam.common.exception.ServerException; | |
| import org.onap.osam.grpc.AbstractOLTGrpc; | |
| import org.onap.osam.grpc.AddChassisMessage; | |
| import org.onap.osam.grpc.AddChassisReturn; | |
| import org.onap.osam.grpc.AddOLTChassisMessage; | |
| import org.onap.osam.grpc.AddOLTChassisReturn; | |
| import org.onap.osam.grpc.AddOntFullMessage; | |
| import org.onap.osam.grpc.AddOntMessage; | |
| import org.onap.osam.grpc.AddOntReturn; | |
| import org.onap.osam.grpc.PreProvisionOntMessage; | |
| import org.onap.osam.model.dao.Chassis; | |
| import org.onap.osam.model.dao.OLTSlot; | |
| import org.onap.osam.model.dao.ONTDevice; | |
| import org.springframework.beans.factory.annotation.Value; | |
| import org.springframework.context.annotation.PropertySource; | |
| import org.springframework.stereotype.Component; | |
| import org.springframework.util.StringUtils; | |
| import javax.annotation.PostConstruct; | |
| @Component | |
| @PropertySource("classpath:abstractolt.properties") | |
| @Slf4j | |
| public class AbstractOLTClient { | |
| private static final String ABSTRACTOLT_HOST = "${abstractolt.host}"; | |
| private static final String ABSTRACTOLT_PORT = "${abstractolt.port}"; | |
| public static int NUMBER_OF_OLT_PORTS = 16; | |
| private AbstractOLTGrpc.AbstractOLTBlockingStub blockingStub; | |
| @Value(ABSTRACTOLT_HOST) | |
| private String host; | |
| @Value(ABSTRACTOLT_PORT) | |
| private int port; | |
| @PostConstruct | |
| private void init() { | |
| log.info("Abstract OLT connection properties - host: {}, port: {}", host, port); | |
| ManagedChannel managedChannel = ManagedChannelBuilder | |
| .forAddress(host, port).usePlaintext().build(); | |
| blockingStub = AbstractOLTGrpc.newBlockingStub(managedChannel); | |
| } | |
| /** create chassis */ | |
| public void createChassis(Chassis chassis) { | |
| try { | |
| log.info("createChassis begin, chassis: {}", chassis); | |
| String clli = chassis.getClli(); | |
| int rack = chassis.getRack(); | |
| int shelf = chassis.getShelf(); | |
| String xosIP = chassis.getAccessPod().getCoreIp(); | |
| int port = Integer.parseInt(chassis.getAccessPod().getCorePort()); | |
| String user = chassis.getAccessPod().getUsername(); | |
| String pass = chassis.getAccessPod().getPassword(); | |
| AddChassisMessage request = AddChassisMessage.newBuilder() | |
| .setCLLI(clli) | |
| .setRack(rack) | |
| .setShelf(shelf) | |
| .setXOSIP(xosIP) | |
| .setXOSPort(port) | |
| .setXOSUser(user) | |
| .setXOSPassword(pass) | |
| .build(); | |
| log.info("AddChassisMessage message: {}", request); | |
| AddChassisReturn response = blockingStub.createChassis(request); | |
| if (!StringUtils.isEmpty(response.getDeviceID())) { | |
| log.info("Chassis created in AbstractOLT with clli : {}", clli); | |
| } else { | |
| log.error("DeviceId of created chassis in AbstractOLT is empty or null, chassis: {}", chassis); | |
| throw new ServerException("DeviceId of created chassis in AbstractOLT is empty or null"); | |
| } | |
| } catch (RuntimeException e){ | |
| log.error("Chassis creation failed", e); | |
| throw new AbstractOLTException("Chassis creation failed for chassis : {}", chassis); | |
| } | |
| } | |
| public String createOLTChassis(OLTSlot olt) { | |
| String deviceID = null, chassisDeviceId = null; | |
| try { | |
| log.info("createOLTChassis begin, olt:{}", olt); | |
| String clli = olt.getChassis().getClli(); | |
| AddOLTChassisMessage.OltDriver oltDriver = AddOLTChassisMessage.OltDriver.forNumber((olt.getOltDriver().ordinal())); | |
| AddOLTChassisMessage.OltType oltType = AddOLTChassisMessage.OltType.forNumber((olt.getOltType().ordinal())); | |
| AddOLTChassisMessage request = AddOLTChassisMessage.newBuilder() | |
| .setCLLI(clli) | |
| .setDriver(oltDriver) | |
| .setNumPorts(NUMBER_OF_OLT_PORTS) | |
| .setSlotPort(olt.getPort()) | |
| .setSlotIP(olt.getIpAddress()) | |
| .setType(oltType) | |
| .build(); | |
| log.info("AddOLTChassisMessage message: {}", request); | |
| AddOLTChassisReturn response = blockingStub.createOLTChassis(request); | |
| deviceID = response.getDeviceID(); | |
| chassisDeviceId = response.getChassisDeviceID(); | |
| if(!StringUtils.isEmpty(response.getDeviceID()) && !StringUtils.isEmpty(response.getChassisDeviceID())) { | |
| log.info("OLT Chassis created in AbstractOLT deviceId : {} chassisDeviceId : {}",deviceID,chassisDeviceId); | |
| } else { | |
| log.error("Invalid return argument from AbstractOLT, deviceId : {} chassisDeviceId : {}",deviceID,chassisDeviceId); | |
| throw new ServerException("DeviceId of created chassis in AbstractOLT is empty or null"); | |
| } | |
| } catch (RuntimeException e) { | |
| log.error("OLT Chassis creation failed", e); | |
| throw new AbstractOLTException("OLT Chassis creation failed for olt : {}", olt); | |
| } | |
| return deviceID; | |
| } | |
| public boolean preProvisionOnt(ONTDevice ontDevice) { | |
| boolean result = false; | |
| try { | |
| PreProvisionOntMessage preProvisionOntMessage = OntMessageFactory.getPreProvisionOntMessage(ontDevice); | |
| AddOntReturn response = blockingStub.preProvisionOnt(preProvisionOntMessage); | |
| result = response.getSuccess(); | |
| log.info("preProvisionOnt with device id : {} success : {}" ,ontDevice.getSerialNumber(), result); | |
| } catch (RuntimeException e) { | |
| log.error("preProvisionOnt RPC failed", e); | |
| throw new AbstractOLTException("preProvisionOnt failed for ont : {}", ontDevice); | |
| } | |
| return result; | |
| } | |
| public boolean provisionONT(ONTDevice ontDevice) { | |
| boolean result = false; | |
| try { | |
| AddOntMessage request = OntMessageFactory.getOntMessage(ontDevice); | |
| AddOntReturn response = blockingStub.provisionOnt(request); | |
| result = response.getSuccess(); | |
| log.info("provisionONT with device id : {} success : {}",ontDevice.getSerialNumber(), result); | |
| } catch (RuntimeException e) { | |
| log.error("provisionONT RPC failed", e); | |
| throw new AbstractOLTException("provisionONT failed for ont : {}", ontDevice); | |
| } | |
| return result; | |
| } | |
| public boolean provisionOntFull(ONTDevice ontDevice) { | |
| boolean result = false; | |
| try { | |
| AddOntFullMessage addOntFullMessage = OntMessageFactory.getOntFullMessage(ontDevice); | |
| AddOntReturn response = blockingStub.provisionOntFull(addOntFullMessage); | |
| result = response.getSuccess(); | |
| log.info("provisionOntFull with device id : {} success : {}",ontDevice.getSerialNumber(), result); | |
| } catch (RuntimeException e) { | |
| log.error("provisionOntFull RPC failed", e); | |
| throw new AbstractOLTException("provisionOntFull failed for ont : {}", ontDevice); | |
| } | |
| return result; | |
| } | |
| } |