import java.util.List;
import java.util.Map;
import java.util.ServiceLoader;
+import java.util.stream.Collectors;
+import lombok.Getter;
+import lombok.Setter;
import org.onap.policy.models.decisions.concepts.DecisionRequest;
import org.onap.policy.models.tosca.authorative.concepts.ToscaPolicy;
import org.onap.policy.models.tosca.authorative.concepts.ToscaPolicyIdentifier;
public class XacmlPdpApplicationManager {
private static final Logger LOGGER = LoggerFactory.getLogger(XacmlPdpApplicationManager.class);
- private static boolean needsInit = true;
- private static ServiceLoader<XacmlApplicationServiceProvider> applicationLoader;
- private static Map<String, XacmlApplicationServiceProvider> providerActionMap = new HashMap<>();
- private static List<ToscaPolicyTypeIdentifier> toscaPolicyTypeIdents = new ArrayList<>();
- private static List<ToscaPolicyIdentifier> toscaPolicies = new ArrayList<>();
+ @Getter
+ @Setter
+ private static XacmlPdpApplicationManager current;
+
+ private ServiceLoader<XacmlApplicationServiceProvider> applicationLoader;
+ private Map<String, XacmlApplicationServiceProvider> providerActionMap = new HashMap<>();
+ private List<ToscaPolicyTypeIdentifier> toscaPolicyTypeIdents = new ArrayList<>();
+ private Map<ToscaPolicy, XacmlApplicationServiceProvider> mapLoadedPolicies = new HashMap<>();
- private XacmlPdpApplicationManager() {
- super();
- }
/**
* One time to initialize the applications upon startup.
*/
- public static void initializeApplications(Path applicationPath) {
- //
- // If we have already done this
- //
- if (! needsInit) {
- LOGGER.error("Already initialized the applications");
- return;
+ public XacmlPdpApplicationManager(Path applicationPath) {
+ if (LOGGER.isInfoEnabled()) {
+ LOGGER.info("Initialization applications {}", applicationPath.toAbsolutePath());
}
//
// Load service
// Iterate through the applications for actions and supported policy types
//
for (XacmlApplicationServiceProvider application : applicationLoader) {
- LOGGER.info("Application {} supports {}", application.applicationName(),
+ if (LOGGER.isInfoEnabled()) {
+ LOGGER.info("Application {} supports {}", application.applicationName(),
application.supportedPolicyTypes());
+ }
//
// We are not going to make this available unless the application can
// install correctly.
//
// we have initialized
//
- needsInit = false;
+ LOGGER.info("Finished applications initialization {}", providerActionMap);
+
}
- public static XacmlApplicationServiceProvider findApplication(DecisionRequest request) {
+ public XacmlApplicationServiceProvider findApplication(DecisionRequest request) {
return providerActionMap.get(request.getAction());
}
- public static List<ToscaPolicyTypeIdentifier> getToscaPolicyTypeIdents() {
+ /**
+ * getToscaPolicies.
+ *
+ * @return the map containing ToscaPolicies
+ */
+ public Map<ToscaPolicy, XacmlApplicationServiceProvider> getToscaPolicies() {
+ return mapLoadedPolicies;
+ }
+
+ /**
+ * getToscaPolicyIdentifiers.
+ *
+ * @return list of ToscaPolicyIdentifier
+ */
+ public List<ToscaPolicyIdentifier> getToscaPolicyIdentifiers() {
+ //
+ // converting map to return List of ToscaPolicyIdentiers
+ //
+ return mapLoadedPolicies.keySet().stream().map(ToscaPolicy::getIdentifier).collect(Collectors.toList());
+ }
+
+ public List<ToscaPolicyTypeIdentifier> getToscaPolicyTypeIdents() {
return toscaPolicyTypeIdents;
}
+ /**
+ * Finds the appropriate application and removes the policy.
+ *
+ * @param policy Incoming policy
+ */
+ public void removeUndeployedPolicy(ToscaPolicy policy) {
+
+ for (XacmlApplicationServiceProvider application : applicationLoader) {
+ try {
+ if (application.unloadPolicy(policy)) {
+ if (LOGGER.isInfoEnabled()) {
+ LOGGER.info("Unloaded ToscaPolicy {} from application {}", policy.getMetadata(),
+ application.applicationName());
+ }
+ if (mapLoadedPolicies.remove(policy) == null) {
+ LOGGER.error("Failed to remove unloaded policy {} from map size {}", policy.getMetadata(),
+ mapLoadedPolicies.size());
+ }
+ }
+ } catch (XacmlApplicationException e) {
+ LOGGER.error("Failed to undeploy the Tosca Policy", e);
+ }
+ }
+ }
+
/**
* Finds the appropriate application and loads the policy.
*
* @param policy Incoming policy
*/
- public static void loadDeployedPolicy(ToscaPolicy policy) {
+ public void loadDeployedPolicy(ToscaPolicy policy) {
for (XacmlApplicationServiceProvider application : applicationLoader) {
try {
// just use the first one found.
//
if (application.canSupportPolicyType(policy.getTypeIdentifier())) {
- application.loadPolicy(policy);
+ if (application.loadPolicy(policy)) {
+ if (LOGGER.isInfoEnabled()) {
+ LOGGER.info("Loaded ToscaPolicy {} into application {}", policy.getMetadata(),
+ application.applicationName());
+ }
+ mapLoadedPolicies.put(policy, application);
+ }
return;
}
} catch (XacmlApplicationException e) {
}
}
- public static List<ToscaPolicyIdentifier> getToscaPolicies() {
- return toscaPolicies;
- }
-
/**
* Returns the current count of policy types supported. This could be misleading a bit
* as some applications can support wildcard of policy types. Eg. onap.Monitoring.* as
*
* @return Total count added from all applications
*/
- public static long getPolicyTypeCount() {
+ public long getPolicyTypeCount() {
long types = 0;
for (XacmlApplicationServiceProvider application : applicationLoader) {
types += application.supportedPolicyTypes().size();
return types;
}
- private static void initializeApplicationPath(Path basePath, XacmlApplicationServiceProvider application)
+ private void initializeApplicationPath(Path basePath, XacmlApplicationServiceProvider application)
throws XacmlApplicationException {
//
// Making an assumption that all application names are unique, and
// they can result in a valid directory being created.
//
Path path = Paths.get(basePath.toAbsolutePath().toString(), application.applicationName());
- LOGGER.info("initializeApplicationPath {} at this path {}", application.applicationName(), path);
+ if (LOGGER.isInfoEnabled()) {
+ LOGGER.info("initializeApplicationPath {} at this path {}", application.applicationName(), path);
+ }
//
// Create that the directory if it does not exist. Ideally
// this is only for testing, but could be used for production
//
Files.createDirectory(path);
} catch (IOException e) {
- LOGGER.error("Failed to create application directory", e);
+ LOGGER.error("Failed to create application directory {}", path.toAbsolutePath().toString(), e);
}
}
//
//
application.initialize(path);
}
-
}
Code Review / policy / xacml-pdp.git / blobdiff