public void push()

in features/src/main/java/org/apache/karaf/cellar/features/FeaturesSynchronizer.java [217:329]
96 lines of code
20 McCabe index (conditional complexity)

    public void push(Group group) {

        if (eventProducer.getSwitch().getStatus().equals(SwitchStatus.OFF)) {
            LOGGER.warn("CELLAR FEATURE: cluster event producer is OFF");
            return;
        }

        if (group != null) {
            String groupName = group.getName();
            LOGGER.debug("CELLAR FEATURE: pushing features repositories and features in cluster group {}", groupName);

            ClassLoader originalClassLoader = Thread.currentThread().getContextClassLoader();
            try {
                Thread.currentThread().setContextClassLoader(getClass().getClassLoader());

                Map<String, String> clusterRepositories = clusterManager.getMap(Constants.REPOSITORIES_MAP + Configurations.SEPARATOR + groupName);
                Map<String, FeatureState> clusterFeatures = clusterManager.getMap(Constants.FEATURES_MAP + Configurations.SEPARATOR + groupName);
                Map<String, Boolean> synchronizers = getSynchronizerMap();

                Repository[] repositoryList = new Repository[0];
                Feature[] featuresList = new Feature[0];

                try {
                    repositoryList = featuresService.listRepositories();
                    featuresList = featuresService.listFeatures();
                } catch (Exception e) {
                    LOGGER.error("CELLAR FEATURE: error listing features", e);
                }

                // push features repositories to the cluster group
                if (repositoryList != null && repositoryList.length > 0) {
                    for (Repository repository : repositoryList) {
                        try {
                            if (repository != null
                                    && repository.getURI() != null
                                    && repository.getName() != null
                                    && !clusterRepositories.containsKey(repository.getURI().toString())) {
                                LOGGER.debug("CELLAR FEATURE: pushing repository {} in cluster group {}", repository.getName(), groupName);
                                // updating cluster state
                                clusterRepositories.put(repository.getURI().toString(), repository.getName());
                                // sending cluster event
                                ClusterRepositoryEvent event = new ClusterRepositoryEvent(repository.getURI().toString(), RepositoryEvent.EventType.RepositoryAdded);
                                event.setSourceGroup(group);
                                event.setSourceNode(clusterManager.getNode());
                                event.setLocal(clusterManager.getNode());
                                eventProducer.produce(event);
                            } else {
                                LOGGER.debug("CELLAR FEATURE: repository {} is already in cluster group {}", repository.getName(), groupName);
                            }
                        } catch (Exception e) {
                            LOGGER.warn("CELLAR FEATURE: can't add repository", e);
                        }
                    }
                }
                synchronizers.put(Constants.REPOSITORIES_MAP + Configurations.SEPARATOR + groupName, true);

                // push features to the cluster group
                if (featuresList != null && featuresList.length > 0) {
                    for (Feature feature : featuresList) {
                        if (isAllowed(group, Constants.CATEGORY, feature.getName(), EventType.OUTBOUND)) {
                            boolean installed = featuresService.isInstalled(feature);
                            String key = feature.getName() + "/" + feature.getVersion();
                            FeatureState clusterFeature = clusterFeatures.get(key);
                            if (clusterFeature == null) {
                                LOGGER.debug("CELLAR FEATURE: adding feature {} to cluster group {}", key, groupName);
                                // updating cluster state
                                clusterFeature = new FeatureState();
                                clusterFeature.setName(feature.getName());
                                clusterFeature.setVersion(feature.getVersion());
                                clusterFeature.setInstalled(installed);
                                clusterFeatures.put(key, clusterFeature);
                                // sending cluster event
                                ClusterFeaturesEvent event;
                                if (installed) {
                                    event = new ClusterFeaturesEvent(feature.getName(), feature.getVersion(), FeatureEvent.EventType.FeatureInstalled);
                                } else {
                                    event = new ClusterFeaturesEvent(feature.getName(), feature.getVersion(), FeatureEvent.EventType.FeatureUninstalled);
                                }
                                event.setSourceGroup(group);
                                event.setSourceNode(clusterManager.getNode());
                                event.setLocal(clusterManager.getNode());
                                eventProducer.produce(event);

                            } else {
                                if (clusterFeature.getInstalled() != installed) {
                                    // updating cluster state
                                    clusterFeature.setInstalled(installed);
                                    clusterFeatures.put(key, clusterFeature);
                                    // sending cluster event
                                    ClusterFeaturesEvent event;
                                    if (installed) {
                                        event = new ClusterFeaturesEvent(feature.getName(), feature.getVersion(), FeatureEvent.EventType.FeatureInstalled);
                                    } else {
                                        event = new ClusterFeaturesEvent(feature.getName(), feature.getVersion(), FeatureEvent.EventType.FeatureUninstalled);
                                    }
                                    event.setSourceGroup(group);
                                    event.setSourceNode(clusterManager.getNode());
                                    eventProducer.produce(event);
                                } else {
                                    LOGGER.debug("CELLAR FEATURE: feature {} already sync on the cluster group {}", key, groupName);
                                }
                            }
                        } else {
                            LOGGER.debug("CELLAR FEATURE: feature {} is marked BLOCKED OUTBOUND for cluster group {}", feature.getName(), groupName);
                        }
                    }
                }
                synchronizers.put(Constants.FEATURES_MAP + Configurations.SEPARATOR + groupName, true);
            } finally {
                Thread.currentThread().setContextClassLoader(originalClassLoader);
            }
        }
    }