1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
|
/*-
* ============LICENSE_START=======================================================
* guard
* ================================================================================
* Copyright (C) 2017 AT&T Intellectual Property. All rights reserved.
* ================================================================================
* 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=========================================================
*/
package org.onap.policy.guard;
import java.util.HashMap;
import java.util.Map;
import java.util.UUID;
import org.onap.policy.controlloop.policy.TargetType;
import org.onap.policy.guard.impl.PNFTargetLock;
import org.onap.policy.guard.impl.VMTargetLock;
import org.onap.policy.guard.impl.VNFTargetLock;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
public class PolicyGuard {
private PolicyGuard() {
// Cannot instantiate this static class
}
private static Map<String, TargetLock> activeLocks = new HashMap<>();
private static final Logger logger = LoggerFactory.getLogger(PolicyGuard.class);
public static class LockResult<A, B> {
private A parameterA;
private B parameterB;
public static <A, B> LockResult<A, B> createLockResult(A parameterA, B parameterB) {
return new LockResult<>(parameterA, parameterB);
}
public LockResult(A parameterA, B parameterB) {
this.parameterA = parameterA;
this.parameterB = parameterB;
}
public A getA() {
return parameterA;
}
public B getB() {
return parameterB;
}
}
/**
* Lock a target.
*
* @param targetType the target type
* @param targetInstance the target instance
* @param requestID the request Id
* @param callback the LockCallback
* @return the LockResult
*/
public static LockResult<GuardResult, TargetLock> lockTarget(TargetType targetType, String targetInstance,
UUID requestID, LockCallback callback) {
synchronized (activeLocks) {
//
// Is there a lock on this instance already?
//
if (activeLocks.containsKey(targetInstance)) {
return LockResult.createLockResult(GuardResult.LOCK_DENIED, null);
}
TargetLock lock = null;
switch (targetType) {
case PNF:
//
// Create the Lock object
//
lock = new PNFTargetLock(targetType, targetInstance, requestID, callback);
break;
case VM:
//
// Create the Lock object
//
lock = new VMTargetLock(targetType, targetInstance, requestID, callback);
break;
case VNF:
//
// Create the Lock object
//
lock = new VNFTargetLock(targetType, targetInstance, requestID, callback);
break;
default:
return LockResult.createLockResult(GuardResult.LOCK_EXCEPTION, null);
}
//
// Keep track of it
//
activeLocks.put(targetInstance, lock);
//
// Return result
//
logger.debug("Locking {}", lock);
return LockResult.createLockResult(GuardResult.LOCK_ACQUIRED, lock);
}
}
/**
* Unlock a target.
*
* @param lock the target lock to unlock
* @return <code>true</code> if the target is successfully unlocked, <code>false</code>
* otherwise
*/
public static boolean unlockTarget(TargetLock lock) {
synchronized (activeLocks) {
if (activeLocks.containsKey(lock.getTargetInstance())) {
logger.debug("Unlocking {}", lock);
return (activeLocks.remove(lock.getTargetInstance()) != null);
}
return false;
}
}
/**
* Check if a target is locked.
*
* @param targetType the target type
* @param targetInstance the target instance
* @param requestID the request Id
* @return <code>true</code> if the target is locked, <code>false</code> otherwise
*/
public static boolean isLocked(TargetType targetType, String targetInstance, UUID requestID) {
synchronized (activeLocks) {
if (activeLocks.containsKey(targetInstance)) {
TargetLock lock = activeLocks.get(targetInstance);
return (lock.getTargetType().equals(targetType) && lock.getRequestID().equals(requestID));
}
return false;
}
}
}
|
