2 * ============LICENSE_START=======================================================
4 * ================================================================================
5 * Copyright (C) 2017 AT&T Intellectual Property. All rights reserved.
6 * ================================================================================
7 * Copyright (C) 2017 Amdocs
8 * =============================================================================
9 * Licensed under the Apache License, Version 2.0 (the "License");
10 * you may not use this file except in compliance with the License.
11 * You may obtain a copy of the License at
13 * http://www.apache.org/licenses/LICENSE-2.0
15 * Unless required by applicable law or agreed to in writing, software
16 * distributed under the License is distributed on an "AS IS" BASIS,
17 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
18 * See the License for the specific language governing permissions and
19 * limitations under the License.
21 * ECOMP is a trademark and service mark of AT&T Intellectual Property.
22 * ============LICENSE_END=========================================================
25 package org.openecomp.appc.workingstatemanager.impl;
27 import java.sql.Connection;
28 import java.sql.PreparedStatement;
29 import java.sql.ResultSet;
30 import java.sql.SQLException;
32 import java.util.concurrent.ConcurrentHashMap;
34 import org.apache.commons.lang.ObjectUtils;
35 import org.apache.commons.lang3.StringUtils;
36 import org.openecomp.appc.configuration.ConfigurationFactory;
37 import org.openecomp.appc.executor.objects.Params;
38 import org.openecomp.appc.message.RequestHandlerMessages;
39 import org.openecomp.appc.util.MessageFormatter;
40 import org.openecomp.appc.workingstatemanager.objects.VNFWorkingState;
41 import org.openecomp.appc.workingstatemanager.objects.VnfWorkingStateDto;
42 import com.att.eelf.configuration.EELFLogger;
43 import com.att.eelf.configuration.EELFManager;
44 import org.apache.commons.lang3.StringUtils;
47 public class WorkingStateManagerImpl extends JdbcWorkingStateManager {
49 private static final String SQL_RETRIEVE_VNF_STATE_MANAGEMENT = "SELECT VNF_ID,STATE,OWNER_ID,UPDATED,VER FROM VNF_STATE_MANAGEMENT WHERE VNF_ID=?";
50 private static final String SQL_INSERT_VNF_STATE_MANAGEMENT = "INSERT IGNORE INTO VNF_STATE_MANAGEMENT (VNF_ID,STATE,OWNER_ID,UPDATED,VER) VALUES (?, ?, ?, ?, ?)";
51 private static final String SQL_UPDATE_VNF_STATE_MANAGEMENT = "UPDATE VNF_STATE_MANAGEMENT SET OWNER_ID=?, UPDATED=?, STATE=?, VER=? WHERE VNF_ID=? AND VER=?";
52 private static final String SQL_CURRENT_TIMESTAMP = "SELECT CURRENT_TIMESTAMP()";
53 private static int maxAttempts = ConfigurationFactory.getConfiguration().getIntegerProperty("org.openecomp.appc.workingstatemanager.maxAttempts",20);
55 private static Map<String,VNFWorkingState> workingStateMap = new ConcurrentHashMap<>();
56 private static final EELFLogger logger = EELFManager.getInstance().getLogger(WorkingStateManagerImpl.class);
60 * Return true if vnf state exists in working state map and state is STABLE else return false. If vnf does not exists in working state map throws vnf not found exception.
61 * @param vnfId vnf Id to be verified for stable state
62 * @return True if vnf Exists and state is STABLE else False.
65 public boolean isVNFStable(String vnfId){
66 if (logger.isTraceEnabled()) {
67 logger.trace("Entering to isVNFStable with vnfId = "+ vnfId);
69 Connection connection = null;
70 boolean vnfStable = false;
72 connection = openDbConnection();
73 VnfWorkingStateDto vnfWorkingStateDto = retrieveVnfWorkingState(connection, vnfId);
74 vnfStable = isVNFStable(vnfWorkingStateDto);
75 } catch (SQLException e) {
76 String errMsg = StringUtils.isEmpty(e.getMessage())? e.toString() :e.getMessage();
77 throw new RuntimeException(errMsg);
79 if(connection != null) {
80 closeDbConnection(connection);
83 if (logger.isTraceEnabled()) {
84 logger.trace("Exiting from isVNFStable for vnfId = "+ vnfId+" with Result = "+vnfStable);
90 * Updates working state for given vnf Id. Returns true if update was allowed and succeeded. Update will success only if the existing vnf state is 'STABLE' or
91 * if the registered ownerId is equal to the given ownerId or if the forceFlag is true.
92 * Note on case of simultaneously updates the latest updates will be failed, and another attempts will be done after refetching the updated data from persistent store.
93 * @param vnfId vnf Id to be updated
94 * @param workingState new working state
96 * @param forceFlag - force to update also on case given onwerId is different then the registered one
99 public boolean setWorkingState(String vnfId, VNFWorkingState workingState, String ownerId, boolean forceFlag){
100 boolean updated = false;
101 if (logger.isTraceEnabled()) {
102 logger.trace("Entering to setWorkingState with vnfId = "+ ObjectUtils.toString(vnfId)+ ", VNFWorkingState = " + workingState.name() + ", ownerId = "+ownerId+", forceFlag = "+forceFlag);
104 Connection connection = null;
106 connection = openDbConnection();
107 updated = setWorkingStateIfStableOrSameOwnerIdOrForce(connection, vnfId, workingState, ownerId, forceFlag, maxAttempts);
108 } catch (SQLException e) {
109 String errMsg = StringUtils.isEmpty(e.getMessage())? e.toString() :e.getMessage();
110 throw new RuntimeException(errMsg);
112 if(connection != null) {
113 closeDbConnection(connection);
117 logger.trace("setWorkingState exit with output updated = "+updated);
121 public boolean setWorkingStateIfStableOrSameOwnerIdOrForce(Connection connection, String vnfId, VNFWorkingState workingState, String ownerId, boolean forceFlag, int maxAttempts) throws SQLException {
122 return setWorkingStateIfStableOrSameOwnerIdOrForce(connection, vnfId, workingState, ownerId, forceFlag,1,maxAttempts);
124 public boolean setWorkingStateIfStableOrSameOwnerIdOrForce(Connection connection, String vnfId, VNFWorkingState workingState, String ownerId, boolean forceFlag,int attempt, int maxAttempts) throws SQLException {
125 boolean updated = false;
126 VnfWorkingStateDto vnfWorkingStateDto = retrieveVnfWorkingState(connection, vnfId);
127 Long currentVersion = vnfWorkingStateDto != null ? vnfWorkingStateDto.getVer() : null;
128 if(forceFlag || isVNFStable(vnfWorkingStateDto) || vnfWorkingStateDto.getOwnerId().equals(ownerId)){
129 updated = storeWorkingStateIfSameVersion(connection, vnfId, workingState, ownerId, currentVersion);
131 Params params = new Params().addParam("vnfId", vnfId).addParam("workingState",workingState.name())
132 .addParam("attempt",attempt).addParam("maxAttempts",maxAttempts).addParam("ownerId",ownerId).addParam("forceFlag",forceFlag);
135 logMessage = MessageFormatter.format(RequestHandlerMessages.VNF_WORKING_STATE_UPDATED, params.getParams());
137 logMessage = MessageFormatter.format(RequestHandlerMessages.VNF_WORKING_STATE_WAS_NOT_UPDATED, params.getParams());
139 logger.debug(logMessage);
140 if(!updated && attempt<maxAttempts){
141 setWorkingStateIfStableOrSameOwnerIdOrForce(connection, vnfId, workingState, ownerId, forceFlag,++attempt,maxAttempts);
149 public boolean storeWorkingStateIfSameVersion(Connection connection, String vnfId, VNFWorkingState workingState, String ownerId, Long currentVersion) throws SQLException {
150 boolean stored = false;
151 if (currentVersion != null) {
152 stored = updateStateIfSameVersion(connection, vnfId, ownerId, workingState.name(), currentVersion);
154 stored = addVnfWorkingStateIfNotExists(connection, vnfId, ownerId, workingState.name());
160 private boolean isVNFStable(VnfWorkingStateDto vnfWorkingStateDto) {
161 if( vnfWorkingStateDto == null || vnfWorkingStateDto.getState() ==VNFWorkingState.STABLE){
167 public boolean updateStateIfSameVersion(Connection connection, String vnfId, String ownerId, String state, long currentVer) throws SQLException {
168 try(PreparedStatement statement = connection.prepareStatement(SQL_UPDATE_VNF_STATE_MANAGEMENT)) {
169 long newVer = (currentVer >= Long.MAX_VALUE) ? 1 : (currentVer + 1);
170 statement.setString(1, ownerId);
171 statement.setLong(2, getCurrentTime(connection));
172 statement.setString(3, state);
173 statement.setLong(4, newVer);
174 statement.setString(5, vnfId);
175 statement.setLong(6, currentVer);
176 return (statement.executeUpdate() != 0);
180 protected VnfWorkingStateDto retrieveVnfWorkingState(Connection connection, String vnfId) throws SQLException {
181 VnfWorkingStateDto res = null;
183 try(PreparedStatement statement = connection.prepareStatement(SQL_RETRIEVE_VNF_STATE_MANAGEMENT)) { //VNF_ID,STATE,OWNER_ID,UPDATED,VER
184 statement.setString(1, vnfId);
185 try(ResultSet resultSet = statement.executeQuery()) {
186 if(resultSet.next()) {
187 res = new VnfWorkingStateDto(vnfId);
188 String stateString = resultSet.getString(2);
189 VNFWorkingState vnfWorkingState = VNFWorkingState.valueOf(stateString);
190 res.setState(vnfWorkingState);
191 res.setOwnerId(resultSet.getString(3));
192 res.setUpdated(resultSet.getLong(4));
193 res.setVer(resultSet.getLong(5));
200 private long getCurrentTime(Connection connection) throws SQLException {
202 if(connection != null) {
203 try(PreparedStatement statement = connection.prepareStatement(SQL_CURRENT_TIMESTAMP)) {
204 try(ResultSet resultSet = statement.executeQuery()) {
205 if(resultSet.next()) {
206 res = resultSet.getTimestamp(1).getTime();
212 res = System.currentTimeMillis();
217 protected boolean addVnfWorkingStateIfNotExists(Connection connection, String vnfId, String ownerId, String state) throws SQLException {
218 boolean added = false;
219 try(PreparedStatement statement = connection.prepareStatement(SQL_INSERT_VNF_STATE_MANAGEMENT)) { //VNF_ID,STATE,OWNER_ID,UPDATED,VER
220 statement.setString(1, vnfId);
221 statement.setString(2, state);
222 statement.setString(3, ownerId);
223 statement.setLong(4, getCurrentTime(connection));
224 statement.setLong(5, 1L);
225 int rowCount = statement.executeUpdate();
226 added = rowCount != 0 ? true : false;