<inherited>false</inherited>
<executions>
<execution>
- <id>push-policy-agent-image</id>
+ <id>push-near-rt-ric-simulator-image</id>
<goals>
<goal>build</goal>
<goal>push</goal>
<pushRegistry>${env.CONTAINER_PUSH_REGISTRY}</pushRegistry>
<images>
<image>
- <name>o-ran-sc/policy-agent:${project.version}</name>
+ <name>o-ran-sc/near-rt-ric-simulator:${project.version}</name>
<build>
<contextDir>${basedir}/ric-plt/a1</contextDir>
<dockerFile>Dockerfile</dockerFile>
package org.oransc.policyagent;
-import org.oransc.policyagent.clients.A1Client;
-import org.oransc.policyagent.clients.A1ClientImpl;
+import org.oransc.policyagent.clients.A1ClientFactory;
import org.oransc.policyagent.configuration.ApplicationConfig;
import org.oransc.policyagent.repository.Policies;
import org.oransc.policyagent.repository.PolicyTypes;
}
@Bean
- A1Client getA1Client() {
- return new A1ClientImpl();
+ A1ClientFactory getA1ClientFactory() {
+ return new A1ClientFactory();
}
}
public interface A1Client {
- public Mono<Collection<String>> getPolicyTypeIdentities(String nearRtRicUrl);
+ public static enum A1ProtocolType {
+ UNKNOWN, STD_V1
+ }
- public Mono<Collection<String>> getPolicyIdentities(String nearRtRicUrl);
+ public Mono<A1ProtocolType> getProtocolVersion();
- public Mono<String> getPolicyType(String nearRtRicUrl, String policyTypeId);
+ public Mono<Collection<String>> getPolicyTypeIdentities();
+
+ public Mono<Collection<String>> getPolicyIdentities();
+
+ public Mono<String> getPolicyTypeSchema(String policyTypeId);
public Mono<String> putPolicy(Policy policy);
- public Mono<String> deletePolicy(String nearRtRicUrl, String policyId);
+ public Mono<String> deletePolicy(String policyId);
}
--- /dev/null
+/*-
+ * ========================LICENSE_START=================================
+ * O-RAN-SC
+ * %%
+ * Copyright (C) 2019 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.
+ * ========================LICENSE_END===================================
+ */
+
+package org.oransc.policyagent.clients;
+
+import org.oransc.policyagent.clients.A1Client.A1ProtocolType;
+import org.oransc.policyagent.exceptions.ServiceException;
+import org.oransc.policyagent.repository.Ric;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import reactor.core.publisher.Mono;
+
+public class A1ClientFactory {
+
+ private static final Logger logger = LoggerFactory.getLogger(A1ClientFactory.class);
+
+ public Mono<A1Client> createA1Client(Ric ric) {
+ return getProtocolVersion(ric) //
+ .flatMap(version -> createA1Client(ric, version));
+ }
+
+ private Mono<A1Client> createA1Client(Ric ric, A1ProtocolType version) {
+ if (version == A1ProtocolType.STD_V1) {
+ return Mono.just(createStdA1ClientImpl(ric));
+ }
+ return Mono.error(new ServiceException("Not supported protocoltype: " + version));
+ }
+
+ private Mono<A1Client.A1ProtocolType> getProtocolVersion(Ric ric) {
+ if (ric.getProtocolVersion() == A1ProtocolType.UNKNOWN) {
+ return fetchVersion(ric, new OscA1Client(ric.getConfig())) //
+ .onErrorResume(err -> fetchVersion(ric, createStdA1ClientImpl(ric)))
+ .doOnNext(version -> ric.setProtocolVersion(version))
+ .doOnNext(version -> logger.debug("Recover ric: {}, protocol version:{}", ric.name(), version)) //
+ .doOnError(t -> logger.warn("Could not get protocol version from RIC: {}", ric.name())); //
+ } else {
+ return Mono.just(ric.getProtocolVersion());
+ }
+ }
+
+ protected A1Client createStdA1ClientImpl(Ric ric) {
+ return new StdA1Client(ric.getConfig());
+ }
+
+ private Mono<A1Client.A1ProtocolType> fetchVersion(Ric ric, A1Client a1Client) {
+ return Mono.just(a1Client) //
+ .flatMap(client -> a1Client.getProtocolVersion());
+ }
+
+}
--- /dev/null
+/*-
+ * ========================LICENSE_START=================================
+ * O-RAN-SC
+ * %%
+ * Copyright (C) 2019 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.
+ * ========================LICENSE_END===================================
+ */
+
+package org.oransc.policyagent.clients;
+
+import java.lang.invoke.MethodHandles;
+import java.util.Collection;
+
+import org.oransc.policyagent.configuration.RicConfig;
+import org.oransc.policyagent.repository.Policy;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import reactor.core.publisher.Mono;
+
+public class OscA1Client implements A1Client {
+ private static final Logger logger = LoggerFactory.getLogger(MethodHandles.lookup().lookupClass());
+
+ private final RicConfig ricConfig;
+
+ public OscA1Client(RicConfig ricConfig) {
+ this.ricConfig = ricConfig;
+ logger.debug("OscA1Client for ric: {}", this.ricConfig.name());
+ }
+
+ @Override
+ public Mono<Collection<String>> getPolicyTypeIdentities() {
+ return Mono.error(new Exception("Not impl"));
+ }
+
+ @Override
+ public Mono<Collection<String>> getPolicyIdentities() {
+ return Mono.error(new Exception("Not impl"));
+ }
+
+ @Override
+ public Mono<String> getPolicyTypeSchema(String policyTypeId) {
+ return Mono.error(new Exception("Not impl"));
+ }
+
+ @Override
+ public Mono<String> putPolicy(Policy policy) {
+ return Mono.error(new Exception("Not impl"));
+ }
+
+ @Override
+ public Mono<String> deletePolicy(String policyId) {
+ return Mono.error(new Exception("Not impl"));
+ }
+
+ @Override
+ public Mono<A1ProtocolType> getProtocolVersion() {
+ return Mono.error(new Exception("Not impl"));
+ }
+
+}
import org.json.JSONArray;
import org.json.JSONException;
import org.json.JSONObject;
+import org.oransc.policyagent.configuration.RicConfig;
import org.oransc.policyagent.repository.Policy;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import reactor.core.publisher.Mono;
-public class A1ClientImpl implements A1Client {
+public class StdA1Client implements A1Client {
private static final Logger logger = LoggerFactory.getLogger(MethodHandles.lookup().lookupClass());
- private static String getBaseUrl(final String nearRtRicUrl) {
- return nearRtRicUrl + "/A1-P/v1";
+ private final RicConfig ricConfig;
+ private final AsyncRestClient restClient;
+
+ public StdA1Client(RicConfig ricConfig) {
+ this.ricConfig = ricConfig;
+ this.restClient = new AsyncRestClient(getBaseUrl());
}
- protected AsyncRestClient createClient(final String nearRtRicUrl) {
- return new AsyncRestClient(getBaseUrl(nearRtRicUrl));
+ public StdA1Client(RicConfig ricConfig, AsyncRestClient restClient) {
+ this.ricConfig = ricConfig;
+ this.restClient = restClient;
}
@Override
- public Mono<Collection<String>> getPolicyTypeIdentities(String nearRtRicUrl) {
- logger.debug("getPolicyTypeIdentities nearRtRicUrl = {}", nearRtRicUrl);
- AsyncRestClient client = createClient(nearRtRicUrl);
- return client.get("/policytypes/identities") //
+ public Mono<Collection<String>> getPolicyTypeIdentities() {
+ logger.debug("getPolicyTypeIdentities nearRtRicUrl = {}", ricConfig.baseUrl());
+ return restClient.get("/policytypes/identities") //
.flatMap(this::parseJsonArrayOfString);
}
@Override
- public Mono<Collection<String>> getPolicyIdentities(String nearRtRicUrl) {
- logger.debug("getPolicyIdentities nearRtRicUrl = {}", nearRtRicUrl);
- AsyncRestClient client = createClient(nearRtRicUrl);
- return client.get("/policies/identities") //
+ public Mono<Collection<String>> getPolicyIdentities() {
+ logger.debug("getPolicyIdentities nearRtRicUrl = {}", ricConfig.baseUrl());
+ return restClient.get("/policies/identities") //
.flatMap(this::parseJsonArrayOfString);
}
@Override
- public Mono<String> getPolicyType(String nearRtRicUrl, String policyTypeId) {
- logger.debug("getPolicyType nearRtRicUrl = {}, policyTypeId = {}", nearRtRicUrl, policyTypeId);
- AsyncRestClient client = createClient(nearRtRicUrl);
- Mono<String> response = client.get("/policytypes/" + policyTypeId);
+ public Mono<String> getPolicyTypeSchema(String policyTypeId) {
+ logger.debug("getPolicyType nearRtRicUrl = {}, policyTypeId = {}", ricConfig.baseUrl(), policyTypeId);
+ Mono<String> response = restClient.get("/policytypes/" + policyTypeId);
return response.flatMap(this::createMono);
}
public Mono<String> putPolicy(Policy policy) {
logger.debug("putPolicy nearRtRicUrl = {}, policyId = {}, policyString = {}", //
policy.ric().getConfig().baseUrl(), policy.id(), policy.json());
- AsyncRestClient client = createClient(policy.ric().getConfig().baseUrl());
// TODO update when simulator is updated to include policy type
// Mono<String> response = client.put("/policies/" + policy.id() + "?policyTypeId=" + policy.type().name(),
// policy.json());
- Mono<String> response = client.put("/policies/" + policy.id(), policy.json());
+ Mono<String> response = restClient.put("/policies/" + policy.id(), policy.json());
return response.flatMap(this::createMono);
}
@Override
- public Mono<String> deletePolicy(String nearRtRicUrl, String policyId) {
- logger.debug("deletePolicy nearRtRicUrl = {}, policyId = {}", nearRtRicUrl, policyId);
- AsyncRestClient client = createClient(nearRtRicUrl);
- return client.delete("/policies/" + policyId);
+ public Mono<String> deletePolicy(String policyId) {
+ logger.debug("deletePolicy nearRtRicUrl = {}, policyId = {}", ricConfig.baseUrl(), policyId);
+ return restClient.delete("/policies/" + policyId);
+ }
+
+ @Override
+ public Mono<A1ProtocolType> getProtocolVersion() {
+ return getPolicyTypeIdentities() //
+ .flatMap(x -> Mono.just(A1ProtocolType.STD_V1));
+ }
+
+ private String getBaseUrl() {
+ return ricConfig.baseUrl() + "/A1-P/v1";
}
private Mono<Collection<String>> parseJsonArrayOfString(String inputString) {
return Mono.error(ex);
}
}
+
}
import java.util.Collection;
import java.util.HashMap;
import java.util.Map;
-import java.util.Optional;
import java.util.Vector;
import javax.validation.constraints.NotEmpty;
return this.filepath;
}
- public synchronized void setFilepath(String filepath) {
- this.filepath = filepath;
- }
-
public synchronized Collection<RicConfig> getRicConfigs() {
return this.ricConfigs.values();
}
- public synchronized Optional<RicConfig> lookupRicConfigForManagedElement(String managedElementId) {
- for (RicConfig ricConfig : getRicConfigs()) {
- if (ricConfig.managedElementIds().contains(managedElementId)) {
- return Optional.of(ricConfig);
- }
- }
- return Optional.empty();
- }
-
public RicConfig getRic(String ricName) throws ServiceException {
for (RicConfig ricConfig : getRicConfigs()) {
if (ricConfig.name().equals(ricName)) {
public String baseUrl();
public Vector<String> managedElementIds();
+
}
import java.util.Collection;
import java.util.Vector;
-import org.oransc.policyagent.clients.A1Client;
+import org.oransc.policyagent.clients.A1ClientFactory;
import org.oransc.policyagent.configuration.ApplicationConfig;
import org.oransc.policyagent.exceptions.ServiceException;
import org.oransc.policyagent.repository.ImmutablePolicy;
private final Rics rics;
private final PolicyTypes policyTypes;
private final Policies policies;
- private final A1Client a1Client;
+ private final A1ClientFactory a1ClientFactory;
private static Gson gson = new GsonBuilder() //
.serializeNulls() //
.create(); //
@Autowired
- PolicyController(ApplicationConfig config, PolicyTypes types, Policies policies, Rics rics, A1Client a1Client) {
+ PolicyController(ApplicationConfig config, PolicyTypes types, Policies policies, Rics rics,
+ A1ClientFactory a1ClientFactory) {
this.policyTypes = types;
this.policies = policies;
this.rics = rics;
- this.a1Client = a1Client;
+ this.a1ClientFactory = a1ClientFactory;
}
@GetMapping("/policy_schemas")
Policy policy = policies.get(id);
if (policy != null && policy.ric().state().equals(Ric.RicState.IDLE)) {
policies.remove(policy);
- return a1Client.deletePolicy(policy.ric().getConfig().baseUrl(), id) //
+ return a1ClientFactory.createA1Client(policy.ric()) //
+ .flatMap(client -> client.deletePolicy(id)) //
.flatMap(notUsed -> {
return Mono.just(new ResponseEntity<>(HttpStatus.NO_CONTENT));
});
.ownerServiceName(service) //
.lastModified(getTimeStampUTC()) //
.build();
- return a1Client.putPolicy(policy) //
+ return a1ClientFactory.createA1Client(ric) //
+ .flatMap(client -> client.putPolicy(policy)) //
.doOnNext(notUsed -> policies.put(policy)) //
.flatMap(notUsed -> {
return Mono.just(new ResponseEntity<>(HttpStatus.CREATED));
import java.util.Vector;
import org.oransc.policyagent.configuration.ApplicationConfig;
-import org.oransc.policyagent.configuration.RicConfig;
import org.oransc.policyagent.repository.Ric;
import org.oransc.policyagent.repository.Rics;
import org.springframework.beans.factory.annotation.Autowired;
@Api(value = "RIC Management API")
public class RicRepositoryController {
- private final ApplicationConfig appConfig;
-
@Autowired
private Rics rics;
@Autowired
RicRepositoryController(ApplicationConfig appConfig) {
- this.appConfig = appConfig;
}
/**
public ResponseEntity<String> getRic(
@RequestParam(name = "managedElementId", required = false, defaultValue = "") String managedElementId) {
- Optional<RicConfig> config = appConfig.lookupRicConfigForManagedElement(managedElementId);
+ Optional<Ric> ric = this.rics.lookupRicForManagedElement(managedElementId);
- if (config.isPresent()) {
- return new ResponseEntity<>(config.get().name(), HttpStatus.OK);
+ if (ric.isPresent()) {
+ return new ResponseEntity<>(ric.get().name(), HttpStatus.OK);
} else {
return new ResponseEntity<>("", HttpStatus.NOT_FOUND);
}
import java.util.Map;
import java.util.Vector;
+import org.oransc.policyagent.clients.A1Client.A1ProtocolType;
import org.oransc.policyagent.configuration.RicConfig;
/**
private final RicConfig ricConfig;
private RicState state = RicState.UNDEFINED;
private Map<String, PolicyType> supportedPolicyTypes = new HashMap<>();
+ private A1ProtocolType protocolVersion = A1ProtocolType.UNKNOWN;
/**
* Creates the Ric. Initial state is {@link RicState.NOT_INITIATED}.
*/
RECOVERING
}
+
+ public A1ProtocolType getProtocolVersion() {
+ return protocolVersion;
+ }
+
+ public void setProtocolVersion(A1ProtocolType version) {
+ protocolVersion = version;
+
+ }
+
}
import java.util.HashMap;
import java.util.Map;
+import java.util.Optional;
import org.oransc.policyagent.exceptions.ServiceException;
public synchronized void clear() {
this.rics.clear();
}
+
+ public synchronized Optional<Ric> lookupRicForManagedElement(String managedElementId) {
+ for (Ric ric : this.rics.values()) {
+ if (ric.getConfig().managedElementIds().contains(managedElementId)) {
+ return Optional.of(ric);
+ }
+ }
+ return Optional.empty();
+ }
}
import java.util.Collection;
import org.oransc.policyagent.clients.A1Client;
+import org.oransc.policyagent.clients.A1ClientFactory;
import org.oransc.policyagent.repository.Policies;
import org.oransc.policyagent.repository.PolicyTypes;
import org.oransc.policyagent.repository.Ric;
private final Rics rics;
private final Policies policies;
private final PolicyTypes policyTypes;
- private final A1Client a1Client;
+ private final A1ClientFactory a1ClientFactory;
private final Services services;
@Autowired
- public RepositorySupervision(Rics rics, Policies policies, A1Client a1Client, PolicyTypes policyTypes,
+ public RepositorySupervision(Rics rics, Policies policies, A1ClientFactory a1ClientFactory, PolicyTypes policyTypes,
Services services) {
this.rics = rics;
this.policies = policies;
- this.a1Client = a1Client;
+ this.a1ClientFactory = a1ClientFactory;
this.policyTypes = policyTypes;
this.services = services;
}
createTask().subscribe(this::onRicChecked, this::onError, this::onComplete);
}
- private Flux<Ric> createTask() {
+ private Flux<RicData> createTask() {
synchronized (this.rics) {
return Flux.fromIterable(rics.getRics()) //
- .flatMap(ric -> checkRicState(ric)) //
- .flatMap(ric -> checkRicPolicies(ric)) //
- .flatMap(ric -> checkRicPolicyTypes(ric));
+ .flatMap(ric -> createRicData(ric)) //
+ .flatMap(ricData -> checkRicState(ricData)) //
+ .flatMap(ricData -> checkRicPolicies(ricData)) //
+ .flatMap(ricData -> checkRicPolicyTypes(ricData));
}
}
- private Mono<Ric> checkRicState(Ric ric) {
- if (ric.state() == RicState.UNDEFINED) {
+ private static class RicData {
+ RicData(Ric ric, A1Client a1Client) {
+ this.ric = ric;
+ this.a1Client = a1Client;
+ }
+
+ final Ric ric;
+ final A1Client a1Client;
+ }
+
+ private Mono<RicData> createRicData(Ric ric) {
+ return Mono.just(ric) //
+ .flatMap(aRic -> this.a1ClientFactory.createA1Client(ric)) //
+ .flatMap(a1Client -> Mono.just(new RicData(ric, a1Client)));
+ }
+
+ private Mono<RicData> checkRicState(RicData ric) {
+ if (ric.ric.state() == RicState.UNDEFINED) {
return startRecovery(ric);
- } else if (ric.state() == RicState.RECOVERING) {
+ } else if (ric.ric.state() == RicState.RECOVERING) {
return Mono.empty();
} else {
return Mono.just(ric);
}
}
- private Mono<Ric> checkRicPolicies(Ric ric) {
- return a1Client.getPolicyIdentities(ric.getConfig().baseUrl()) //
+ private Mono<RicData> checkRicPolicies(RicData ric) {
+ return ric.a1Client.getPolicyIdentities() //
.onErrorResume(t -> Mono.empty()) //
.flatMap(ricP -> validateInstances(ricP, ric));
}
- private Mono<Ric> validateInstances(Collection<String> ricPolicies, Ric ric) {
+ private Mono<RicData> validateInstances(Collection<String> ricPolicies, RicData ric) {
synchronized (this.policies) {
- if (ricPolicies.size() != policies.getForRic(ric.name()).size()) {
+ if (ricPolicies.size() != policies.getForRic(ric.ric.name()).size()) {
return startRecovery(ric);
}
}
return Mono.just(ric);
}
- private Mono<Ric> checkRicPolicyTypes(Ric ric) {
- return a1Client.getPolicyTypeIdentities(ric.getConfig().baseUrl()) //
+ private Mono<RicData> checkRicPolicyTypes(RicData ric) {
+ return ric.a1Client.getPolicyTypeIdentities() //
.onErrorResume(t -> {
return Mono.empty();
}) //
.flatMap(ricTypes -> validateTypes(ricTypes, ric));
}
- private Mono<Ric> validateTypes(Collection<String> ricTypes, Ric ric) {
- if (ricTypes.size() != ric.getSupportedPolicyTypes().size()) {
+ private Mono<RicData> validateTypes(Collection<String> ricTypes, RicData ric) {
+ if (ricTypes.size() != ric.ric.getSupportedPolicyTypes().size()) {
return startRecovery(ric);
}
for (String typeName : ricTypes) {
- if (!ric.isSupportingType(typeName)) {
+ if (!ric.ric.isSupportingType(typeName)) {
return startRecovery(ric);
}
}
return Mono.just(ric);
}
- private Mono<Ric> startRecovery(Ric ric) {
- RicRecoveryTask recovery = new RicRecoveryTask(a1Client, policyTypes, policies, services);
- recovery.run(ric);
+ private Mono<RicData> startRecovery(RicData ric) {
+ RicRecoveryTask recovery = new RicRecoveryTask(a1ClientFactory, policyTypes, policies, services);
+ recovery.run(ric.ric);
return Mono.empty();
}
- private void onRicChecked(Ric ric) {
- logger.info("Ric: " + ric.name() + " checked");
+ private void onRicChecked(RicData ric) {
+ logger.info("Ric: " + ric.ric.name() + " checked");
}
private void onError(Throwable t) {
import java.util.Vector;
import org.oransc.policyagent.clients.A1Client;
+import org.oransc.policyagent.clients.A1ClientFactory;
import org.oransc.policyagent.clients.AsyncRestClient;
import org.oransc.policyagent.exceptions.ServiceException;
import org.oransc.policyagent.repository.ImmutablePolicyType;
private static final Logger logger = LoggerFactory.getLogger(RicRecoveryTask.class);
- private final A1Client a1Client;
+ private final A1ClientFactory a1ClientFactory;
private final PolicyTypes policyTypes;
private final Policies policies;
private final Services services;
- public RicRecoveryTask(A1Client a1Client, PolicyTypes policyTypes, Policies policies, Services services) {
- this.a1Client = a1Client;
+ public RicRecoveryTask(A1ClientFactory a1ClientFactory, PolicyTypes policyTypes, Policies policies,
+ Services services) {
+ this.a1ClientFactory = a1ClientFactory;
this.policyTypes = policyTypes;
this.policies = policies;
this.services = services;
}
ric.setState(Ric.RicState.RECOVERING);
}
- Flux<PolicyType> recoverTypes = recoverPolicyTypes(ric);
- Flux<?> deletePoliciesInRic = deleteAllPoliciesInRic(ric);
- Flux<?> recreatePoliciesInRic = recreateAllPoliciesInRic(ric);
-
- Flux.concat(recoverTypes, deletePoliciesInRic, recreatePoliciesInRic) //
+ this.a1ClientFactory.createA1Client(ric)//
+ .flatMapMany(client -> startRecover(ric, client)) //
.subscribe(x -> logger.debug("Recover: " + x), //
throwable -> onRecoveryError(ric, throwable), //
() -> onRecoveryComplete(ric));
}
+ private Flux<Object> startRecover(Ric ric, A1Client a1Client) {
+ Flux<PolicyType> recoverTypes = recoverPolicyTypes(ric, a1Client);
+ Flux<?> deletePoliciesInRic = deleteAllPoliciesInRic(ric, a1Client);
+ Flux<?> recreatePoliciesInRic = recreateAllPoliciesInRic(ric, a1Client);
+
+ return Flux.concat(recoverTypes, deletePoliciesInRic, recreatePoliciesInRic);
+ }
+
private void onRecoveryComplete(Ric ric) {
logger.debug("Recovery completed for:" + ric.name());
ric.setState(Ric.RicState.IDLE);
private void onRecoveryError(Ric ric, Throwable t) {
logger.warn("Recovery failed for: {}, reason: {}", ric.name(), t.getMessage());
-
// If recovery fails, try to remove all instances
deleteAllPolicies(ric);
- Flux<PolicyType> recoverTypes = recoverPolicyTypes(ric);
- Flux<?> deletePoliciesInRic = deleteAllPoliciesInRic(ric);
+ Flux<PolicyType> recoverTypes = this.a1ClientFactory.createA1Client(ric) //
+ .flatMapMany(a1Client -> recoverPolicyTypes(ric, a1Client));
+ Flux<?> deletePoliciesInRic = this.a1ClientFactory.createA1Client(ric) //
+ .flatMapMany(a1Client -> deleteAllPoliciesInRic(ric, a1Client));
Flux.merge(recoverTypes, deletePoliciesInRic) //
.subscribe(x -> logger.debug("Brute recover: " + x), //
return new AsyncRestClient(url);
}
- private Flux<PolicyType> recoverPolicyTypes(Ric ric) {
+ private Flux<PolicyType> recoverPolicyTypes(Ric ric, A1Client a1Client) {
ric.clearSupportedPolicyTypes();
- return a1Client.getPolicyTypeIdentities(ric.getConfig().baseUrl()) //
+ return a1Client.getPolicyTypeIdentities() //
.flatMapMany(types -> Flux.fromIterable(types)) //
.doOnNext(typeId -> logger.debug("For ric: {}, handling type: {}", ric.getConfig().name(), typeId)) //
- .flatMap((policyTypeId) -> getPolicyType(ric, policyTypeId)) //
+ .flatMap((policyTypeId) -> getPolicyType(ric, policyTypeId, a1Client)) //
.doOnNext(policyType -> ric.addSupportedPolicyType(policyType)); //
}
- private Mono<PolicyType> getPolicyType(Ric ric, String policyTypeId) {
+ private Mono<PolicyType> getPolicyType(Ric ric, String policyTypeId, A1Client a1Client) {
if (policyTypes.contains(policyTypeId)) {
try {
return Mono.just(policyTypes.getType(policyTypeId));
return Mono.error(e);
}
}
- return a1Client.getPolicyType(ric.getConfig().baseUrl(), policyTypeId) //
+ return a1Client.getPolicyTypeSchema(policyTypeId) //
.flatMap(schema -> createPolicyType(policyTypeId, schema));
}
}
}
- private Flux<String> deleteAllPoliciesInRic(Ric ric) {
- return a1Client.getPolicyIdentities(ric.getConfig().baseUrl()) //
+ private Flux<String> deleteAllPoliciesInRic(Ric ric, A1Client a1Client) {
+ return a1Client.getPolicyIdentities() //
.flatMapMany(policyIds -> Flux.fromIterable(policyIds)) //
.doOnNext(policyId -> logger.debug("Deleting policy: {}, for ric: {}", policyId, ric.getConfig().name()))
- .flatMap(policyId -> a1Client.deletePolicy(ric.getConfig().baseUrl(), policyId)); //
+ .flatMap(policyId -> a1Client.deletePolicy(policyId)); //
}
- private Flux<String> recreateAllPoliciesInRic(Ric ric) {
+ private Flux<String> recreateAllPoliciesInRic(Ric ric, A1Client a1Client) {
synchronized (policies) {
return Flux.fromIterable(new Vector<>(policies.getForRic(ric.name()))) //
.doOnNext(
package org.oransc.policyagent.tasks;
-import org.oransc.policyagent.clients.A1Client;
+import org.oransc.policyagent.clients.A1ClientFactory;
import org.oransc.policyagent.repository.Policies;
import org.oransc.policyagent.repository.Policy;
import org.oransc.policyagent.repository.Service;
private static final Logger logger = LoggerFactory.getLogger(ServiceSupervision.class);
private final Services services;
private final Policies policies;
- private A1Client a1Client;
+ private A1ClientFactory a1ClientFactory;
@Autowired
- public ServiceSupervision(Services services, Policies policies, A1Client a1Client) {
+ public ServiceSupervision(Services services, Policies policies, A1ClientFactory a1ClientFactory) {
this.services = services;
this.policies = policies;
- this.a1Client = a1Client;
+ this.a1ClientFactory = a1ClientFactory;
}
@Scheduled(fixedRate = 1000 * 60)
}
private Mono<Policy> deletePolicyInRic(Policy policy) {
- return a1Client.deletePolicy(policy.ric().getConfig().baseUrl(), policy.id()) //
- .onErrorResume(exception -> handleDeleteFromRicFailure(policy, exception)) //
- .map((nothing) -> policy);
+ return a1ClientFactory.createA1Client(policy.ric()) //
+ .flatMap(client -> client.deletePolicy(policy.id()) //
+ .onErrorResume(exception -> handleDeleteFromRicFailure(policy, exception)) //
+ .map((nothing) -> policy));
}
private Mono<String> handleDeleteFromRicFailure(Policy policy, Throwable e) {
package org.oransc.policyagent.tasks;
-import org.oransc.policyagent.clients.A1Client;
+import org.oransc.policyagent.clients.A1ClientFactory;
import org.oransc.policyagent.configuration.ApplicationConfig;
import org.oransc.policyagent.configuration.RicConfig;
import org.oransc.policyagent.repository.Policies;
PolicyTypes policyTypes;
@Autowired
- private A1Client a1Client;
+ private A1ClientFactory a1ClientFactory;
@Autowired
private Policies policies;
// Only for unittesting
StartupService(ApplicationConfig appConfig, RefreshConfigTask refreshTask, Rics rics, PolicyTypes policyTypes,
- A1Client a1Client, Policies policies, Services services) {
+ A1ClientFactory a1ClientFactory, Policies policies, Services services) {
this.applicationConfig = appConfig;
this.refreshConfigTask = refreshTask;
this.rics = rics;
this.policyTypes = policyTypes;
- this.a1Client = a1Client;
+ this.a1ClientFactory = a1ClientFactory;
this.policies = policies;
this.services = services;
}
|| event.equals(ApplicationConfig.RicConfigUpdate.CHANGED)) {
Ric ric = new Ric(ricConfig);
rics.put(ric);
- RicRecoveryTask recoveryTask = new RicRecoveryTask(a1Client, policyTypes, policies, services);
+ RicRecoveryTask recoveryTask = new RicRecoveryTask(a1ClientFactory, policyTypes, policies, services);
recoveryTask.run(ric);
} else if (event.equals(ApplicationConfig.RicConfigUpdate.REMOVED)) {
rics.remove(ricConfig.name());
import com.google.gson.GsonBuilder;
import com.google.gson.reflect.TypeToken;
-import java.net.URL;
import java.util.List;
import java.util.Vector;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
-import org.oransc.policyagent.clients.A1Client;
import org.oransc.policyagent.configuration.ApplicationConfig;
import org.oransc.policyagent.configuration.ImmutableRicConfig;
import org.oransc.policyagent.configuration.RicConfig;
import org.oransc.policyagent.repository.Rics;
import org.oransc.policyagent.tasks.RepositorySupervision;
import org.oransc.policyagent.utils.MockA1Client;
+import org.oransc.policyagent.utils.MockA1ClientFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.boot.test.context.SpringBootTest.WebEnvironment;
private PolicyTypes policyTypes;
@Autowired
- MockA1Client a1Client;
+ MockA1ClientFactory a1ClientFactory;
@Autowired
RepositorySupervision supervision;
public static class MockApplicationConfig extends ApplicationConfig {
@Override
public String getLocalConfigurationFilePath() {
- URL url = MockApplicationConfig.class.getClassLoader().getResource("test_application_configuration.json");
- return url.getFile();
+ return ""; // No config file loaded for the test
}
}
}
@Bean
- A1Client getA1Client() {
- return new MockA1Client(this.policyTypes);
+ MockA1ClientFactory getA1ClientFactory() {
+ return new MockA1ClientFactory(this.policyTypes);
}
@Bean
public void testRecovery() throws Exception {
reset();
Policy policy = addPolicy("policyId", "typeName", "service", "ric"); // This should be created in the RIC
-
Policy policy2 = addPolicy("policyId2", "typeName", "service", "ric");
- a1Client.putPolicy("ric", policy2); // put it in the RIC
+
+ getA1Client("ric").putPolicy(policy2); // put it in the RIC
policies.remove(policy2); // Remove it from the repo -> should be deleted in the RIC
supervision.checkAllRics(); // The created policy should be put in the RIC
- Policies ricPolicies = a1Client.getPolicies("ric");
+ Policies ricPolicies = getA1Client("ric").getPolicies();
assertThat(ricPolicies.size()).isEqualTo(1);
Policy ricPolicy = ricPolicies.get("policyId");
assertThat(ricPolicy.json()).isEqualTo(policy.json());
}
+ MockA1Client getA1Client(String ricName) throws ServiceException {
+ return a1ClientFactory.getOrCreateA1Client(ricName);
+ }
+
@Test
public void testGetRic() throws Exception {
reset();
+ Ric ric = addRic("ric1");
+ ric.addManagedElement("kista_1");
String url = baseUrl() + "/ric?managedElementId=kista_1";
+
String rsp = this.restTemplate.getForObject(url, String.class);
System.out.println(rsp);
+
assertThat(rsp).isEqualTo("ric1");
}
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
-import org.oransc.policyagent.clients.A1Client;
import org.oransc.policyagent.configuration.ApplicationConfig;
import org.oransc.policyagent.repository.ImmutablePolicyType;
import org.oransc.policyagent.repository.Policies;
import org.oransc.policyagent.repository.PolicyType;
import org.oransc.policyagent.repository.PolicyTypes;
import org.oransc.policyagent.repository.Rics;
-import org.oransc.policyagent.utils.MockA1Client;
+import org.oransc.policyagent.utils.MockA1ClientFactory;
+import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.boot.test.context.SpringBootTest.WebEnvironment;
import org.springframework.boot.test.context.TestConfiguration;
@SpringBootTest(webEnvironment = WebEnvironment.DEFINED_PORT)
public class MockPolicyAgent {
+ @Autowired
+ Rics rics;
+
static class MockApplicationConfig extends ApplicationConfig {
@Override
public String getLocalConfigurationFilePath() {
}
@Bean
- public A1Client getA1Client() {
+ public MockA1ClientFactory getA1ClientFactory() {
PolicyTypes ricTypes = new PolicyTypes();
loadTypes(ricTypes);
- A1Client client = new MockA1Client(ricTypes);
- return client;
+ return new MockA1ClientFactory(ricTypes);
}
@Bean
package org.oransc.policyagent.clients;
import static org.mockito.ArgumentMatchers.anyString;
-import static org.mockito.Mockito.doReturn;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.spy;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import org.junit.runner.RunWith;
-import org.mockito.Mock;
-import org.mockito.Spy;
import org.mockito.junit.MockitoJUnitRunner;
import org.mockito.junit.jupiter.MockitoExtension;
import org.oransc.policyagent.configuration.ImmutableRicConfig;
@ExtendWith(MockitoExtension.class)
@RunWith(MockitoJUnitRunner.class)
-public class A1ClientImplTest {
+public class StdA1ClientTest {
private static final String RIC_URL = "RicUrl";
private static final String POLICYTYPES_IDENTITIES_URL = "/policytypes/identities";
private static final String POLICIES_IDENTITIES_URL = "/policies/identities";
private static final String POLICY_JSON_INVALID = "\"policyId\":\"policy1\"}";
private static final String POLICY_TYPE = "typeName";
- @Spy
- A1ClientImpl a1Client;
+ StdA1Client a1Client;
- @Mock
AsyncRestClient asyncRestClientMock;
@BeforeEach
public void init() {
- doReturn(asyncRestClientMock).when(a1Client).createClient(RIC_URL);
+ asyncRestClientMock = mock(AsyncRestClient.class);
+ a1Client = spy(new StdA1Client(createRic(RIC_URL).getConfig(), asyncRestClientMock));
}
@Test
Mono<String> policyTypeIds = Mono.just(Arrays.toString(new String[] {POLICY_TYPE_1_NAME, POLICY_TYPE_2_NAME}));
when(asyncRestClientMock.get(POLICYTYPES_IDENTITIES_URL)).thenReturn(policyTypeIds);
- Mono<?> policyTypeIdsFlux = a1Client.getPolicyTypeIdentities(RIC_URL);
+ Mono<?> policyTypeIdsFlux = a1Client.getPolicyTypeIdentities();
verify(asyncRestClientMock).get(POLICYTYPES_IDENTITIES_URL);
StepVerifier.create(policyTypeIdsFlux).expectNextCount(1).expectComplete().verify();
}
Mono<String> policyIds = Mono.just(Arrays.toString(new String[] {POLICY_1_ID, POLICY_2_ID}));
when(asyncRestClientMock.get(POLICIES_IDENTITIES_URL)).thenReturn(policyIds);
- Mono<?> policyIdsFlux = a1Client.getPolicyIdentities(RIC_URL);
+ Mono<?> policyIdsFlux = a1Client.getPolicyIdentities();
verify(asyncRestClientMock).get(POLICIES_IDENTITIES_URL);
StepVerifier.create(policyIdsFlux).expectNextCount(1).expectComplete().verify();
}
when(asyncRestClientMock.get(POLICYTYPES_URL + POLICY_TYPE_1_NAME))
.thenReturn(Mono.just(POLICY_TYPE_SCHEMA_VALID));
- Mono<String> policyTypeMono = a1Client.getPolicyType(RIC_URL, POLICY_TYPE_1_NAME);
+ Mono<String> policyTypeMono = a1Client.getPolicyTypeSchema(POLICY_TYPE_1_NAME);
verify(asyncRestClientMock).get(POLICYTYPES_URL + POLICY_TYPE_1_NAME);
StepVerifier.create(policyTypeMono).expectNext(POLICY_TYPE_SCHEMA_VALID).expectComplete().verify();
}
when(asyncRestClientMock.get(POLICYTYPES_URL + POLICY_TYPE_1_NAME))
.thenReturn(Mono.just(POLICY_TYPE_SCHEMA_INVALID));
- Mono<String> policyTypeMono = a1Client.getPolicyType(RIC_URL, POLICY_TYPE_1_NAME);
+ Mono<String> policyTypeMono = a1Client.getPolicyTypeSchema(POLICY_TYPE_1_NAME);
verify(asyncRestClientMock).get(POLICYTYPES_URL + POLICY_TYPE_1_NAME);
StepVerifier.create(policyTypeMono).expectErrorMatches(throwable -> throwable instanceof JSONException)
.verify();
public void testDeletePolicy() {
when(asyncRestClientMock.delete(POLICIES_URL + POLICY_1_ID)).thenReturn(Mono.empty());
- Mono<?> responseMono = a1Client.deletePolicy(RIC_URL, POLICY_1_ID);
+ Mono<?> responseMono = a1Client.deletePolicy(POLICY_1_ID);
verify(asyncRestClientMock).delete(POLICIES_URL + POLICY_1_ID);
StepVerifier.create(responseMono).expectComplete().verify();
}
import static org.awaitility.Awaitility.await;
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.ArgumentMatchers.anyString;
+import static org.mockito.Mockito.doReturn;
+import static org.mockito.Mockito.times;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.verifyNoMoreInteractions;
-import static org.mockito.Mockito.when;
import java.util.Arrays;
import java.util.Collection;
import java.util.Vector;
+import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import org.junit.runner.RunWith;
import org.mockito.junit.MockitoJUnitRunner;
import org.mockito.junit.jupiter.MockitoExtension;
import org.oransc.policyagent.clients.A1Client;
+import org.oransc.policyagent.clients.A1ClientFactory;
import org.oransc.policyagent.configuration.ImmutableRicConfig;
import org.oransc.policyagent.repository.ImmutablePolicy;
import org.oransc.policyagent.repository.ImmutablePolicyType;
@Mock
A1Client a1ClientMock;
+ @Mock
+ A1ClientFactory a1ClientFactory;
+
+ @BeforeEach
+ public void init() {
+ doReturn(Mono.just(a1ClientMock)).when(a1ClientFactory).createA1Client(any());
+ }
+
@Test
public void test() {
Ric ric1 = new Ric(ImmutableRicConfig.builder() //
Services services = new Services();
RepositorySupervision supervisorUnderTest =
- new RepositorySupervision(rics, policies, a1ClientMock, types, services);
+ new RepositorySupervision(rics, policies, a1ClientFactory, types, services);
Mono<Collection<String>> policyIds = Mono.just(Arrays.asList("policyId1", "policyId2"));
- when(a1ClientMock.getPolicyIdentities(anyString())).thenReturn(policyIds);
- when(a1ClientMock.deletePolicy(anyString(), anyString())).thenReturn(Mono.empty());
- when(a1ClientMock.getPolicyTypeIdentities(anyString())).thenReturn(policyIds);
- when(a1ClientMock.getPolicyType(anyString(), anyString())).thenReturn(Mono.just("schema"));
- when(a1ClientMock.putPolicy(any())).thenReturn(Mono.just("OK"));
+
+ doReturn(policyIds).when(a1ClientMock).getPolicyTypeIdentities();
+ doReturn(policyIds).when(a1ClientMock).getPolicyIdentities();
+ doReturn(Mono.empty()).when(a1ClientMock).deletePolicy(anyString());
+ doReturn(Mono.just("schema")).when(a1ClientMock).getPolicyTypeSchema(anyString());
+ doReturn(Mono.just("OK")).when(a1ClientMock).putPolicy(any());
supervisorUnderTest.checkAllRics();
await().untilAsserted(() -> RicState.IDLE.equals(ric2.state()));
await().untilAsserted(() -> RicState.IDLE.equals(ric3.state()));
- verify(a1ClientMock).deletePolicy("baseUrl1", "policyId2");
- verify(a1ClientMock).deletePolicy("baseUrl2", "policyId2");
+ verify(a1ClientMock, times(3)).deletePolicy("policyId2");
verifyNoMoreInteractions(a1ClientMock);
}
}
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertNotNull;
import static org.junit.jupiter.api.Assertions.assertTrue;
+import static org.mockito.ArgumentMatchers.any;
import static org.mockito.ArgumentMatchers.anyString;
import static org.mockito.Mockito.doReturn;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.times;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;
import static org.oransc.policyagent.repository.Ric.RicState.IDLE;
import java.util.Collection;
import java.util.Vector;
+import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import org.junit.runner.RunWith;
-import org.mockito.Mock;
import org.mockito.junit.MockitoJUnitRunner;
import org.mockito.junit.jupiter.MockitoExtension;
import org.oransc.policyagent.clients.A1Client;
+import org.oransc.policyagent.clients.A1ClientFactory;
import org.oransc.policyagent.configuration.ApplicationConfig;
import org.oransc.policyagent.configuration.ImmutableRicConfig;
import org.oransc.policyagent.configuration.RicConfig;
private static final String POLICY_ID_1 = "policy1";
private static final String POLICY_ID_2 = "policy2";
- @Mock
ApplicationConfig appConfigMock;
-
- @Mock
RefreshConfigTask refreshTaskMock;
- @Mock
A1Client a1ClientMock;
+ A1ClientFactory a1ClientFactory;
+
+ @BeforeEach
+ public void init() throws Exception {
+ a1ClientMock = mock(A1Client.class);
+ a1ClientFactory = mock(A1ClientFactory.class);
+ appConfigMock = mock(ApplicationConfig.class);
+ refreshTaskMock = mock(RefreshConfigTask.class);
+ doReturn(Mono.just(a1ClientMock)).when(a1ClientFactory).createA1Client(any());
+ }
@Test
public void startup_allOk() {
Mono<Collection<String>> policyTypes1 = Mono.just(Arrays.asList(POLICY_TYPE_1_NAME));
Mono<Collection<String>> policyTypes2 = Mono.just(Arrays.asList(POLICY_TYPE_1_NAME, POLICY_TYPE_2_NAME));
- when(a1ClientMock.getPolicyTypeIdentities(anyString())).thenReturn(policyTypes1).thenReturn(policyTypes2);
+ doReturn(policyTypes1, policyTypes2).when(a1ClientMock).getPolicyTypeIdentities();
Mono<Collection<String>> policies = Mono.just(Arrays.asList(POLICY_ID_1, POLICY_ID_2));
- when(a1ClientMock.getPolicyIdentities(anyString())).thenReturn(policies);
- when(a1ClientMock.getPolicyType(anyString(), anyString())).thenReturn(Mono.just("Schema"));
- when(a1ClientMock.deletePolicy(anyString(), anyString())).thenReturn(Mono.just("OK"));
+ doReturn(policies).when(a1ClientMock).getPolicyIdentities();
+ doReturn(Mono.just("Schema")).when(a1ClientMock).getPolicyTypeSchema(anyString());
+ doReturn(Mono.just("OK")).when(a1ClientMock).deletePolicy(anyString());
Rics rics = new Rics();
PolicyTypes policyTypes = new PolicyTypes();
StartupService serviceUnderTest = new StartupService(appConfigMock, refreshTaskMock, rics, policyTypes,
- a1ClientMock, new Policies(), new Services());
+ a1ClientFactory, new Policies(), new Services());
serviceUnderTest.startup();
await().untilAsserted(() -> assertThat(policyTypes.size()).isEqualTo(2));
- verify(a1ClientMock).getPolicyTypeIdentities(FIRST_RIC_URL);
- verify(a1ClientMock).deletePolicy(FIRST_RIC_URL, POLICY_ID_1);
- verify(a1ClientMock).deletePolicy(FIRST_RIC_URL, POLICY_ID_2);
-
- verify(a1ClientMock).getPolicyTypeIdentities(SECOND_RIC_URL);
- verify(a1ClientMock).deletePolicy(SECOND_RIC_URL, POLICY_ID_1);
- verify(a1ClientMock).deletePolicy(SECOND_RIC_URL, POLICY_ID_2);
+ verify(a1ClientMock, times(2)).getPolicyTypeIdentities();
+ verify(a1ClientMock, times(2)).deletePolicy(POLICY_ID_1);
+ verify(a1ClientMock, times(2)).deletePolicy(POLICY_ID_2);
assertTrue(policyTypes.contains(POLICY_TYPE_1_NAME), POLICY_TYPE_1_NAME + " not added to PolicyTypes.");
assertTrue(policyTypes.contains(POLICY_TYPE_2_NAME), POLICY_TYPE_2_NAME + " not added to PolicyTypes.");
@Test
public void startup_unableToConnectToGetTypes() {
Mono<?> error = Mono.error(new Exception("Unable to contact ric."));
- doReturn(error, error).when(a1ClientMock).getPolicyTypeIdentities(anyString());
- doReturn(error).when(a1ClientMock).getPolicyIdentities(anyString());
+ doReturn(error, error).when(a1ClientMock).getPolicyTypeIdentities();
+ doReturn(error).when(a1ClientMock).getPolicyIdentities();
Rics rics = new Rics();
PolicyTypes policyTypes = new PolicyTypes();
StartupService serviceUnderTest = new StartupService(appConfigMock, refreshTaskMock, rics, policyTypes,
- a1ClientMock, new Policies(), new Services());
+ a1ClientFactory, new Policies(), new Services());
serviceUnderTest.startup();
serviceUnderTest.onRicConfigUpdate(getRicConfig(FIRST_RIC_NAME, FIRST_RIC_URL, MANAGED_NODE_A),
public void startup_unableToConnectToGetPolicies() {
Mono<Collection<String>> policyTypes = Mono.just(Arrays.asList(POLICY_TYPE_1_NAME));
- when(a1ClientMock.getPolicyTypeIdentities(anyString())).thenReturn(policyTypes);
- when(a1ClientMock.getPolicyType(anyString(), anyString())).thenReturn(Mono.just("Schema"));
+ when(a1ClientMock.getPolicyTypeIdentities()).thenReturn(policyTypes);
+ when(a1ClientMock.getPolicyTypeSchema(anyString())).thenReturn(Mono.just("Schema"));
Mono<?> error = Mono.error(new Exception("Unable to contact ric."));
- doReturn(error).when(a1ClientMock).getPolicyIdentities(anyString());
+ doReturn(error).when(a1ClientMock).getPolicyIdentities();
Rics rics = new Rics();
StartupService serviceUnderTest = new StartupService(appConfigMock, refreshTaskMock, rics, new PolicyTypes(),
- a1ClientMock, new Policies(), new Services());
+ a1ClientFactory, new Policies(), new Services());
serviceUnderTest.startup();
serviceUnderTest.onRicConfigUpdate(getRicConfig(FIRST_RIC_NAME, FIRST_RIC_URL, MANAGED_NODE_A),
package org.oransc.policyagent.utils;
import java.util.Collection;
-import java.util.HashMap;
-import java.util.Map;
import java.util.Vector;
import org.oransc.policyagent.clients.A1Client;
import reactor.core.publisher.Mono;
public class MockA1Client implements A1Client {
- private final Map<String, Policies> policies = new HashMap<>();
+ Policies policies = new Policies();
private final PolicyTypes policyTypes;
public MockA1Client(PolicyTypes policyTypes) {
}
@Override
- public Mono<Collection<String>> getPolicyTypeIdentities(String nearRtRicUrl) {
+ public Mono<Collection<String>> getPolicyTypeIdentities() {
synchronized (this.policyTypes) {
Vector<String> result = new Vector<>();
for (PolicyType p : this.policyTypes.getAll()) {
}
@Override
- public Mono<Collection<String>> getPolicyIdentities(String nearRtRicUrl) {
+ public Mono<Collection<String>> getPolicyIdentities() {
synchronized (this.policies) {
Vector<String> result = new Vector<>();
- for (Policy policy : getPolicies(nearRtRicUrl).getAll()) {
- if (policy.ric().getConfig().baseUrl().equals(nearRtRicUrl)) {
- result.add(policy.id());
- }
+ for (Policy policy : policies.getAll()) {
+ result.add(policy.id());
}
return Mono.just(result);
}
@Override
- public Mono<String> getPolicyType(String nearRtRicUrl, String policyTypeId) {
+ public Mono<String> getPolicyTypeSchema(String policyTypeId) {
try {
return Mono.just(this.policyTypes.getType(policyTypeId).schema());
} catch (Exception e) {
@Override
public Mono<String> putPolicy(Policy p) {
- getPolicies(p.ric().getConfig().baseUrl()).put(p);
+ this.policies.put(p);
return Mono.just("OK");
}
@Override
- public Mono<String> deletePolicy(String nearRtRicUrl, String policyId) {
- getPolicies(nearRtRicUrl).removeId(policyId);
+ public Mono<String> deletePolicy(String policyId) {
+ this.policies.removeId(policyId);
return Mono.just("OK");
}
- public Policies getPolicies(String url) {
- if (!policies.containsKey(url)) {
- policies.put(url, new Policies());
- }
- return policies.get(url);
+ public Policies getPolicies() {
+ return this.policies;
}
- public void putPolicy(String url, Policy policy) {
- getPolicies(url).put(policy);
+ @Override
+ public Mono<A1ProtocolType> getProtocolVersion() {
+ return Mono.just(A1ProtocolType.STD_V1);
}
}
--- /dev/null
+/*-
+ * ========================LICENSE_START=================================
+ * O-RAN-SC
+ * %%
+ * Copyright (C) 2019 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.
+ * ========================LICENSE_END===================================
+ */
+
+package org.oransc.policyagent.utils;
+
+import java.lang.invoke.MethodHandles;
+import java.util.HashMap;
+import java.util.Map;
+
+import org.oransc.policyagent.clients.A1Client;
+import org.oransc.policyagent.clients.A1ClientFactory;
+import org.oransc.policyagent.repository.PolicyTypes;
+import org.oransc.policyagent.repository.Ric;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+public class MockA1ClientFactory extends A1ClientFactory {
+ private static final Logger logger = LoggerFactory.getLogger(MethodHandles.lookup().lookupClass());
+ private final Map<String, MockA1Client> clients = new HashMap<>();
+ private final PolicyTypes policyTypes;
+
+ public MockA1ClientFactory(PolicyTypes policyTypes) {
+ this.policyTypes = policyTypes;
+ }
+
+ @Override
+ protected A1Client createStdA1ClientImpl(Ric ric) {
+ return getOrCreateA1Client(ric.name());
+ }
+
+ public MockA1Client getOrCreateA1Client(String ricName) {
+ if (!clients.containsKey(ricName)) {
+ logger.debug("Creating client for RIC: {}", ricName);
+ MockA1Client client = new MockA1Client(policyTypes);
+ clients.put(ricName, client);
+ }
+ return clients.get(ricName);
+ }
+
+}
}
]
}
-}
+}
\ No newline at end of file
<name>nonrtric</name>
<modules>
<module>policy-agent</module>
+ <module>sdnc-a1-controller</module>
<module>dashboard</module>
<module>near-rt-ric-simulator</module>
</modules>
\r
import ietf-yang-types { prefix yang; }\r
\r
- revision "2019-10-02" {\r
+ revision "2020-01-22" {\r
description\r
"A1 adapter";\r
}\r
\r
- //Flattend interface using RPC\r
-\r
- //Get an array of near-rt-ric IDs,\r
- //Each item in the returned array will be regarded as one near-rt-ric-id.\r
- rpc getNearRT-RICs {\r
- output {\r
- leaf-list near-rt-ric-id-list {\r
- type string;\r
- }\r
- leaf code {\r
- type string;\r
- }\r
- }\r
- }\r
-\r
- //Get health status for a Near-RT-RIC. true - health ok, false - health is not ok.\r
- rpc getHealthCheck {\r
- input {\r
- leaf near-rt-ric-id {\r
- type string;\r
- }\r
- }\r
-\r
- output {\r
- leaf health-status {\r
- type boolean;\r
- }\r
- leaf code {\r
- type string;\r
- }\r
- }\r
- }\r
-\r
//Get an array of integer policy type ids\r
//Each item in the returned array will be regarded as one policy-type-id.\r
- rpc getPolicyTypes {\r
+ rpc getPolicyTypeIdentities {\r
input {\r
- leaf near-rt-ric-id {\r
+ leaf near-rt-ric-url {\r
type string;\r
}\r
}\r
\r
output {\r
leaf-list policy-type-id-list {\r
- type uint32;\r
- }\r
- leaf code {\r
- type string;\r
- }\r
- }\r
- }\r
-\r
- //Create a policy type\r
- rpc createPolicyType {\r
- input {\r
- leaf near-rt-ric-id {\r
- type string;\r
- }\r
- leaf policy-type-id {\r
- type uint32;\r
- }\r
- leaf description {\r
- type string;\r
- }\r
- leaf name {\r
- type string;\r
- }\r
- leaf policy-type {\r
- type string;\r
- }\r
- }\r
- output {\r
- leaf code {\r
- type string;\r
- }\r
- }\r
- }\r
-\r
- //Get a policy type\r
- rpc getPolicyType {\r
- input {\r
- leaf near-rt-ric-id {\r
- type string;\r
- }\r
- leaf policy-type-id {\r
- type uint32;\r
- }\r
- }\r
- output {\r
- leaf description {\r
- type string;\r
- }\r
- leaf name {\r
- type string;\r
- }\r
- leaf policy-type {\r
- type string;\r
- }\r
- leaf code {\r
type string;\r
}\r
}\r
}\r
\r
- //Delete a policy type\r
- rpc deletePolicyType {\r
+ //Get an array of integer policy ids\r
+ //Each item in the returned array will be regarded as one policy-id.\r
+ rpc getPolicyIdentities {\r
input {\r
- leaf near-rt-ric-id {\r
+ leaf near-rt-ric-url {\r
type string;\r
}\r
- leaf policy-type-id {\r
- type uint32;\r
- }\r
- }\r
- output {\r
- leaf code {\r
- type string;\r
- }\r
- }\r
- }\r
-\r
- //Get an array of string policy instance ids\r
- //Each item in the returned array will be regarded as one policy-instance-id.\r
- rpc getPolicyInstances {\r
- input {\r
- leaf near-rt-ric-id {\r
- type string;\r
- }\r
- leaf policy-type-id {\r
- type uint32;\r
- }\r
}\r
\r
output {\r
- leaf-list policy-instance-id-list {\r
- type string;\r
- }\r
- leaf code {\r
+ leaf-list policy-id-list {\r
type string;\r
}\r
}\r
}\r
\r
- //Create a policy instance\r
- rpc createPolicyInstance {\r
+ //Get a policy type\r
+ rpc getPolicyType {\r
input {\r
- leaf near-rt-ric-id {\r
+ leaf near-rt-ric-url {\r
type string;\r
}\r
leaf policy-type-id {\r
- type uint32;\r
- }\r
- leaf policy-instance-id {\r
- type string;\r
- }\r
- leaf policy-instance {\r
type string;\r
}\r
}\r
output {\r
- leaf code {\r
+ leaf policy-type {\r
type string;\r
}\r
}\r
}\r
\r
- ///Get a policy instance\r
- rpc getPolicyInstance {\r
+ //Create a policy\r
+ rpc putPolicy {\r
input {\r
- leaf near-rt-ric-id {\r
+ leaf near-rt-ric-url {\r
type string;\r
}\r
- leaf policy-type-id {\r
- type uint32;\r
- }\r
- leaf policy-instance-id {\r
- type string;\r
- }\r
- }\r
- output {\r
- leaf policy-instance {\r
- type string;\r
- }\r
- leaf code {\r
- type string;\r
- }\r
- }\r
- }\r
-\r
- //Delete a policy instance\r
- rpc deletePolicyInstance {\r
- input {\r
- leaf near-rt-ric-id {\r
+ leaf policy-id {\r
type string;\r
}\r
- leaf policy-type-id {\r
- type uint32;\r
- }\r
- leaf policy-instance-id {\r
+ leaf policy {\r
type string;\r
}\r
}\r
output {\r
- leaf code {\r
+ leaf returned-policy {\r
type string;\r
}\r
}\r
}\r
\r
- //Get the status for a policy instance\r
- rpc getStatus {\r
+ //Delete a policy\r
+ rpc deletePolicy {\r
input {\r
- leaf near-rt-ric-id {\r
- type string;\r
- }\r
- leaf policy-type-id {\r
- type uint32;\r
- }\r
- leaf policy-instance-id {\r
- type string;\r
- }\r
- }\r
- output {\r
- leaf status {\r
+ leaf near-rt-ric-url {\r
type string;\r
}\r
- leaf code {\r
+ leaf policy-id {\r
type string;\r
}\r
}\r
+++ /dev/null
-package org.onap.sdnc.northbound.exceptions;
-
-public class NearRtRicNotFoundException extends RuntimeException {
-
- /**
- *
- */
- private static final long serialVersionUID = -4503072266424371087L;
-
- public NearRtRicNotFoundException(String message) {
- super(message);
- }
-
-}
import com.google.common.util.concurrent.CheckedFuture;
import com.google.common.util.concurrent.Futures;
import com.google.common.util.concurrent.ListenableFuture;
-import com.google.gson.Gson;
import java.text.DateFormat;
import java.text.SimpleDateFormat;
-import java.util.ArrayList;
import java.util.Date;
import java.util.List;
import java.util.TimeZone;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
-import org.json.JSONObject;
-import org.onap.sdnc.northbound.exceptions.NearRtRicNotFoundException;
-import org.onap.sdnc.northbound.restadpter.NearRicUrlProvider;
-import org.onap.sdnc.northbound.restadpter.RestAdapter;
-import org.onap.sdnc.northbound.restadpter.RestAdapterImpl;
+import org.onap.sdnc.northbound.restadapter.NearRicUrlProvider;
+import org.onap.sdnc.northbound.restadapter.RestAdapter;
+import org.onap.sdnc.northbound.restadapter.RestAdapterImpl;
import org.opendaylight.controller.md.sal.binding.api.DataBroker;
import org.opendaylight.controller.md.sal.binding.api.NotificationPublishService;
import org.opendaylight.controller.md.sal.binding.api.WriteTransaction;
import org.opendaylight.controller.md.sal.common.api.data.TransactionCommitFailedException;
import org.opendaylight.controller.sal.binding.api.BindingAwareBroker;
import org.opendaylight.controller.sal.binding.api.RpcProviderRegistry;
-import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.a1.adapter.rev191002.A1ADAPTERAPIService;
-import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.a1.adapter.rev191002.CreatePolicyInstanceInput;
-import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.a1.adapter.rev191002.CreatePolicyInstanceOutput;
-import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.a1.adapter.rev191002.CreatePolicyInstanceOutputBuilder;
-import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.a1.adapter.rev191002.CreatePolicyTypeInput;
-import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.a1.adapter.rev191002.CreatePolicyTypeOutput;
-import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.a1.adapter.rev191002.CreatePolicyTypeOutputBuilder;
-import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.a1.adapter.rev191002.DeletePolicyInstanceInput;
-import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.a1.adapter.rev191002.DeletePolicyInstanceOutput;
-import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.a1.adapter.rev191002.DeletePolicyInstanceOutputBuilder;
-import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.a1.adapter.rev191002.DeletePolicyTypeInput;
-import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.a1.adapter.rev191002.DeletePolicyTypeOutput;
-import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.a1.adapter.rev191002.DeletePolicyTypeOutputBuilder;
-import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.a1.adapter.rev191002.GetHealthCheckInput;
-import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.a1.adapter.rev191002.GetHealthCheckOutput;
-import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.a1.adapter.rev191002.GetHealthCheckOutputBuilder;
-import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.a1.adapter.rev191002.GetNearRTRICsInput;
-import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.a1.adapter.rev191002.GetNearRTRICsOutput;
-import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.a1.adapter.rev191002.GetNearRTRICsOutputBuilder;
-import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.a1.adapter.rev191002.GetPolicyInstanceInput;
-import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.a1.adapter.rev191002.GetPolicyInstanceOutput;
-import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.a1.adapter.rev191002.GetPolicyInstanceOutputBuilder;
-import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.a1.adapter.rev191002.GetPolicyInstancesInput;
-import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.a1.adapter.rev191002.GetPolicyInstancesOutput;
-import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.a1.adapter.rev191002.GetPolicyInstancesOutputBuilder;
-import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.a1.adapter.rev191002.GetPolicyTypeInput;
-import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.a1.adapter.rev191002.GetPolicyTypeOutput;
-import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.a1.adapter.rev191002.GetPolicyTypeOutputBuilder;
-import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.a1.adapter.rev191002.GetPolicyTypesInput;
-import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.a1.adapter.rev191002.GetPolicyTypesOutput;
-import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.a1.adapter.rev191002.GetPolicyTypesOutputBuilder;
-import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.a1.adapter.rev191002.GetStatusInput;
-import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.a1.adapter.rev191002.GetStatusOutput;
-import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.a1.adapter.rev191002.GetStatusOutputBuilder;
+import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.a1.adapter.rev200122.A1ADAPTERAPIService;
+import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.a1.adapter.rev200122.DeletePolicyInput;
+import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.a1.adapter.rev200122.DeletePolicyOutput;
+import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.a1.adapter.rev200122.DeletePolicyOutputBuilder;
+import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.a1.adapter.rev200122.GetPolicyIdentitiesInput;
+import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.a1.adapter.rev200122.GetPolicyIdentitiesOutput;
+import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.a1.adapter.rev200122.GetPolicyIdentitiesOutputBuilder;
+import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.a1.adapter.rev200122.GetPolicyTypeIdentitiesInput;
+import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.a1.adapter.rev200122.GetPolicyTypeIdentitiesOutput;
+import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.a1.adapter.rev200122.GetPolicyTypeIdentitiesOutputBuilder;
+import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.a1.adapter.rev200122.GetPolicyTypeInput;
+import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.a1.adapter.rev200122.GetPolicyTypeOutput;
+import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.a1.adapter.rev200122.GetPolicyTypeOutputBuilder;
+import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.a1.adapter.rev200122.PutPolicyInput;
+import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.a1.adapter.rev200122.PutPolicyOutput;
+import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.a1.adapter.rev200122.PutPolicyOutputBuilder;
import org.opendaylight.yangtools.yang.common.RpcResult;
import org.opendaylight.yangtools.yang.common.RpcResultBuilder;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
-import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
-import org.springframework.web.client.RestClientResponseException;
/**
* Defines a base implementation for your provider. This class overrides the generated interface
}
@Override
- public ListenableFuture<RpcResult<CreatePolicyInstanceOutput>> createPolicyInstance(
- CreatePolicyInstanceInput input) {
- log.info("Start of createPolicyInstance");
- CreatePolicyInstanceOutputBuilder responseBuilder = new CreatePolicyInstanceOutputBuilder();
- try {
- String uri = nearRicUrlProvider.getPolicyInstanceId(String.valueOf(input.getNearRtRicId()),
- String.valueOf(input.getPolicyTypeId()), String.valueOf(input.getPolicyInstanceId()));
- log.info("PUT Request input.getPolicyInstance() : {} ", input.getPolicyInstance());
- ResponseEntity<Void> response = restAdapter.put(uri, input.getPolicyInstance());
- responseBuilder.setCode(response.getStatusCode().toString());
- } catch (NearRtRicNotFoundException ex) {
- log.error("Caught exception: {}", ex);
- responseBuilder.setCode(HttpStatus.INTERNAL_SERVER_ERROR.toString());
- } catch (RestClientResponseException ex) {
- log.error("Caught exception: {}", ex);
- responseBuilder.setCode(String.valueOf(ex.getRawStatusCode()));
- }
- log.info("End of createPolicyInstance");
- RpcResult<CreatePolicyInstanceOutput> rpcResult = RpcResultBuilder
- .<CreatePolicyInstanceOutput>status(true).withResult(responseBuilder.build()).build();
- return Futures.immediateFuture(rpcResult);
- }
-
- @Override
- public ListenableFuture<RpcResult<CreatePolicyTypeOutput>> createPolicyType(
- CreatePolicyTypeInput input) {
- log.info("Start of createPolicyType");
- CreatePolicyTypeOutputBuilder responseBuilder = new CreatePolicyTypeOutputBuilder();
- try {
- String uri = nearRicUrlProvider.getPolicyTypeId(String.valueOf(input.getNearRtRicId()),
- String.valueOf(input.getPolicyTypeId()));
- log.info("PUT Request input.getPolicyType() : {} ", input.getPolicyType());
- ResponseEntity<Void> response = restAdapter.put(uri, input.getPolicyType());
- responseBuilder.setCode(response.getStatusCode().toString());
- } catch (NearRtRicNotFoundException ex) {
- log.error("Caught exception: {}", ex);
- responseBuilder.setCode(HttpStatus.INTERNAL_SERVER_ERROR.toString());
- } catch (RestClientResponseException ex) {
- log.error("Caught exception: {}", ex);
- responseBuilder.setCode(String.valueOf(ex.getRawStatusCode()));
- }
- log.info("End of createPolicyType");
- RpcResult<CreatePolicyTypeOutput> rpcResult = RpcResultBuilder
- .<CreatePolicyTypeOutput>status(true).withResult(responseBuilder.build()).build();
- return Futures.immediateFuture(rpcResult);
- }
-
- @Override
- public ListenableFuture<RpcResult<DeletePolicyInstanceOutput>> deletePolicyInstance(
- DeletePolicyInstanceInput input) {
- log.info("Start of deletePolicyInstance");
- DeletePolicyInstanceOutputBuilder responseBuilder = new DeletePolicyInstanceOutputBuilder();
- try {
- String uri = nearRicUrlProvider.getPolicyInstanceId(String.valueOf(input.getNearRtRicId()),
- String.valueOf(input.getPolicyTypeId()), String.valueOf(input.getPolicyInstanceId()));
- ResponseEntity<Void> response = restAdapter.delete(uri);
- responseBuilder.setCode(response.getStatusCode().toString());
- } catch (NearRtRicNotFoundException ex) {
- log.error("Caught exception: {}", ex);
- responseBuilder.setCode(HttpStatus.INTERNAL_SERVER_ERROR.toString());
- } catch (RestClientResponseException ex) {
- log.error("Caught exception: {}", ex);
- responseBuilder.setCode(String.valueOf(ex.getRawStatusCode()));
- }
- log.info("End of deletePolicyInstance");
- RpcResult<DeletePolicyInstanceOutput> rpcResult = RpcResultBuilder
- .<DeletePolicyInstanceOutput>status(true).withResult(responseBuilder.build()).build();
- return Futures.immediateFuture(rpcResult);
- }
-
- @Override
- public ListenableFuture<RpcResult<DeletePolicyTypeOutput>> deletePolicyType(
- DeletePolicyTypeInput input) {
- log.info("Start of deletePolicyType");
- DeletePolicyTypeOutputBuilder responseBuilder = new DeletePolicyTypeOutputBuilder();
- try {
- String uri = nearRicUrlProvider.getPolicyTypeId(String.valueOf(input.getNearRtRicId()),
- String.valueOf(input.getPolicyTypeId()));
- ResponseEntity<Void> response = restAdapter.delete(uri);
- responseBuilder.setCode(response.getStatusCode().toString());
- } catch (NearRtRicNotFoundException ex) {
- log.error("Caught exception: {}", ex);
- responseBuilder.setCode(HttpStatus.INTERNAL_SERVER_ERROR.toString());
- } catch (RestClientResponseException ex) {
- log.error("Caught exception: {}", ex);
- responseBuilder.setCode(String.valueOf(ex.getRawStatusCode()));
- }
- log.info("End of deletePolicyType");
- RpcResult<DeletePolicyTypeOutput> rpcResult = RpcResultBuilder
- .<DeletePolicyTypeOutput>status(true).withResult(responseBuilder.build()).build();
- return Futures.immediateFuture(rpcResult);
- }
-
- @Override
- public ListenableFuture<RpcResult<GetHealthCheckOutput>> getHealthCheck(
- GetHealthCheckInput input) {
- log.info("Start of getHealthCheck");
- GetHealthCheckOutputBuilder responseBuilder = new GetHealthCheckOutputBuilder();
- try {
- String uri = nearRicUrlProvider.getHealthCheck(String.valueOf(input.getNearRtRicId()));
- ResponseEntity<Object> response = restAdapter.get(uri, Object.class);
- responseBuilder.setHealthStatus(false);
- if (response.getStatusCode().equals(HttpStatus.OK)) {
- responseBuilder.setHealthStatus(true);
- }
- responseBuilder.setCode(response.getStatusCode().toString());
- } catch (NearRtRicNotFoundException ex) {
- log.error("Caught exception: {}", ex);
- responseBuilder.setCode(HttpStatus.INTERNAL_SERVER_ERROR.toString());
- } catch (RestClientResponseException ex) {
- log.error("Caught exception: {}", ex);
- responseBuilder.setCode(String.valueOf(ex.getRawStatusCode()));
+ public ListenableFuture<RpcResult<GetPolicyTypeIdentitiesOutput>> getPolicyTypeIdentities(
+ GetPolicyTypeIdentitiesInput input) {
+ log.info("Start of getPolicyTypeIdentities");
+ GetPolicyTypeIdentitiesOutputBuilder responseBuilder = new GetPolicyTypeIdentitiesOutputBuilder();
+ String uri = nearRicUrlProvider.getPolicyTypeIdentitiesUrl(String.valueOf(input.getNearRtRicUrl()));
+ ResponseEntity<List<String>> response = restAdapter.get(uri, List.class);
+ if (response.hasBody()) {
+ log.info("Response getPolicyTypeIdentities : {} ", response.getBody());
+ responseBuilder.setPolicyTypeIdList(response.getBody());
}
- log.info("End of getHealthCheck");
- RpcResult<GetHealthCheckOutput> rpcResult = RpcResultBuilder.<GetHealthCheckOutput>status(true)
+ log.info("End of getPolicyTypeIdentities");
+ RpcResult<GetPolicyTypeIdentitiesOutput> rpcResult = RpcResultBuilder.<GetPolicyTypeIdentitiesOutput>status(true)
.withResult(responseBuilder.build()).build();
return Futures.immediateFuture(rpcResult);
}
@Override
- public ListenableFuture<RpcResult<GetNearRTRICsOutput>> getNearRTRICs(GetNearRTRICsInput input) {
- log.info("Start of getNearRTRICs");
- GetNearRTRICsOutputBuilder responseBuilder = new GetNearRTRICsOutputBuilder();
- responseBuilder.setNearRtRicIdList(nearRicUrlProvider.getNearRTRicIdsList());
- responseBuilder.setCode(HttpStatus.OK.toString());
- log.info("End of getNearRTRICs");
- RpcResult<GetNearRTRICsOutput> rpcResult = RpcResultBuilder.<GetNearRTRICsOutput>status(true)
- .withResult(responseBuilder.build()).build();
- return Futures.immediateFuture(rpcResult);
- }
-
- @Override
- public ListenableFuture<RpcResult<GetPolicyInstanceOutput>> getPolicyInstance(
- GetPolicyInstanceInput input) {
- log.info("Start of getPolicyInstance");
- log.info("Policy Type Id : {}, Policy Instance Id : {}", input.getPolicyTypeId(), input.getPolicyInstanceId());
- GetPolicyInstanceOutputBuilder responseBuilder = new GetPolicyInstanceOutputBuilder();
- try {
- String uri = nearRicUrlProvider.getPolicyInstanceId(String.valueOf(input.getNearRtRicId()),
- String.valueOf(input.getPolicyTypeId()), String.valueOf(input.getPolicyInstanceId()));
- ResponseEntity<String> response = restAdapter.get(uri, String.class);
- if (response.hasBody()) {
- log.info("Response getPolicyInstance : {} ", response.getBody());
- responseBuilder.setPolicyInstance(response.getBody());
- }
- responseBuilder.setCode(response.getStatusCode().toString());
- } catch (NearRtRicNotFoundException ex) {
- log.error("Caught exception: {}", ex);
- responseBuilder.setCode(HttpStatus.INTERNAL_SERVER_ERROR.toString());
- } catch (RestClientResponseException ex) {
- log.error("Caught exception: {}", ex);
- responseBuilder.setCode(String.valueOf(ex.getRawStatusCode()));
- }
- log.info("End of getPolicyInstance");
- RpcResult<GetPolicyInstanceOutput> rpcResult = RpcResultBuilder
- .<GetPolicyInstanceOutput>status(true).withResult(responseBuilder.build()).build();
- return Futures.immediateFuture(rpcResult);
- }
-
- @Override
- public ListenableFuture<RpcResult<GetPolicyInstancesOutput>> getPolicyInstances(
- GetPolicyInstancesInput input) {
- log.info("Start of getPolicyInstances");
- GetPolicyInstancesOutputBuilder responseBuilder = new GetPolicyInstancesOutputBuilder();
- try {
- String uri = nearRicUrlProvider.getPolicyInstances(String.valueOf(input.getNearRtRicId()),
- String.valueOf(input.getPolicyTypeId()));
- ResponseEntity<List<String>> response = restAdapter.get(uri, List.class);
- if (response.hasBody()) {
- log.info("Response getPolicyInstances : {} ", response.getBody());
- responseBuilder.setPolicyInstanceIdList(response.getBody());
- }
- responseBuilder.setCode(response.getStatusCode().toString());
- } catch (NearRtRicNotFoundException ex) {
- log.error("Caught exception: {}", ex);
- responseBuilder.setCode(HttpStatus.INTERNAL_SERVER_ERROR.toString());
- } catch (RestClientResponseException ex) {
- log.error("Caught exception: {}", ex);
- responseBuilder.setCode(String.valueOf(ex.getRawStatusCode()));
+ public ListenableFuture<RpcResult<GetPolicyIdentitiesOutput>> getPolicyIdentities(GetPolicyIdentitiesInput input) {
+ log.info("Start of getPolicyIdentities");
+ GetPolicyIdentitiesOutputBuilder responseBuilder = new GetPolicyIdentitiesOutputBuilder();
+ String uri = nearRicUrlProvider.getPolicyIdentitiesUrl(String.valueOf(input.getNearRtRicUrl()));
+ ResponseEntity<List<String>> response = restAdapter.get(uri, List.class);
+ if (response.hasBody()) {
+ log.info("Response getPolicyIdentities : {} ", response.getBody());
+ responseBuilder.setPolicyIdList(response.getBody());
}
- log.info("End of getPolicyInstances");
- RpcResult<GetPolicyInstancesOutput> rpcResult = RpcResultBuilder
- .<GetPolicyInstancesOutput>status(true).withResult(responseBuilder.build()).build();
+ log.info("End of getPolicyIdentities");
+ RpcResult<GetPolicyIdentitiesOutput> rpcResult = RpcResultBuilder
+ .<GetPolicyIdentitiesOutput>status(true).withResult(responseBuilder.build()).build();
return Futures.immediateFuture(rpcResult);
}
log.info("Start of getPolicyType");
log.info("Policy Type Id : {} ", input.getPolicyTypeId());
GetPolicyTypeOutputBuilder responseBuilder = new GetPolicyTypeOutputBuilder();
- try {
- String uri = nearRicUrlProvider.getPolicyTypeId(String.valueOf(input.getNearRtRicId()),
- String.valueOf(input.getPolicyTypeId()));
- ResponseEntity<String> response = restAdapter.get(uri, String.class);
- if (response.hasBody()) {
- log.info("Response getPolicyType : {} ", response.getBody());
- JSONObject policyTypeObj = new JSONObject(response.getBody());
- responseBuilder.setDescription(policyTypeObj.getString("description"));
- responseBuilder.setName(policyTypeObj.getString("name"));
- responseBuilder.setPolicyType(policyTypeObj.getJSONObject("create_schema").toString());
- }
- responseBuilder.setCode(response.getStatusCode().toString());
- } catch (NearRtRicNotFoundException ex) {
- log.error("Caught exception: {}", ex);
- responseBuilder.setCode(HttpStatus.INTERNAL_SERVER_ERROR.toString());
- } catch (RestClientResponseException ex) {
- log.error("Caught exception: {}", ex);
- responseBuilder.setCode(String.valueOf(ex.getRawStatusCode()));
+ String uri = nearRicUrlProvider.getPolicyTypeUrl(String.valueOf(input.getNearRtRicUrl()),
+ String.valueOf(input.getPolicyTypeId()));
+ ResponseEntity<String> response = restAdapter.get(uri, String.class);
+ if (response.hasBody()) {
+ log.info("Response getPolicyType : {} ", response.getBody());
+ responseBuilder.setPolicyType(response.getBody());
}
log.info("End of getPolicyType");
RpcResult<GetPolicyTypeOutput> rpcResult = RpcResultBuilder.<GetPolicyTypeOutput>status(true)
}
@Override
- public ListenableFuture<RpcResult<GetPolicyTypesOutput>> getPolicyTypes(
- GetPolicyTypesInput input) {
- log.info("Start of getPolicyTypes");
- GetPolicyTypesOutputBuilder responseBuilder = new GetPolicyTypesOutputBuilder();
- try {
- String uri = nearRicUrlProvider.getPolicyTypes(String.valueOf(input.getNearRtRicId()));
- ResponseEntity<List<Integer>> response = restAdapter.get(uri, List.class);
- if (response.hasBody()) {
- log.info("Response getPolicyTypes : {} ", response.getBody());
- List<Integer> policyTypesListInteger = response.getBody();
- List<Long> policyTypesListLong = new ArrayList<>();
- for(Integer i : policyTypesListInteger){
- policyTypesListLong.add(i.longValue());
- }
- responseBuilder.setPolicyTypeIdList(policyTypesListLong);
- }
- responseBuilder.setCode(response.getStatusCode().toString());
- } catch (NearRtRicNotFoundException ex) {
- log.error("Caught exception: {}", ex);
- responseBuilder.setCode(HttpStatus.INTERNAL_SERVER_ERROR.toString());
- } catch (RestClientResponseException ex) {
- log.error("Caught exception: {}", ex);
- responseBuilder.setCode(String.valueOf(ex.getRawStatusCode()));
+ public ListenableFuture<RpcResult<PutPolicyOutput>> putPolicy(PutPolicyInput input) {
+ log.info("Start of putPolicy");
+ PutPolicyOutputBuilder responseBuilder = new PutPolicyOutputBuilder();
+ String uri = nearRicUrlProvider.getPolicyUrl(String.valueOf(input.getNearRtRicUrl()),
+ String.valueOf(input.getPolicyId()));
+ log.info("PUT Request input.getPolicy() : {} ", input.getPolicy());
+ ResponseEntity<String> response = restAdapter.put(uri, input.getPolicy());
+ if (response.hasBody()) {
+ log.info("Response putPolicy : {} ", response.getBody());
+ responseBuilder.setReturnedPolicy(response.getBody());
}
- log.info("End of getPolicyTypes");
- RpcResult<GetPolicyTypesOutput> rpcResult = RpcResultBuilder.<GetPolicyTypesOutput>status(true)
- .withResult(responseBuilder.build()).build();
+ log.info("End of putPolicy");
+ RpcResult<PutPolicyOutput> rpcResult = RpcResultBuilder
+ .<PutPolicyOutput>status(true).withResult(responseBuilder.build()).build();
return Futures.immediateFuture(rpcResult);
}
@Override
- public ListenableFuture<RpcResult<GetStatusOutput>> getStatus(GetStatusInput input) {
- log.info("Start of getStatus");
- GetStatusOutputBuilder responseBuilder = new GetStatusOutputBuilder();
- try {
- String uri = nearRicUrlProvider.getPolicyInstanceIdStatus(String.valueOf(input.getNearRtRicId()),
- String.valueOf(input.getPolicyTypeId()), String.valueOf(input.getPolicyInstanceId()));
- ResponseEntity<List<Object>> response = restAdapter.get(uri, List.class);
- if (response.hasBody()) {
- log.info("Response getStatus : {} ", response.getBody());
- // only return the status of first handler for compliance with current yang model, ignore handler_id
- JSONObject statusObj = new JSONObject(new Gson().toJson(response.getBody().get(0)));
- responseBuilder.setStatus(statusObj.getString("status"));
- }
- responseBuilder.setCode(response.getStatusCode().toString());
- } catch (NearRtRicNotFoundException ex) {
- log.error("Caught exception: {}", ex);
- responseBuilder.setCode(HttpStatus.INTERNAL_SERVER_ERROR.toString());
- } catch (RestClientResponseException ex) {
- log.error("Caught exception: {}", ex);
- responseBuilder.setCode(String.valueOf(ex.getRawStatusCode()));
- }
- log.info("End of getStatus");
- RpcResult<GetStatusOutput> rpcResult =
- RpcResultBuilder.<GetStatusOutput>status(true).withResult(responseBuilder.build()).build();
+ public ListenableFuture<RpcResult<DeletePolicyOutput>> deletePolicy(DeletePolicyInput input) {
+ log.info("Start of deletePolicy");
+ DeletePolicyOutputBuilder responseBuilder = new DeletePolicyOutputBuilder();
+ String uri = nearRicUrlProvider.getPolicyUrl(String.valueOf(input.getNearRtRicUrl()),
+ String.valueOf(input.getPolicyId()));
+ ResponseEntity<Void> response = restAdapter.delete(uri);
+ log.info("End of deletePolicy");
+ RpcResult<DeletePolicyOutput> rpcResult = RpcResultBuilder
+ .<DeletePolicyOutput>status(true).withResult(responseBuilder.build()).build();
return Futures.immediateFuture(rpcResult);
}
}
--- /dev/null
+/*-
+ * ============LICENSE_START=======================================================
+ * Copyright (C) 2019 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.sdnc.northbound.restadapter;
+
+import org.springframework.web.util.UriComponentsBuilder;
+
+/**
+ * This class provides Near-RIC api to invoke the A1 interface
+ *
+ * @author lathishbabu.ganesan@est.tech
+ *
+ */
+
+public class NearRicUrlProvider {
+
+ public NearRicUrlProvider() {
+ }
+
+ /**
+ * Retrieve the base url of the Near-RIC
+ *
+ * @return the base url
+ */
+ public String getBaseUrl(final String nearRtRicUrl) {
+ String baseUrl = nearRtRicUrl + "/A1-P/v1";
+ return UriComponentsBuilder.fromUriString(baseUrl).build().toString();
+ }
+
+ /**
+ * Retrieve the policy type ids url
+ *
+ * @return the policytype ids url
+ */
+ public String getPolicyTypeIdentitiesUrl(final String nearRtRicUrl) {
+ return UriComponentsBuilder.fromUriString(getBaseUrl(nearRtRicUrl)).pathSegment("policytypes")
+ .pathSegment("identities").build().toString();
+ }
+
+ /**
+ * Retrieve the url of the policy instances
+ *
+ * @param policyTypeId Policy Type Id
+ * @return the policy ids url
+ */
+ public String getPolicyIdentitiesUrl(final String nearRtRicUrl) {
+ return UriComponentsBuilder.fromUriString(getBaseUrl(nearRtRicUrl)).pathSegment("policies")
+ .pathSegment("identities").build().toString();
+ }
+
+ /**
+ * Retrieve the url of policy type
+ *
+ * @param policyTypeId Policy Type Id
+ * @return the policy type url
+ */
+ public String getPolicyTypeUrl(final String nearRtRicUrl, final String policyTypeId) {
+ return UriComponentsBuilder.fromUriString(getBaseUrl(nearRtRicUrl)).pathSegment("policytypes")
+ .pathSegment(policyTypeId).build().toString();
+ }
+
+ /**
+ * Retrieve the url of the policy instance id
+ *
+ * @param policyId Policy Id
+ * @return the policy id url
+ */
+ public String getPolicyUrl(final String nearRtRicUrl, final String policyId) {
+ return UriComponentsBuilder.fromUriString(getBaseUrl(nearRtRicUrl)).pathSegment("policies")
+ .pathSegment(policyId).build().toString();
+ }
+}
* ============LICENSE_END=========================================================
*/
-package org.onap.sdnc.northbound.restadpter;
+package org.onap.sdnc.northbound.restadapter;
import org.springframework.http.ResponseEntity;
* ============LICENSE_END=========================================================
*/
-package org.onap.sdnc.northbound.restadpter;
+package org.onap.sdnc.northbound.restadapter;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
+++ /dev/null
-/*-
- * ============LICENSE_START=======================================================
- * Copyright (C) 2019 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.sdnc.northbound.restadpter;
-
-import java.io.IOException;
-import java.io.InputStream;
-import java.util.ArrayList;
-import java.util.Enumeration;
-import java.util.HashMap;
-import java.util.List;
-import java.util.Properties;
-import org.onap.sdnc.northbound.exceptions.NearRtRicNotFoundException;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-import org.springframework.web.util.UriComponentsBuilder;
-
-/**
- * This class provides Near-RIC api to invoke the A1 interface
- *
- * @author lathishbabu.ganesan@est.tech
- *
- */
-
-public class NearRicUrlProvider {
-
- // nearRicMap provides mapping from nearRtRicId to domainname:port of nearRTRics
- private HashMap<String, String> nearRicMap = new HashMap<>();
- private static final String NEAR_RIC_LIST_FILE = "NearRtRicList.properties";
- private final Logger log = LoggerFactory.getLogger(NearRicUrlProvider.class);
-
- public NearRicUrlProvider() {
- try {
- readNearRtRicConfigFile();
- } catch (IOException ex) {
- log.error("Exception while reading nearRtRicConfigFile: {}", ex);
- }
- }
-
- private void readNearRtRicConfigFile() throws IOException {
- InputStream inputStream = NearRicUrlProvider.class.getClassLoader().getResourceAsStream(NEAR_RIC_LIST_FILE);
- if (inputStream == null) {
- log.error("The file {} not found in classpath", NEAR_RIC_LIST_FILE);
- } else {
- Properties properties = new Properties();
- properties.load(inputStream);
- Enumeration<?> keys = properties.propertyNames();
- while (keys.hasMoreElements()) {
- String key = (String) keys.nextElement();
- nearRicMap.put(key, properties.getProperty(key));
- }
- inputStream.close();
- }
- }
-
- /**
- * Retrieve the list of Near-RICs
- *
- * @return the list of Near-RICs
- */
- public List<String> getNearRTRicIdsList () {
- return new ArrayList<>(nearRicMap.keySet());
- }
-
- /**
- * Retrieve the base url of the Near-RIC
- *
- * @return the base url
- */
- public String getBaseUrl(final String nearRtRicId) {
- if (!nearRicMap.containsKey(nearRtRicId)) {
- throw new NearRtRicNotFoundException("NearRtRic with this ID is not known by the A1 controller");
- }
- String baseUrl = "http://" + nearRicMap.get(nearRtRicId) + "/a1-p/";
- return UriComponentsBuilder.fromUriString(baseUrl).build().toString();
- }
-
- /**
- * Retrieve the url of A1 healthcheck
- *
- * @return the health check url
- */
- public String getHealthCheck(final String nearRtRicId) {
- return UriComponentsBuilder.fromUriString(getBaseUrl(nearRtRicId)).pathSegment("healthcheck").build()
- .toString();
- }
-
- /**
- * Retrieve the policy type url
- *
- * @return the base url with the policytypes
- */
- public String getPolicyTypes(final String nearRtRicId) {
- return UriComponentsBuilder.fromUriString(getBaseUrl(nearRtRicId)).pathSegment("policytypes/").build()
- .toString();
- }
-
- /**
- * Retrieve the url of policy type id
- *
- * @param policyTypeId Policy Type Id
- * @return the policy type id url
- */
- public String getPolicyTypeId(final String nearRtRicId,
- final String policyTypeId) {
- return UriComponentsBuilder.fromUriString(getBaseUrl(nearRtRicId)).pathSegment("policytypes")
- .pathSegment(policyTypeId).build().toString();
- }
-
- /**
- * Retrieve the url of the policy instances
- *
- * @param policyTypeId Policy Type Id
- * @return the policy instances for the given policy type
- */
- public String getPolicyInstances(final String nearRtRicId,
- final String policyTypeId) {
- return UriComponentsBuilder.fromUriString(getPolicyTypeId(nearRtRicId, policyTypeId)).pathSegment("policies")
- .build().toString();
- }
-
- /**
- * Retrieve the url of the policy instance id
- *
- * @param policyTypeId Policy Type Id
- * @param policyInstanceId Policy Instance Id
- * @return the policy instance id for the given policy type
- */
- public String getPolicyInstanceId(final String nearRtRicId, final String policyTypeId,
- final String policyInstanceId) {
- return UriComponentsBuilder.fromUriString(getPolicyTypeId(nearRtRicId, policyTypeId)).pathSegment("policies")
- .pathSegment(policyInstanceId).build().toString();
- }
-
- /**
- * Retrieve the url of the policy instance id status
- *
- * @param policyTypeId Policy Type Id
- * @param policyInstanceId Policy Instance Id
- * @return the policy instance id status for the given policy type
- */
- public String getPolicyInstanceIdStatus(final String nearRtRicId, final String policyTypeId,
- final String policyInstanceId) {
- return UriComponentsBuilder.fromUriString(getPolicyInstanceId(nearRtRicId, policyTypeId, policyInstanceId))
- .pathSegment("status").build().toString();
- }
-}
package org.onap.sdnc.northbound;
-import static org.mockito.Matchers.anyObject;
import static org.mockito.Matchers.eq;
import static org.mockito.Mockito.when;
import com.google.common.util.concurrent.ListenableFuture;
-import com.google.gson.Gson;
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.ExecutionException;
import org.mockito.internal.util.reflection.Whitebox;
import org.mockito.runners.MockitoJUnitRunner;
import org.onap.sdnc.northbound.provider.NonrtRicApiProvider;
-import org.onap.sdnc.northbound.restadpter.NearRicUrlProvider;
-import org.onap.sdnc.northbound.restadpter.RestAdapter;
+import org.onap.sdnc.northbound.restadapter.NearRicUrlProvider;
+import org.onap.sdnc.northbound.restadapter.RestAdapter;
import org.opendaylight.controller.md.sal.binding.api.DataBroker;
import org.opendaylight.controller.md.sal.binding.api.NotificationPublishService;
import org.opendaylight.controller.md.sal.binding.test.AbstractConcurrentDataBrokerTest;
import org.opendaylight.controller.sal.binding.api.RpcProviderRegistry;
-import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.a1.adapter.rev191002.CreatePolicyInstanceInputBuilder;
-import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.a1.adapter.rev191002.CreatePolicyInstanceOutput;
-import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.a1.adapter.rev191002.CreatePolicyTypeInputBuilder;
-import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.a1.adapter.rev191002.CreatePolicyTypeOutput;
-import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.a1.adapter.rev191002.DeletePolicyInstanceInputBuilder;
-import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.a1.adapter.rev191002.DeletePolicyInstanceOutput;
-import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.a1.adapter.rev191002.DeletePolicyTypeInputBuilder;
-import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.a1.adapter.rev191002.DeletePolicyTypeOutput;
-import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.a1.adapter.rev191002.GetHealthCheckInputBuilder;
-import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.a1.adapter.rev191002.GetHealthCheckOutput;
-import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.a1.adapter.rev191002.GetNearRTRICsInputBuilder;
-import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.a1.adapter.rev191002.GetNearRTRICsOutput;
-import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.a1.adapter.rev191002.GetPolicyInstanceInputBuilder;
-import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.a1.adapter.rev191002.GetPolicyInstanceOutput;
-import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.a1.adapter.rev191002.GetPolicyInstancesInputBuilder;
-import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.a1.adapter.rev191002.GetPolicyInstancesOutput;
-import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.a1.adapter.rev191002.GetPolicyTypeInputBuilder;
-import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.a1.adapter.rev191002.GetPolicyTypeOutput;
-import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.a1.adapter.rev191002.GetPolicyTypesInputBuilder;
-import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.a1.adapter.rev191002.GetPolicyTypesOutput;
-import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.a1.adapter.rev191002.GetStatusInputBuilder;
-import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.a1.adapter.rev191002.GetStatusOutput;
+import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.a1.adapter.rev200122.GetPolicyIdentitiesInputBuilder;
+import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.a1.adapter.rev200122.GetPolicyIdentitiesOutput;
+import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.a1.adapter.rev200122.GetPolicyTypeIdentitiesInputBuilder;
+import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.a1.adapter.rev200122.GetPolicyTypeIdentitiesOutput;
+import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.a1.adapter.rev200122.GetPolicyTypeInputBuilder;
+import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.a1.adapter.rev200122.GetPolicyTypeOutput;
+import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.a1.adapter.rev200122.PutPolicyInputBuilder;
+import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.a1.adapter.rev200122.PutPolicyOutput;
import org.opendaylight.yangtools.yang.common.RpcResult;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
@Mock
private RestAdapter restAdapter;
private NearRicUrlProvider nearRicUrlProvider;
- private static String nearRtRicId = "NearRtRic1";
- private static Long policyTypeId = 11L;
- private static String policyTypeInstanceId = "12";
+ private static String nearRtRicUrl = "http://ric1:8085";
+ private static String policyTypeId = "STD_QoSNudging_0.1.0";
+ private static String policyId = "3d2157af-6a8f-4a7c-810f-38c2f824bf12";
@Before
}
@Test
- public void testCreatePolicyInstance() throws InterruptedException, ExecutionException {
- CreatePolicyInstanceInputBuilder inputBuilder = new CreatePolicyInstanceInputBuilder();
- inputBuilder.setNearRtRicId(nearRtRicId);
- inputBuilder.setPolicyTypeId(policyTypeId);
- inputBuilder.setPolicyInstanceId(policyTypeInstanceId);
- Whitebox.setInternalState(nonrtRicApiProvider, "restAdapter", restAdapter);
- String uri = nearRicUrlProvider.getPolicyInstanceId(inputBuilder.build().getNearRtRicId(),
- String.valueOf(inputBuilder.build().getPolicyTypeId()), inputBuilder.getPolicyInstanceId());
- ResponseEntity<Object> createPolicyInstanceResponse = new ResponseEntity<>(HttpStatus.CREATED);
- when(restAdapter.put(eq(uri), anyObject())).thenReturn(createPolicyInstanceResponse);
- ListenableFuture<RpcResult<CreatePolicyInstanceOutput>> result =
- nonrtRicApiProvider.createPolicyInstance(inputBuilder.build());
- Assert.assertEquals(String.valueOf(HttpStatus.CREATED.value()), result.get().getResult().getCode());
- }
-
- @Test
- public void testDeletePolicyInstance() throws InterruptedException, ExecutionException {
- DeletePolicyInstanceInputBuilder inputBuilder = new DeletePolicyInstanceInputBuilder();
- inputBuilder.setNearRtRicId(nearRtRicId);
- inputBuilder.setPolicyTypeId(policyTypeId);
- inputBuilder.setPolicyInstanceId(policyTypeInstanceId);
- Whitebox.setInternalState(nonrtRicApiProvider, "restAdapter", restAdapter);
- String uri = nearRicUrlProvider.getPolicyInstanceId(inputBuilder.build().getNearRtRicId(),
- String.valueOf(inputBuilder.build().getPolicyTypeId()), inputBuilder.getPolicyInstanceId());
- ResponseEntity<Object> deletePolicyInstanceResponse = new ResponseEntity<>(HttpStatus.NO_CONTENT);
- when(restAdapter.delete(eq(uri))).thenReturn(deletePolicyInstanceResponse);
- ListenableFuture<RpcResult<DeletePolicyInstanceOutput>> result =
- nonrtRicApiProvider.deletePolicyInstance(inputBuilder.build());
- Assert.assertEquals(String.valueOf(HttpStatus.NO_CONTENT.value()), result.get().getResult().getCode());
- }
-
- @Test
- public void testGetNearRTRICs() throws InterruptedException, ExecutionException {
- GetNearRTRICsInputBuilder inputBuilder = new GetNearRTRICsInputBuilder();
- ListenableFuture<RpcResult<GetNearRTRICsOutput>> result =
- nonrtRicApiProvider.getNearRTRICs(inputBuilder.build());
- Assert.assertEquals(String.valueOf(HttpStatus.OK.value()), result.get().getResult().getCode());
- }
-
- @Test
- public void testCreatePolicyType() throws InterruptedException, ExecutionException {
- CreatePolicyTypeInputBuilder inputBuilder = new CreatePolicyTypeInputBuilder();
- inputBuilder.setNearRtRicId(nearRtRicId);
- inputBuilder.setPolicyTypeId(policyTypeId);
+ public void testGetPolicyTypeIdentities() throws InterruptedException, ExecutionException {
+ GetPolicyTypeIdentitiesInputBuilder inputBuilder = new GetPolicyTypeIdentitiesInputBuilder();
+ inputBuilder.setNearRtRicUrl(nearRtRicUrl);
Whitebox.setInternalState(nonrtRicApiProvider, "restAdapter", restAdapter);
- String uri = nearRicUrlProvider.getPolicyTypeId(inputBuilder.build().getNearRtRicId(),
- String.valueOf(inputBuilder.build().getPolicyTypeId()));
- ResponseEntity<Object> createPolicyTypeResponse = new ResponseEntity<>(HttpStatus.CREATED);
- when(restAdapter.put(eq(uri), anyObject())).thenReturn(createPolicyTypeResponse);
- ListenableFuture<RpcResult<CreatePolicyTypeOutput>> result =
- nonrtRicApiProvider.createPolicyType(inputBuilder.build());
- Assert.assertEquals(String.valueOf(HttpStatus.CREATED.value()), result.get().getResult().getCode());
+ String uri = nearRicUrlProvider.getPolicyTypeIdentitiesUrl(inputBuilder.build().getNearRtRicUrl());
+ List<String> policyTypeIdentities = new ArrayList<>();
+ policyTypeIdentities.add(policyTypeId);
+ ResponseEntity<Object> getPolicyTypeIdentitiesResponse = new ResponseEntity<>(policyTypeIdentities, HttpStatus.OK);
+ when(restAdapter.get(eq(uri), eq(List.class))).thenReturn(getPolicyTypeIdentitiesResponse);
+ ListenableFuture<RpcResult<GetPolicyTypeIdentitiesOutput>> result =
+ nonrtRicApiProvider.getPolicyTypeIdentities(inputBuilder.build());
+ Assert.assertEquals(policyTypeIdentities, result.get().getResult().getPolicyTypeIdList());
}
@Test
- public void testDeletePolicyType() throws InterruptedException, ExecutionException {
- DeletePolicyTypeInputBuilder inputBuilder = new DeletePolicyTypeInputBuilder();
- inputBuilder.setNearRtRicId(nearRtRicId);
- inputBuilder.setPolicyTypeId(policyTypeId);
+ public void testGetPolicyIdentities() throws InterruptedException, ExecutionException {
+ GetPolicyIdentitiesInputBuilder inputBuilder = new GetPolicyIdentitiesInputBuilder();
+ inputBuilder.setNearRtRicUrl(nearRtRicUrl);
Whitebox.setInternalState(nonrtRicApiProvider, "restAdapter", restAdapter);
- String uri = nearRicUrlProvider.getPolicyTypeId(inputBuilder.build().getNearRtRicId(),
- String.valueOf(inputBuilder.build().getPolicyTypeId()));
- ResponseEntity<Object> deletePolicyTypeResponse = new ResponseEntity<>(HttpStatus.NO_CONTENT);
- when(restAdapter.delete(eq(uri))).thenReturn(deletePolicyTypeResponse);
- ListenableFuture<RpcResult<DeletePolicyTypeOutput>> result =
- nonrtRicApiProvider.deletePolicyType(inputBuilder.build());
- Assert.assertEquals(String.valueOf(HttpStatus.NO_CONTENT.value()), result.get().getResult().getCode());
+ String uri = nearRicUrlProvider.getPolicyIdentitiesUrl(inputBuilder.build().getNearRtRicUrl());
+ List<String> policyIdentities = new ArrayList<>();
+ policyIdentities.add(policyId);
+ ResponseEntity<Object> getPolicyIdentitiesResponse = new ResponseEntity<>(policyIdentities, HttpStatus.OK);
+ when(restAdapter.get(eq(uri), eq(List.class))).thenReturn(getPolicyIdentitiesResponse);
+ ListenableFuture<RpcResult<GetPolicyIdentitiesOutput>> result =
+ nonrtRicApiProvider.getPolicyIdentities(inputBuilder.build());
+ Assert.assertEquals(policyIdentities, result.get().getResult().getPolicyIdList());
}
@Test
public void testGetPolicyType() throws InterruptedException, ExecutionException {
GetPolicyTypeInputBuilder inputBuilder = new GetPolicyTypeInputBuilder();
- inputBuilder.setNearRtRicId(nearRtRicId);
+ inputBuilder.setNearRtRicUrl(nearRtRicUrl);
inputBuilder.setPolicyTypeId(policyTypeId);
Whitebox.setInternalState(nonrtRicApiProvider, "restAdapter", restAdapter);
- String uri = nearRicUrlProvider.getPolicyTypeId(inputBuilder.build().getNearRtRicId(),
+ String uri = nearRicUrlProvider.getPolicyTypeUrl(inputBuilder.build().getNearRtRicUrl(),
String.valueOf(inputBuilder.build().getPolicyTypeId()));
- String policyType =
- "{\"name\":\"Policy type 1\",\"description\":\"PT 1\",\"policy_type_id\":1,\"create_schema\":{}}";
- ResponseEntity<Object> getPolicyTypeResponse = new ResponseEntity<>(policyType, HttpStatus.OK);
+ String testPolicyType = "{}";
+ ResponseEntity<Object> getPolicyTypeResponse = new ResponseEntity<>(testPolicyType, HttpStatus.OK);
when(restAdapter.get(eq(uri), eq(String.class))).thenReturn(getPolicyTypeResponse);
ListenableFuture<RpcResult<GetPolicyTypeOutput>> result =
nonrtRicApiProvider.getPolicyType(inputBuilder.build());
- Assert.assertEquals("Policy type 1", result.get().getResult().getName());
- Assert.assertEquals(String.valueOf(HttpStatus.OK.value()), result.get().getResult().getCode());
- }
-
- @Test
- public void testGetPolicyTypes() throws InterruptedException, ExecutionException {
- GetPolicyTypesInputBuilder inputBuilder = new GetPolicyTypesInputBuilder();
- inputBuilder.setNearRtRicId(nearRtRicId);
- Whitebox.setInternalState(nonrtRicApiProvider, "restAdapter", restAdapter);
- String uri = nearRicUrlProvider.getPolicyTypes(inputBuilder.build().getNearRtRicId());
- List<Integer> policyTypesInteger = new ArrayList<>();
- policyTypesInteger.add(20001);
- List<Long> policyTypesLong = new ArrayList<>();
- policyTypesLong.add(20001L);
- ResponseEntity<Object> getPolicyTypesResponse = new ResponseEntity<>(policyTypesInteger, HttpStatus.OK);
- when(restAdapter.get(eq(uri), eq(List.class))).thenReturn(getPolicyTypesResponse);
- ListenableFuture<RpcResult<GetPolicyTypesOutput>> result =
- nonrtRicApiProvider.getPolicyTypes(inputBuilder.build());
- Assert.assertEquals(policyTypesLong, result.get().getResult().getPolicyTypeIdList());
- Assert.assertEquals(String.valueOf(HttpStatus.OK.value()), result.get().getResult().getCode());
- }
-
- @Test
- public void testGetPolicyInstance() throws InterruptedException, ExecutionException {
- GetPolicyInstanceInputBuilder inputBuilder = new GetPolicyInstanceInputBuilder();
- inputBuilder.setNearRtRicId(nearRtRicId);
- inputBuilder.setPolicyTypeId(policyTypeId);
- inputBuilder.setPolicyInstanceId(policyTypeInstanceId);
- Whitebox.setInternalState(nonrtRicApiProvider, "restAdapter", restAdapter);
- String uri = nearRicUrlProvider.getPolicyInstanceId(inputBuilder.build().getNearRtRicId(),
- String.valueOf(inputBuilder.build().getPolicyTypeId()), inputBuilder.getPolicyInstanceId());
- String policyInstance =
- "{\"scope\":{\"ue_id\":\"2\"},\"statement\":{\"priority_level\":\"1\"},\"policy_id\":\"pi12\"}";
- ResponseEntity<Object> getPolicyInstanceResponse = new ResponseEntity<>(policyInstance, HttpStatus.OK);
- when(restAdapter.get(eq(uri), eq(String.class))).thenReturn(getPolicyInstanceResponse);
- ListenableFuture<RpcResult<GetPolicyInstanceOutput>> result =
- nonrtRicApiProvider.getPolicyInstance(inputBuilder.build());
- Assert.assertEquals(policyInstance, result.get().getResult().getPolicyInstance());
- Assert.assertEquals(String.valueOf(HttpStatus.OK.value()), result.get().getResult().getCode());
- }
-
- @Test
- public void testGetPolicyInstances() throws InterruptedException, ExecutionException {
- GetPolicyInstancesInputBuilder inputBuilder = new GetPolicyInstancesInputBuilder();
- inputBuilder.setNearRtRicId(nearRtRicId);
- inputBuilder.setPolicyTypeId(policyTypeId);
- Whitebox.setInternalState(nonrtRicApiProvider, "restAdapter", restAdapter);
- String uri = nearRicUrlProvider.getPolicyInstances(inputBuilder.build().getNearRtRicId(),
- String.valueOf(inputBuilder.build().getPolicyTypeId()));
- List<String> policyInstances = new ArrayList<>();
- policyInstances.add("3d2157af-6a8f-4a7c-810f-38c2f824bf12");
- ResponseEntity<Object> getPolicyInstancesResponse = new ResponseEntity<>(policyInstances, HttpStatus.OK);
- when(restAdapter.get(eq(uri), eq(List.class))).thenReturn(getPolicyInstancesResponse);
- ListenableFuture<RpcResult<GetPolicyInstancesOutput>> result =
- nonrtRicApiProvider.getPolicyInstances(inputBuilder.build());
- Assert.assertEquals(policyInstances, result.get().getResult().getPolicyInstanceIdList());
- Assert.assertEquals(String.valueOf(HttpStatus.OK.value()), result.get().getResult().getCode());
- }
-
- @Test
- public void testGetStatus() throws InterruptedException, ExecutionException {
- GetStatusInputBuilder inputBuilder = new GetStatusInputBuilder();
- inputBuilder.setNearRtRicId(nearRtRicId);
- inputBuilder.setPolicyTypeId(policyTypeId);
- inputBuilder.setPolicyInstanceId(policyTypeInstanceId);
- Whitebox.setInternalState(nonrtRicApiProvider, "restAdapter", restAdapter);
- String uri = nearRicUrlProvider.getPolicyInstanceIdStatus(inputBuilder.build().getNearRtRicId(),
- String.valueOf(inputBuilder.build().getPolicyTypeId()), inputBuilder.getPolicyInstanceId());
- String policyInstanceStatus = "[{\"handler_id\":\"NearRTRIC-1\",\"status\":\"enforced\"}]";
- ResponseEntity<Object> getStatusResponse =
- new ResponseEntity<>(new Gson().fromJson(policyInstanceStatus, List.class), HttpStatus.OK);
- when(restAdapter.get(eq(uri), eq(List.class))).thenReturn(getStatusResponse);
- ListenableFuture<RpcResult<GetStatusOutput>> result =
- nonrtRicApiProvider.getStatus(inputBuilder.build());
- Assert.assertEquals("enforced", result.get().getResult().getStatus());
- Assert.assertEquals(String.valueOf(HttpStatus.OK.value()), result.get().getResult().getCode());
+ Assert.assertEquals(testPolicyType, result.get().getResult().getPolicyType());
}
@Test
- public void testGetHealthCheck() throws InterruptedException, ExecutionException {
- GetHealthCheckInputBuilder inputBuilder = new GetHealthCheckInputBuilder();
- inputBuilder.setNearRtRicId(nearRtRicId);
+ public void testPutPolicy() throws InterruptedException, ExecutionException {
+ PutPolicyInputBuilder inputBuilder = new PutPolicyInputBuilder();
+ String testPolicy = "{}";
+ inputBuilder.setNearRtRicUrl(nearRtRicUrl);
+ inputBuilder.setPolicyId(policyId);
+ inputBuilder.setPolicy(testPolicy);
Whitebox.setInternalState(nonrtRicApiProvider, "restAdapter", restAdapter);
- String uri = nearRicUrlProvider.getHealthCheck(inputBuilder.build().getNearRtRicId());
- ResponseEntity<Object> getHealthCheckResponse = new ResponseEntity<>(HttpStatus.OK);
- when(restAdapter.get(eq(uri), eq(Object.class))).thenReturn(getHealthCheckResponse);
- ListenableFuture<RpcResult<GetHealthCheckOutput>> result =
- nonrtRicApiProvider.getHealthCheck(inputBuilder.build());
- Assert.assertEquals(true, result.get().getResult().isHealthStatus());
- Assert.assertEquals(String.valueOf(HttpStatus.OK.value()), result.get().getResult().getCode());
+ String uri = nearRicUrlProvider.getPolicyUrl(inputBuilder.build().getNearRtRicUrl(),
+ inputBuilder.getPolicyId());
+ ResponseEntity<Object> putPolicyResponse = new ResponseEntity<>(testPolicy, HttpStatus.CREATED);
+ when(restAdapter.put(eq(uri), eq(testPolicy))).thenReturn(putPolicyResponse);
+ ListenableFuture<RpcResult<PutPolicyOutput>> result =
+ nonrtRicApiProvider.putPolicy(inputBuilder.build());
+ Assert.assertEquals(testPolicy, result.get().getResult().getReturnedPolicy());
}
}