Merge branch 'dev/dotnet' of https://github.com/codedx/codepulse into dev/dotnet

Author: Steve Salas

codepulse/src/main/scala/com/secdec/codepulse/input/project/ProjectInput.scala

@@ -21,47 +21,100 @@ package com.secdec.codepulse.input.project
 
 import scala.concurrent.ExecutionContext.Implicits.global
 
-import akka.actor.{ Actor, Stash }
+import akka.actor.{ Actor, ActorRef, Stash }
+import scala.collection.mutable.{ Map => MutableMap }
 import com.secdec.codepulse.data.model.{ ProjectData, ProjectId }
 import com.secdec.codepulse.events.GeneralEventBus
+import com.secdec.codepulse.input.LanguageProcessor
 import com.secdec.codepulse.processing.ProcessEnvelope
 import com.secdec.codepulse.processing.ProcessStatus._
-import com.secdec.codepulse.tracer.{ generalEventBus, projectDataProvider, projectManager }
+import com.secdec.codepulse.tracer.{ BootVar, generalEventBus, projectDataProvider, projectManager }
 
 trait ProjectLoader {
-	def createAndLoadProjectData(doLoad: (ProjectData, GeneralEventBus) => Unit): ProjectData
+	protected def createProject: ProjectData
 }
 
-case class CreateProject(load: (ProjectData, GeneralEventBus) => Unit)
+case class CreateProject(processors: List[BootVar[ActorRef]], load: (ProjectData, GeneralEventBus) => Unit)
 
 class ProjectInputActor extends Actor with Stash with ProjectLoader {
 
+	val projectCreationProcessors = MutableMap.empty[String, List[BootVar[ActorRef]]]
+
+	val projectProcessingSuccesses = MutableMap.empty[String, Integer]
+
+	val projectProcessingFailures = MutableMap.empty[String, Integer]
+
 	// TODO: handle data input by creating a project and broadcasting with 'DataInputAvailable' with project payload
 	// TODO: capture failed state to cause a failed message and redirect (as necessary) for the user
 
 	def receive = {
-		case CreateProject(load) => {
-			val projectData = createAndLoadProjectData(load)
+		case CreateProject(processors, load) => {
+			val projectData = createProject
+			addProjectCreators(projectData, processors)
+
+			load(projectData, generalEventBus)
+
 			sender ! projectData
 		}
 		case ProcessEnvelope(_, ProcessDataAvailable(identifier, file, treeNodeData)) => {
-			for (target <- projectManager getProject ProjectId(identifier.toInt)) {
-				target.notifyLoadingFinished()
+			val numberOfProcessors = projectCreationProcessors.get(identifier).get.length
+			val succeeded = projectProcessorSucceeded(identifier)
+			val failed = projectProcessingFailures.get(identifier).get
+
+			val remaining = numberOfProcessors - (succeeded + failed)
+
+			if(remaining == 0 && succeeded >= 1) {
+				projectManager getProject ProjectId(identifier.toInt) foreach(_.notifyLoadingFinished())
+				clearProjectCreators(identifier)
 			}
 		}
 		case ProcessEnvelope(_, Failed(identifier, action, Some(exception))) if action != "Dependency Check" => {
-			for (target <- projectManager.removeUnloadedProject(ProjectId(identifier.toInt), exception.getMessage)) {
-				//target.notifyLoadingFailed(exception.getMessage)
+			val numberOfProcessors = projectCreationProcessors.get(identifier).get.length
+			val succeeded = projectProcessingSuccesses.get(identifier).get
+			val failed = projectProcessorFailed(identifier)
+
+			val remaining = numberOfProcessors - (succeeded + failed)
+
+			if(remaining == 0 && failed == numberOfProcessors) {
+				projectManager.removeUnloadedProject(ProjectId(identifier.toInt), exception.getMessage)
+				clearProjectCreators(identifier)
 			}
 		}
 	}
 
-	def createAndLoadProjectData(doLoad: (ProjectData, GeneralEventBus) => Unit): ProjectData = {
+	protected def createProject: ProjectData = {
 		val projectId = projectManager.createProject
 		val projectData = projectDataProvider getProject projectId
 
-		doLoad(projectData, generalEventBus)
-
 		projectData
 	}
+
+	protected def addProjectCreators(projectData: ProjectData, processors: List[BootVar[ActorRef]]): Integer = {
+		val id = projectData.id.num.toString
+		projectCreationProcessors.put(id, processors)
+		projectProcessingSuccesses.put(id, 0)
+		projectProcessingFailures.put(id, 0)
+		processors.length
+	}
+
+	protected def clearProjectCreators(projectId: String) = {
+		projectCreationProcessors.remove(projectId)
+		projectProcessingSuccesses.remove(projectId)
+		projectProcessingFailures.remove(projectId)
+	}
+
+	protected def projectProcessorSucceeded(projectId: String): Integer = {
+		incrementProcessor(projectId, projectProcessingSuccesses)
+	}
+
+	protected def projectProcessorFailed(projectId: String) = {
+		incrementProcessor(projectId, projectProcessingFailures)
+	}
+
+	private def incrementProcessor(key: String, map: MutableMap[String, Integer]): Integer = {
+		val count = map.get(key).get + 1
+		map.update(key, count)
+
+		count
+	}
 }

codepulse/src/main/scala/com/secdec/codepulse/tracer/ProjectFileUploadHandler.scala

@@ -73,7 +73,7 @@ class ProjectFileUploadHandler(projectManager: ProjectManager, eventBus: General
 				}
 				name <- req.param("name") ?~ "You must specify a name"
 			} yield {
-				val project = Await.result((projectInput() ? CreateProject((projectData, eventBus) => {
+				val project = Await.result((projectInput() ? CreateProject(processors, (projectData, eventBus) => {
 					projectData.metadata.name = name
 					projectData.metadata.creationDate = System.currentTimeMillis
 

codepulse/src/main/scala/com/secdec/codepulse/util/ZipEntryChecker.scala

@@ -68,7 +68,7 @@ trait ZipEntryChecker {
 				entry <- entryStream
 				if !ZipCleaner.shouldFilter(entry)
 			} {
-				if (isZip(entry.getName) && recursive)
+				if (entry.isDirectory || (isZip(entry.getName) && recursive))
 					forEachEntry(s"$filename/${entry.getName}", new CloseShieldInputStream(zipStream), true)(callback)
 				else
 					callback(filename, entry, zipStream)
@@ -104,9 +104,9 @@ trait ZipEntryChecker {
 				.filterNot(ZipCleaner.shouldFilter)
 
 			entryStream.exists { entry =>
-				lazy val recurse = recursive &&
+				lazy val recurse = entry.isDirectory || (recursive &&
 					isZip(entry.getName) &&
-					findFirstEntry(s"$filename/${entry.getName}", new CloseShieldInputStream(zipStream), true)(predicate)
+					findFirstEntry(s"$filename/${entry.getName}", new CloseShieldInputStream(zipStream), true)(predicate))
 
 				predicate(filename, entry, zipStream) || recurse
 			}