The DAO is now able to dump its data to a recovery file and re-read it

Tests now cover the whole DynamicInstanceDAO

Author: Johannes Duesing

src/main/scala/de/upb/cs/swt/delphi/instanceregistry/Configuration.scala

@@ -3,4 +3,5 @@ package de.upb.cs.swt.delphi.instanceregistry
 class Configuration(  //Server configuration
                     val bindHost: String = "0.0.0.0",
                     val bindPort: Int = 8087,
+                      val recoveryFileName : String = "dump.temp",
                    ) 

src/main/scala/de/upb/cs/swt/delphi/instanceregistry/daos/DynamicInstanceDAO.scala

@@ -1,21 +1,33 @@
 package de.upb.cs.swt.delphi.instanceregistry.daos
 
+import java.io.{File, IOException, PrintWriter}
+
 import akka.actor.ActorSystem
-import de.upb.cs.swt.delphi.instanceregistry.{AppLogging, Server}
-import de.upb.cs.swt.delphi.instanceregistry.io.swagger.client.model.Instance
+import akka.stream.ActorMaterializer
+import de.upb.cs.swt.delphi.instanceregistry.{AppLogging, Configuration, Server}
+import de.upb.cs.swt.delphi.instanceregistry.io.swagger.client.model.{Instance, JsonSupport}
 import de.upb.cs.swt.delphi.instanceregistry.io.swagger.client.model.InstanceEnums.ComponentType
 
 import scala.collection.mutable
+import scala.concurrent.ExecutionContext
 import scala.util.{Failure, Success, Try}
+import spray.json._
+import spray.json.DefaultJsonProtocol._
+
+import scala.io.Source
 
 /**
   * Implementation of the instance data access object that keeps its data in memory
   * instead of using a persistent storage.
   */
-class DynamicInstanceDAO extends InstanceDAO with AppLogging {
+class DynamicInstanceDAO (configuration : Configuration) extends InstanceDAO with AppLogging with JsonSupport {
 
   private val instances : mutable.Set[Instance] = new mutable.HashSet[Instance]()
+
   implicit val system : ActorSystem = Server.system
+  implicit val materializer : ActorMaterializer = ActorMaterializer()
+  implicit val ec : ExecutionContext = system.dispatcher
+
 
   override def addInstance(instance: Instance): Try[Unit] = {
     //Verify ID is present in instance
@@ -27,6 +39,7 @@ class DynamicInstanceDAO extends InstanceDAO with AppLogging {
       //Verify id is not already present in instances!
       if(!hasInstance(instance.id.get)){
         instances.add(instance)
+        dumpToRecoveryFile()
         Success(log.info(s"Added instance ${instance.name} with id ${instance.id} to database."))
       } else {
         val msg = s"Cannot add instance ${instance.name}, id ${instance.id} already present."
@@ -46,6 +59,7 @@ class DynamicInstanceDAO extends InstanceDAO with AppLogging {
     if(hasInstance(id)){
       //AddInstance verifies that id is always present, hasInstance verifies that find will return an instance
       instances.remove(instances.find(i => i.id.get == id).get)
+      dumpToRecoveryFile()
       Success(log.info(s"Successfully removed instance with id $id."))
     } else {
       val msg = s"Cannot remove instance with id $id, that id is not present."
@@ -72,8 +86,63 @@ class DynamicInstanceDAO extends InstanceDAO with AppLogging {
     List() ++ instances
   }
 
-  override def clearAll() : Unit = {
+  override def removeAll() : Unit = {
+    instances.clear()
+    dumpToRecoveryFile()
+  }
+
+  private[daos] def clearData() : Unit = {
     instances.clear()
   }
 
+  private[daos] def dumpToRecoveryFile() : Unit = {
+    log.info(s"Dumping data to recovery file ${configuration.recoveryFileName} ...")
+    val writer = new PrintWriter(new File(configuration.recoveryFileName))
+    writer.write(getAllInstances().toJson(listFormat(instanceFormat)).toString())
+    writer.flush()
+    writer.close()
+    log.info(s"Successfully wrote to recovery file.")
+  }
+
+  private[daos] def deleteRecoveryFile() : Unit = {
+    log.info("Deleting data recovery file...")
+    if(new File(configuration.recoveryFileName).delete()){
+      log.info(s"Successfully deleted data recovery file ${configuration.recoveryFileName}.")
+    } else {
+      log.warning(s"Failed to delete data recovery file ${configuration.recoveryFileName}.")
+    }
+  }
+
+  private[daos] def tryInitFromRecoveryFile() : Unit = {
+    try {
+      log.info(s"Attempting to load data from recovery file ${configuration.recoveryFileName} ...")
+      val recoveryFileContent = Source.fromFile(configuration.recoveryFileName).getLines()
+
+      if(!recoveryFileContent.hasNext){
+        log.warning(s"Recovery file invalid, more than one line found.")
+        throw new IOException("Recovery file invalid.")
+      }
+
+      val jsonString : String = recoveryFileContent.next()
+
+      val instanceList = jsonString.parseJson.convertTo[List[Instance]](listFormat(instanceFormat))
+
+      log.info(s"Successfully loaded ${instanceList.size} instance from recovery file. Initializing...")
+
+      clearData()
+      for(instance <- instanceList){
+        addInstance(instance)
+      }
+
+      log.info(s"Successfully initialized from recovery file.")
+
+    } catch  {
+      case iox : IOException =>
+        log.error(iox, s"An error occurred while reading the recovery file at ${configuration.recoveryFileName}.")
+      case x : Exception =>
+        log.error(x, "An error occurred while deserializing the contents of the recovery file.")
+    }
+
+  }
+
 }

src/main/scala/de/upb/cs/swt/delphi/instanceregistry/daos/InstanceDAO.scala

@@ -54,6 +54,6 @@ trait InstanceDAO {
   /**
     * Removes all instances from the DAO
     */
-  def clearAll() : Unit
+  def removeAll() : Unit
 
 }

src/test/scala/de/upb/cs/swt/delphi/instanceregistry/daos/DynamicInstanceDAOTest.scala

@@ -1,19 +1,20 @@
 package de.upb.cs.swt.delphi.instanceregistry.daos
 
+import de.upb.cs.swt.delphi.instanceregistry.Configuration
 import de.upb.cs.swt.delphi.instanceregistry.io.swagger.client.model.Instance
 import de.upb.cs.swt.delphi.instanceregistry.io.swagger.client.model.InstanceEnums.ComponentType
-import org.scalatest.{BeforeAndAfterAll, FlatSpec, Matchers}
+import org.scalatest.{BeforeAndAfterAll, BeforeAndAfterEach, FlatSpec, Matchers}
 
-class DynamicInstanceDAOTest extends FlatSpec with Matchers with BeforeAndAfterAll{
+class DynamicInstanceDAOTest extends FlatSpec with Matchers with BeforeAndAfterEach{
 
-  val dao : InstanceDAO = new DynamicInstanceDAO()
+  val dao : DynamicInstanceDAO = new DynamicInstanceDAO(new Configuration())
 
   private def buildInstance(id : Int) : Instance = {
     Instance(Some(id), "https://localhost", 12345, "TestInstance", ComponentType.Crawler)
   }
 
-  override protected def beforeAll() : Unit = {
-    dao.clearAll()
+  override protected def beforeEach() : Unit = {
+    dao.deleteRecoveryFile()
     for(i <- 1 to 3){
       dao.addInstance(buildInstance(i))
     }
@@ -26,4 +27,95 @@ class DynamicInstanceDAOTest extends FlatSpec with Matchers with BeforeAndAfterA
     assert(dao.removeInstance(4).isSuccess)
   }
 
+  it must "not allow the addition of any id twice" in {
+    assert(dao.addInstance(buildInstance(3)).isFailure)
+    assert(dao.getAllInstances().size == 3)
+  }
+
+  it must "return true on hasInstance for any present id" in {
+    for(i <- 1 to 3){
+      assert(dao.hasInstance(i))
+    }
+  }
+
+  it must "return false on hasInstance for any id not present" in {
+    assert(!dao.hasInstance(-1))
+    assert(!dao.hasInstance(Long.MaxValue))
+    assert(!dao.hasInstance(4))
+  }
+
+  it must "return instances with the correct id on getInstance" in {
+    for(i <- 1 to 3){
+      val instance = dao.getInstance(i)
+      assert(instance.isDefined)
+      assert(instance.get.id.isDefined)
+      assert(instance.get.id.get == i)
+    }
+  }
+
+  it must "return instance with the correct type on getInstanceOfType" in {
+    val compTypeInstances = dao.getInstancesOfType(ComponentType.Crawler)
+    assert(compTypeInstances.size == 3)
+
+    for(instance <- compTypeInstances){
+      assert(instance.componentType == ComponentType.Crawler)
+    }
+  }
+
+  it must "remove instances that are present in the DAO" in {
+    for(i <- 1 to 3){
+      assert(dao.removeInstance(i).isSuccess)
+      assert(!dao.hasInstance(i))
+    }
+    assert(dao.getAllInstances().isEmpty)
+  }
+
+  it must "not change the data on removing invalid IDs" in {
+    assert(dao.removeInstance(-1).isFailure)
+    assert(dao.removeInstance(Long.MaxValue).isFailure)
+    assert(dao.removeInstance(4).isFailure)
+  }
+
+  it must "remove all instance on removeAll" in {
+    dao.removeAll()
+    assert(dao.getAllInstances().isEmpty)
+  }
+
+  "The DAO" must "be able to read multiple instances from the recovery file" in {
+    dao.dumpToRecoveryFile()
+    dao.clearData()
+    assert(dao.getAllInstances().isEmpty)
+    dao.tryInitFromRecoveryFile()
+    assert(dao.getAllInstances().size == 3)
+  }
+
+  it must "fail to load from recovery file if it is not present" in {
+    dao.dumpToRecoveryFile()
+    assert(dao.getAllInstances().size == 3)
+    dao.deleteRecoveryFile()
+    dao.clearData()
+    assert(dao.getAllInstances().isEmpty)
+    dao.tryInitFromRecoveryFile()
+    assert(dao.getAllInstances().isEmpty)
+  }
+
+  it must "contain the correct instance data after loading from recovery file" in {
+    assert(dao.addInstance(buildInstance(4)).isSuccess)
+    dao.dumpToRecoveryFile()
+    assert(dao.getAllInstances().size == 4)
+    dao.clearData()
+    assert(dao.getAllInstances().isEmpty)
+    dao.tryInitFromRecoveryFile()
+    assert(dao.getAllInstances().size == 4)
+    val instance = dao.getInstance(4)
+    assert(instance.isDefined)
+    assert(instance.get.id.get == 4)
+  }
+
+
+  override protected def afterEach() : Unit = {
+    dao.removeAll()
+    dao.deleteRecoveryFile()
+  }
+
 }