Broken state. In the process of extracting the meta-adaptations into

separate library.

Author: iridin

.classpath

@@ -0,0 +1,16 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<classpath>
+	<classpathentry kind="src" output="target/classes" path="src">
+		<attributes>
+			<attribute name="optional" value="true"/>
+			<attribute name="maven.pomderived" value="true"/>
+		</attributes>
+	</classpathentry>
+	<classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER/org.eclipse.jdt.internal.debug.ui.launcher.StandardVMType/JavaSE-1.8"/>
+	<classpathentry kind="con" path="org.eclipse.m2e.MAVEN2_CLASSPATH_CONTAINER">
+		<attributes>
+			<attribute name="maven.pomderived" value="true"/>
+		</attributes>
+	</classpathentry>
+	<classpathentry kind="output" path="target/classes"/>
+</classpath>

.gitignore

@@ -0,0 +1,2 @@
+/bin/
+/target/

.project

@@ -0,0 +1,23 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<projectDescription>
+	<name>meta-adaptation-manager</name>
+	<comment></comment>
+	<projects>
+	</projects>
+	<buildSpec>
+		<buildCommand>
+			<name>org.eclipse.jdt.core.javabuilder</name>
+			<arguments>
+			</arguments>
+		</buildCommand>
+		<buildCommand>
+			<name>org.eclipse.m2e.core.maven2Builder</name>
+			<arguments>
+			</arguments>
+		</buildCommand>
+	</buildSpec>
+	<natures>
+		<nature>org.eclipse.m2e.core.maven2Nature</nature>
+		<nature>org.eclipse.jdt.core.javanature</nature>
+	</natures>
+</projectDescription>

.settings/org.eclipse.jdt.core.prefs

@@ -0,0 +1,12 @@
+eclipse.preferences.version=1
+org.eclipse.jdt.core.compiler.codegen.inlineJsrBytecode=enabled
+org.eclipse.jdt.core.compiler.codegen.targetPlatform=1.8
+org.eclipse.jdt.core.compiler.codegen.unusedLocal=preserve
+org.eclipse.jdt.core.compiler.compliance=1.8
+org.eclipse.jdt.core.compiler.debug.lineNumber=generate
+org.eclipse.jdt.core.compiler.debug.localVariable=generate
+org.eclipse.jdt.core.compiler.debug.sourceFile=generate
+org.eclipse.jdt.core.compiler.problem.assertIdentifier=error
+org.eclipse.jdt.core.compiler.problem.enumIdentifier=error
+org.eclipse.jdt.core.compiler.problem.forbiddenReference=warning
+org.eclipse.jdt.core.compiler.source=1.8

.settings/org.eclipse.m2e.core.prefs

@@ -0,0 +1,4 @@
+activeProfiles=
+eclipse.preferences.version=1
+resolveWorkspaceProjects=true
+version=1

pom.xml

@@ -0,0 +1,19 @@
+<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
+  <modelVersion>4.0.0</modelVersion>
+  <groupId>cz.cuni.mff.d3s</groupId>
+  <artifactId>meta-adaptation-manager</artifactId>
+  <version>0.0.1-SNAPSHOT</version>
+  <build>
+    <sourceDirectory>src</sourceDirectory>
+    <plugins>
+      <plugin>
+        <artifactId>maven-compiler-plugin</artifactId>
+        <version>3.5.1</version>
+        <configuration>
+          <source/>
+          <target/>
+        </configuration>
+      </plugin>
+    </plugins>
+  </build>
+</project>

src/cz/cuni/mff/d3s/metaadaptation/Log.java

@@ -0,0 +1,91 @@
+package cz.cuni.mff.d3s.metaadaptation;
+
+import java.io.File;
+import java.io.InputStream;
+import java.util.logging.ConsoleHandler;
+import java.util.logging.Level;
+import java.util.logging.LogManager;
+
+
+/**
+ * Simple wrapper of java.util.logging.Logger with lazy-initialized singleton
+ * object and thread-safe methods
+ * 
+ * @author Ilias Gerostathopoulos
+ * 
+ */
+public class Log {
+	
+	private static final Log INSTANCE = new Log();
+	
+	public static Log getInstance() {		
+		return INSTANCE;
+	}
+	
+	
+	/**
+	 * The default directory where the log files are placed.
+	 */
+	private static final String LOG_DIRECTORY = "logs";
+		
+	private java.util.logging.Logger logger;
+	
+	
+	private Log() {
+
+		// Check whether the directory for log files exists and create it if needed
+		File logDirectory = new File(LOG_DIRECTORY);
+		if(!logDirectory.exists() || !logDirectory.isDirectory()){
+			logDirectory.mkdirs();
+		}
+		
+		
+		logger = java.util.logging.Logger.getLogger(getClass().getPackage().getName());
+		String confPath = System.getProperty("java.util.logging.config.file");
+		if (confPath == null || confPath.equals(""))
+			confPath = "logging.properties";
+		InputStream inputStream = getClass().getClassLoader()
+				.getResourceAsStream(confPath);
+		try {
+			LogManager.getLogManager().readConfiguration(inputStream);
+		} catch (Exception e) {
+			logger = java.util.logging.Logger.getLogger("default");
+			ConsoleHandler ch = new ConsoleHandler();
+			logger.addHandler(ch);			
+			logger.severe("Could not load logging.properties file - falling backing to console logging");
+		}
+	}
+
+	public synchronized void debug(String s) {
+		logger.log(Level.FINEST, s);
+	}
+
+	public synchronized void debug(String s, Throwable t) {
+		logger.log(Level.FINEST, s, t);
+	}
+
+	public synchronized void info(String s) {
+		logger.log(Level.FINEST, s);
+	}
+
+	public synchronized void info(String s, Throwable t) {
+		logger.log(Level.INFO, s, t);
+	}
+
+	public synchronized void warning(String s) {
+		logger.log(Level.WARNING, s);
+	}
+
+	public synchronized void warning(String s, Throwable t) {
+		logger.log(Level.WARNING, s, t);
+	}
+
+	public synchronized void error(String s) {
+		logger.log(Level.SEVERE, s);
+	}
+
+	public synchronized void error(String s, Throwable t) {
+		logger.log(Level.SEVERE, s, t);
+	}
+
+}

src/cz/cuni/mff/d3s/metaadaptation/MAPEAdaptation.java

@@ -0,0 +1,32 @@
+package cz.cuni.mff.d3s.metaadaptation;
+
+/**
+ * Interface for adaptation manager to control individual adaptations.
+ */
+public interface MAPEAdaptation {
+
+	/**
+	 * Monitor the context or inner state.
+	 */
+	void monitor();
+	
+	/**
+	 * Analyze the monitored data.
+	 * The provided value indicates the applicability of the adaptation.
+	 * False means no applicability of the adaptation, True expresses
+	 * the adaptation being suitable in the current situation.
+	 * 
+	 * @return A suitability of the adaptation.
+	 */
+	boolean analyze();
+	
+	/**
+	 * Plan and prepare the adaptation changes.
+	 */
+	void plan();
+	
+	/**
+	 * Apply the adaptation.
+	 */
+	void execute();
+}

src/cz/cuni/mff/d3s/metaadaptation/MetaAdaptationManager.java

@@ -0,0 +1,52 @@
+/*******************************************************************************
+ * Copyright 2017 Charles University in Prague
+ *  
+ *  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.
+ *******************************************************************************/
+package cz.cuni.mff.d3s.metaadaptation;
+
+import java.util.ArrayList;
+import java.util.List;
+
+
+/**
+ * @author Dominik Skoda <[email protected]>
+ *
+ */
+public class MetaAdaptationManager {
+		
+	public List<MAPEAdaptation> adaptations;
+	
+	public MetaAdaptationManager(){
+		adaptations = new ArrayList<>();		
+	}
+	
+	public void addAdaptation(MAPEAdaptation adaptation){
+		adaptations.add(adaptation);
+	}
+	
+	/**
+	 * Run the MAPE loop of all registered {@link MAPEAdaptation}s.
+	 */
+	public void reason() {
+		for(MAPEAdaptation adaptation : adaptations){
+			adaptation.monitor();
+			boolean isApplicable = adaptation.analyze();
+			if(isApplicable){
+				adaptation.plan();
+				adaptation.execute();
+			}
+		}
+		
+	}
+}

src/cz/cuni/mff/d3s/metaadaptation/correlation/BoundaryValueHolder.java

@@ -0,0 +1,97 @@
+package cz.cuni.mff.d3s.metaadaptation.correlation;
+
+import java.io.Serializable;
+
+/**
+ * Holds a boundary value together with a flag indicating whether the value
+ * has changed since it was lastly used.
+ * 
+ * @author Dominik Skoda <[email protected]>
+ *
+ */
+public class BoundaryValueHolder implements Serializable {
+	
+	/**
+	 * Generated UID.
+	 */
+	private static final long serialVersionUID = -6438264656364851855L;
+
+	/**
+	 * The limit beyond which two doubles are considered equal.
+	 * The value of this constant influences the granularity of changing
+	 * the boundary.
+	 */
+	protected static final double EPSILON = 0.01;
+	
+	/**
+	 * Stored value of the boundary.
+	 */
+	private double boundary;
+	/**
+	 * Flag indicating whether the boundary has changed enough (see {@link #EPSILON})
+	 * since it was lastly used.
+	 */
+	private boolean changed;
+	
+	/**
+	 * Construct new instance of the {@link BoundaryValueHolder} with the
+	 * given value to hold. The {@link #hasChanged()} flag is set by default
+	 * to true.
+	 * @param boundary The boundary value to be held.
+	 */
+	public BoundaryValueHolder(double boundary) {
+		this.boundary = boundary;
+		this.changed = true;
+	}
+	
+	/**
+	 * Set new boundary to be held. If the boundary differs from the previous
+	 * one more than {@link #EPSILON} than the {@link #hasChanged()} flag
+	 * is set to true.
+	 * @param boundary The boundary to be held.
+	 */
+	public void setBoundary(double boundary) {
+		if(Double.isNaN(boundary) && Double.isNaN(this.boundary)) {
+			return;
+		}
+		if(Double.isNaN(boundary) || Double.isNaN(this.boundary)
+				|| Math.abs(this.boundary - boundary) > EPSILON) {
+			this.boundary = boundary;
+			changed = true;
+		}
+	}
+	
+	/**
+	 * Read the stored boundary.
+	 * @return The stored boundary.
+	 */
+	public double getBoundary() {
+		return boundary;
+	}
+	
+	/**
+	 * Indicates whether the boundary is valid (is not NaN).
+	 * @return True if the boundary is not NaN.
+	 */
+	public boolean isValid() {
+		return !Double.isNaN(boundary);
+	}
+	
+	/**
+	 * Set the {@link #hasChanged()} flag to false. Indicate that
+	 * the current value has been used.
+	 */
+	public void boundaryUsed() {
+		changed = false;
+	}
+	
+	/**
+	 * Indicates whether the stored boundary value has changed enough
+	 * (see {@link #EPSILON}) since its last usage.
+	 * @return
+	 */
+	public boolean hasChanged() {
+		return changed;
+	}
+
+}