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
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
|
/*-
* ============LICENSE_START=======================================================
* Copyright (C) 2021 Nordix Foundation.
* ================================================================================
* 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.
*
* SPDX-License-Identifier: Apache-2.0
* ============LICENSE_END=========================================================
*/
package org.onap.policy.clamp.controlloop.runtime.commissioning;
import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.PropertyNamingStrategies;
import com.fasterxml.jackson.module.jsonSchema.JsonSchema;
import com.fasterxml.jackson.module.jsonSchema.factories.SchemaFactoryWrapper;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;
import org.apache.commons.collections4.CollectionUtils;
import org.apache.commons.collections4.MapUtils;
import org.onap.policy.clamp.controlloop.models.controlloop.persistence.provider.ControlLoopProvider;
import org.onap.policy.clamp.controlloop.models.messages.rest.commissioning.CommissioningResponse;
import org.onap.policy.models.base.PfModelException;
import org.onap.policy.models.provider.PolicyModelsProvider;
import org.onap.policy.models.tosca.authorative.concepts.ToscaCapabilityType;
import org.onap.policy.models.tosca.authorative.concepts.ToscaConceptIdentifier;
import org.onap.policy.models.tosca.authorative.concepts.ToscaDataType;
import org.onap.policy.models.tosca.authorative.concepts.ToscaNodeTemplate;
import org.onap.policy.models.tosca.authorative.concepts.ToscaNodeType;
import org.onap.policy.models.tosca.authorative.concepts.ToscaPolicyType;
import org.onap.policy.models.tosca.authorative.concepts.ToscaRelationshipType;
import org.onap.policy.models.tosca.authorative.concepts.ToscaServiceTemplate;
import org.onap.policy.models.tosca.authorative.concepts.ToscaServiceTemplates;
import org.onap.policy.models.tosca.authorative.concepts.ToscaTopologyTemplate;
import org.onap.policy.models.tosca.authorative.concepts.ToscaTypedEntityFilter;
import org.springframework.stereotype.Component;
/**
* This class provides the create, read and delete actions on Commissioning of Control Loop concepts in the database to
* the callers.
*/
@Component
public class CommissioningProvider {
public static final String CONTROL_LOOP_NODE_TYPE = "org.onap.policy.clamp.controlloop.ControlLoop";
private final PolicyModelsProvider modelsProvider;
private final ControlLoopProvider clProvider;
private static final Object lockit = new Object();
/**
* Create a commissioning provider.
*
* @param modelsProvider the PolicyModelsProvider
* @param clProvider the ControlLoopProvider
*/
public CommissioningProvider(PolicyModelsProvider modelsProvider, ControlLoopProvider clProvider) {
this.modelsProvider = modelsProvider;
this.clProvider = clProvider;
}
/**
* Create control loops from a service template.
*
* @param serviceTemplate the service template
* @return the result of the commissioning operation
* @throws PfModelException on creation errors
*/
public CommissioningResponse createControlLoopDefinitions(ToscaServiceTemplate serviceTemplate)
throws PfModelException {
synchronized (lockit) {
modelsProvider.createServiceTemplate(serviceTemplate);
}
var response = new CommissioningResponse();
// @formatter:off
response.setAffectedControlLoopDefinitions(serviceTemplate.getToscaTopologyTemplate().getNodeTemplates()
.values()
.stream()
.map(template -> template.getKey().asIdentifier())
.collect(Collectors.toList()));
// @formatter:on
return response;
}
/**
* Delete the control loop definition with the given name and version.
*
* @param name the name of the control loop definition to delete
* @param version the version of the control loop to delete
* @return the result of the deletion
* @throws PfModelException on deletion errors
*/
public CommissioningResponse deleteControlLoopDefinition(String name, String version) throws PfModelException {
synchronized (lockit) {
modelsProvider.deleteServiceTemplate(name, version);
}
var response = new CommissioningResponse();
response.setAffectedControlLoopDefinitions(
Collections.singletonList(new ToscaConceptIdentifier(name, version)));
return response;
}
/**
* Get control loop node templates.
*
* @param clName the name of the control loop, null for all
* @param clVersion the version of the control loop, null for all
* @return list of control loop node templates
* @throws PfModelException on errors getting control loop definitions
*/
public List<ToscaNodeTemplate> getControlLoopDefinitions(String clName, String clVersion) throws PfModelException {
// @formatter:off
ToscaTypedEntityFilter<ToscaNodeTemplate> nodeTemplateFilter = ToscaTypedEntityFilter
.<ToscaNodeTemplate>builder()
.name(clName)
.version(clVersion)
.type(CONTROL_LOOP_NODE_TYPE)
.build();
// @formatter:on
return clProvider.getFilteredNodeTemplates(nodeTemplateFilter);
}
/**
* Get the control loop elements from a control loop node template.
*
* @param controlLoopNodeTemplate the control loop node template
* @return a list of the control loop element node templates in a control loop node template
* @throws PfModelException on errors get control loop element node templates
*/
public List<ToscaNodeTemplate> getControlLoopElementDefinitions(ToscaNodeTemplate controlLoopNodeTemplate)
throws PfModelException {
if (!CONTROL_LOOP_NODE_TYPE.equals(controlLoopNodeTemplate.getType())) {
return Collections.emptyList();
}
if (MapUtils.isEmpty(controlLoopNodeTemplate.getProperties())) {
return Collections.emptyList();
}
@SuppressWarnings("unchecked")
List<Map<String, String>> controlLoopElements =
(List<Map<String, String>>) controlLoopNodeTemplate.getProperties().get("elements");
if (CollectionUtils.isEmpty(controlLoopElements)) {
return Collections.emptyList();
}
List<ToscaNodeTemplate> controlLoopElementList = new ArrayList<>();
// @formatter:off
controlLoopElementList.addAll(
controlLoopElements
.stream()
.map(elementMap -> clProvider.getNodeTemplates(elementMap.get("name"),
elementMap.get("version")))
.flatMap(List::stream)
.collect(Collectors.toList())
);
// @formatter:on
return controlLoopElementList;
}
/**
* Get the requested control loop definitions.
*
* @param name the name of the definition to get, null for all definitions
* @param version the version of the definition to get, null for all definitions
* @return the control loop definitions
* @throws PfModelException on errors getting control loop definitions
*/
public ToscaServiceTemplate getToscaServiceTemplate(String name, String version) throws PfModelException {
var serviceTemplates = new ToscaServiceTemplates();
serviceTemplates.setServiceTemplates(modelsProvider.getServiceTemplateList(name, version));
return serviceTemplates.getServiceTemplates().get(0);
}
/**
* Get the requested json schema.
*
* @param section section of the tosca service template to get schema for
* @return the specified tosca service template or section Json Schema
* @throws PfModelException on errors with retrieving the classes
* @throws JsonProcessingException on errors generating the schema
*/
public String getToscaServiceTemplateSchema(String section) throws PfModelException, JsonProcessingException {
ObjectMapper mapper = new ObjectMapper();
mapper.setPropertyNamingStrategy(PropertyNamingStrategies.SNAKE_CASE);
SchemaFactoryWrapper visitor = new SchemaFactoryWrapper();
switch (section) {
case "data_types":
mapper.acceptJsonFormatVisitor(mapper.constructType(ToscaDataType.class), visitor);
break;
case "capability_types":
mapper.acceptJsonFormatVisitor(mapper.constructType(ToscaCapabilityType.class), visitor);
break;
case "node_types":
mapper.acceptJsonFormatVisitor(mapper.constructType(ToscaNodeType.class), visitor);
break;
case "relationship_types":
mapper.acceptJsonFormatVisitor(mapper.constructType(ToscaRelationshipType.class), visitor);
break;
case "policy_types":
mapper.acceptJsonFormatVisitor(mapper.constructType(ToscaPolicyType.class), visitor);
break;
case "topology_template":
mapper.acceptJsonFormatVisitor(mapper.constructType(ToscaTopologyTemplate.class), visitor);
break;
case "node_templates":
mapper.acceptJsonFormatVisitor(mapper.getTypeFactory()
.constructCollectionType(List.class, ToscaNodeTemplate.class), visitor);
break;
default:
mapper.acceptJsonFormatVisitor(mapper.constructType(ToscaServiceTemplate.class), visitor);
}
JsonSchema jsonSchema = visitor.finalSchema();
String response = mapper.writerWithDefaultPrettyPrinter().writeValueAsString(jsonSchema);
return response;
}
}
|
