Merge pull request #93 from PalladioSimulator/teammates_rules

Add supporting structure for Teammates project-specific rules

bundles/org.palladiosimulator.retriever.extraction.discoverers/plugin.xml

@@ -57,5 +57,13 @@
 			class="org.palladiosimulator.retriever.extraction.discoverers.EcmaScriptDiscoverer">
 		</discoverer>
 	</extension>
+ <extension
+       id="org.palladiosimulator.retriever.extraction.discoverers.docker"
+       name="Dockerfile Discoverer"
+       point="org.palladiosimulator.retriever.services.discoverer">
+    <discoverer
+          class="org.palladiosimulator.retriever.extraction.discoverers.DockerfileDiscoverer">
+    </discoverer>
+ </extension>
 
 </plugin>

bundles/org.palladiosimulator.retriever.extraction.discoverers/src/org/palladiosimulator/retriever/extraction/discoverers/DockerfileDiscoverer.java

@@ -0,0 +1,69 @@
+package org.palladiosimulator.retriever.extraction.discoverers;
+
+import java.nio.file.Path;
+import java.nio.file.Paths;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.Objects;
+import java.util.Set;
+
+import org.eclipse.core.runtime.IProgressMonitor;
+import org.eclipse.emf.common.CommonPlugin;
+import org.palladiosimulator.retriever.services.Discoverer;
+import org.palladiosimulator.retriever.services.RetrieverConfiguration;
+import org.palladiosimulator.retriever.services.blackboard.RetrieverBlackboard;
+
+import de.uka.ipd.sdq.workflow.jobs.AbstractBlackboardInteractingJob;
+import de.uka.ipd.sdq.workflow.jobs.CleanupFailedException;
+import de.uka.ipd.sdq.workflow.jobs.IBlackboardInteractingJob;
+import de.uka.ipd.sdq.workflow.jobs.JobFailedException;
+import de.uka.ipd.sdq.workflow.jobs.UserCanceledException;
+
+public class DockerfileDiscoverer implements Discoverer {
+
+    private static final String DISCOVERER_ID = "org.palladiosimulator.retriever.extraction.discoverers.docker";
+
+    @Override
+    public IBlackboardInteractingJob<RetrieverBlackboard> create(final RetrieverConfiguration configuration,
+            final RetrieverBlackboard blackboard) {
+        return new AbstractBlackboardInteractingJob<>() {
+
+            @Override
+            public void cleanup(final IProgressMonitor monitor) throws CleanupFailedException {
+            }
+
+            @Override
+            public void execute(final IProgressMonitor monitor) throws JobFailedException, UserCanceledException {
+                final Path root = Paths.get(CommonPlugin.asLocalURI(configuration.getInputFolder())
+                    .devicePath());
+                this.setBlackboard(Objects.requireNonNull(blackboard));
+                final Map<Path, Object> dockerfiles = new HashMap<>();
+                Discoverer.find(root, "Dockerfile", this.logger)
+                    .forEach(p -> dockerfiles.put(p, null));
+                this.getBlackboard()
+                    .putDiscoveredFiles(DISCOVERER_ID, dockerfiles);
+            }
+
+            @Override
+            public String getName() {
+                return "Dockerfile Discoverer Job";
+            }
+        };
+    }
+
+    @Override
+    public Set<String> getConfigurationKeys() {
+        return Collections.emptySet();
+    }
+
+    @Override
+    public String getID() {
+        return DISCOVERER_ID;
+    }
+
+    @Override
+    public String getName() {
+        return "Dockerfile Discoverer";
+    }
+}

bundles/org.palladiosimulator.retriever.extraction/src/org/palladiosimulator/retriever/extraction/commonalities/Component.java

@@ -15,12 +15,14 @@ public class Component {
     private final CompUnitOrName compUnitOrName;
     private final Requirements requirements;
     private final Provisions provisions;
+    private final Optional<String> separatingIdentifier;
 
-    public Component(final CompUnitOrName compUnitOrName, final Requirements requirements,
-            final Provisions provisions) {
+    public Component(final CompUnitOrName compUnitOrName, final Requirements requirements, final Provisions provisions,
+            final Optional<String> separatingIdentifier) {
         this.compUnitOrName = compUnitOrName;
         this.requirements = requirements;
         this.provisions = provisions;
+        this.separatingIdentifier = separatingIdentifier;
     }
 
     public Requirements requirements() {
@@ -43,6 +45,10 @@ public CompUnitOrName identifier() {
         return this.compUnitOrName;
     }
 
+    public Optional<String> separatingIdentifier() {
+        return this.separatingIdentifier;
+    }
+
     @Override
     public int hashCode() {
         return Objects.hash(this.compUnitOrName, this.provisions, this.requirements);

bundles/org.palladiosimulator.retriever.extraction/src/org/palladiosimulator/retriever/extraction/commonalities/ComponentBuilder.java

@@ -2,6 +2,7 @@
 
 import java.util.Collection;
 import java.util.Objects;
+import java.util.Optional;
 
 /**
  * Used to build {@code Component}s.
@@ -13,11 +14,13 @@ public class ComponentBuilder {
     private final CompUnitOrName compUnitOrName;
     private final RequirementsBuilder requirements;
     private final ProvisionsBuilder provisions;
+    private Optional<String> separatingIdentifier;
 
     public ComponentBuilder(final CompUnitOrName compUnitOrName) {
         this.compUnitOrName = compUnitOrName;
         this.requirements = new RequirementsBuilder();
         this.provisions = new ProvisionsBuilder();
+        this.separatingIdentifier = Optional.empty();
     }
 
     public CompUnitOrName identifier() {
@@ -32,10 +35,14 @@ public ProvisionsBuilder provisions() {
         return this.provisions;
     }
 
+    public void setSeparatingIdentifier(final String separatingIdentifier) {
+        this.separatingIdentifier = Optional.of(separatingIdentifier);
+    }
+
     public Component create(final Collection<OperationInterface> allDependencies,
             final Collection<OperationInterface> visibleProvisions) {
         return new Component(this.compUnitOrName, this.requirements.create(allDependencies, visibleProvisions),
-                this.provisions.create(allDependencies));
+                this.provisions.create(allDependencies), this.separatingIdentifier);
     }
 
     @Override

bundles/org.palladiosimulator.retriever.extraction/src/org/palladiosimulator/retriever/extraction/commonalities/CompositeBuilder.java

@@ -9,6 +9,7 @@
 import java.util.List;
 import java.util.Map;
 import java.util.Objects;
+import java.util.Optional;
 import java.util.PriorityQueue;
 import java.util.Queue;
 import java.util.Set;
@@ -215,13 +216,19 @@ private static List<OperationInterface> findRequiringComponents(final Set<Compon
             .filter(x -> !compositeProvisions.containsEntire(x))
             .forEach(provisions::add);
 
+        final Optional<String> separatingIdentifier = providingComponent.separatingIdentifier();
+
         final List<OperationInterface> traversedOperations = new ArrayList<>();
         while (!provisions.isEmpty()) {
             final OperationInterface provision = provisions.pop();
             final Set<Component> requiringComponents = remainingComponents.stream()
                 .filter(x -> x.requirements()
                     .containsPartOf(provision))
                 .filter(x -> !providingComponent.equals(x))
+                .filter(x -> x.separatingIdentifier()
+                    .isEmpty() || separatingIdentifier.isEmpty()
+                        || x.separatingIdentifier()
+                            .equals(separatingIdentifier))
                 .collect(Collectors.toSet());
 
             // Skip this provision if no unit requires it.
@@ -250,13 +257,19 @@ private static List<OperationInterface> findProvidingComponents(final Set<Compon
             .filter(x -> !compositeProvisions.containsEntire(x))
             .forEach(requirements::add);
 
+        final Optional<String> separatingIdentifier = requiringComponent.separatingIdentifier();
+
         final List<OperationInterface> traversedOperations = new ArrayList<>();
         while (!requirements.isEmpty()) {
             final OperationInterface requirement = requirements.pop();
             final Set<Component> providingComponents = remainingComponents.stream()
                 .filter(x -> x.provisions()
                     .containsPartOf(requirement))
                 .filter(x -> !requiringComponent.equals(x))
+                .filter(x -> x.separatingIdentifier()
+                    .isEmpty() || separatingIdentifier.isEmpty()
+                        || x.separatingIdentifier()
+                            .equals(separatingIdentifier))
                 .collect(Collectors.toSet());
 
             // Skip this requirement if no unit provides it.

bundles/org.palladiosimulator.retriever.extraction/src/org/palladiosimulator/retriever/extraction/commonalities/PCMDetectionResult.java

@@ -4,6 +4,7 @@
 import java.util.LinkedList;
 import java.util.List;
 import java.util.Map;
+import java.util.Optional;
 import java.util.Set;
 import java.util.stream.Collectors;
 
@@ -93,27 +94,63 @@ private static Set<Composite> createCompositeComponents(final Set<Component> fre
         final Set<Composite> redundantComposites = new HashSet<>();
         final Set<Composite> remainingComposites = new HashSet<>();
 
-        for (int i = 0; i < allComposites.size(); ++i) {
-            final Composite subject = allComposites.get(i);
-            final long subsetCount = allComposites.subList(i + 1, allComposites.size())
-                .stream()
+        for (final Composite subject : allComposites) {
+            final Optional<Composite> other = allComposites.stream()
+                .filter(x -> !subject.equals(x))
                 .filter(x -> !redundantComposites.contains(x))
-                .filter(x -> subject.isSubsetOf(x) || x.isSubsetOf(subject))
-                .count();
+                .filter(x -> subject.isSubsetOf(x))
+                .findFirst();
 
-            // Any composite is guaranteed to be the subset of at least one composite in the
-            // list, namely itself. If it is the subset of any composites other than itself, it is
-            // redundant.
-            if (subsetCount > 0) {
+            if (other.isPresent()) {
                 redundantComposites.add(subject);
+                continue;
             } else {
                 // TODO: Is there any merging necessary, like adapting the redundant composite's
                 // requirements to its peer?
                 remainingComposites.add(subject);
             }
         }
 
+        // Remove composite components contained in multiple other composites, according to a
+        // conservative heuristic.
+        // TODO: A comprehensive solution would require e.g. graph traversal and tie-breaking in
+        // cycles.
+
+        final Set<Composite> collectivelyContainedComposites = new HashSet<>();
+        for (final Composite subject : remainingComposites) {
+            final Set<Component> allOtherParts = remainingComposites.stream()
+                .filter(x -> !subject.equals(x))
+                .map(Composite::parts)
+                .flatMap(Set::stream)
+                .collect(Collectors.toSet());
+            final boolean isContainedInOthers = subject.parts()
+                .stream()
+                .allMatch(allOtherParts::contains);
+            if (isContainedInOthers) {
+                collectivelyContainedComposites.add(subject);
+            }
+        }
+
+        final Set<Composite> actuallyContainedComposites = new HashSet<>();
+        for (final Composite subject : collectivelyContainedComposites) {
+            final Set<Component> allOtherParts = remainingComposites.stream()
+                .filter(x -> !subject.equals(x))
+                .filter(x -> !collectivelyContainedComposites.contains(x))
+                .map(Composite::parts)
+                .flatMap(Set::stream)
+                .collect(Collectors.toSet());
+            final boolean isContainedInOthers = subject.parts()
+                .stream()
+                .allMatch(allOtherParts::contains);
+            if (isContainedInOthers) {
+                actuallyContainedComposites.add(subject);
+            }
+        }
+
+        remainingComposites.removeAll(actuallyContainedComposites);
+
         return remainingComposites;
+
     }
 
     private static Set<OperationInterface> collectVisibleProvisions(final Set<Component> components,