Patched something, but broke everything related to task communication

bootstrap/core_algorithm.alc

@@ -893,12 +893,14 @@ Void function enact_PM(pm : Element, mapping : Element):
 
 	output("Success")
 
+	log("Prepare for PM enactment...")
 	// For all entries in the signature, not in the mapping, we add a mock location
 	Element signature
 	String mock_location
 	Element mock_locations
 	mock_locations = set_create()
 	signature = PM_signature(pm)
+	log("Got signature: " + dict_to_string(signature))
 	keys = dict_keys(signature)
 	while (set_len(keys) > 0):
 		key = set_pop(keys)
@@ -906,15 +908,23 @@ Void function enact_PM(pm : Element, mapping : Element):
 			// Add mock location
 			mock_location = ""
 			while (get_entry_id(mock_location) != ""):
+				log("Try to generate")
 				mock_location = ".tmp/" + random_string(10)
+				log("Mock location: " + mock_location)
+			log("Got mock location: " + mock_location)
 			dict_add(mapping, key, mock_location)
+			log("Model add...")
 			cmd_model_add(signature[key], mapping[key], "")
+			log("Added model...")
 			set_add(mock_locations, mock_location)
+			log("Got mock location")
 
+	log("Init join")
 	// Initialize Join counters
 	counters = dict_create()
 	join_nodes = allInstances(pm, "Join")
 	while (set_len(join_nodes) > 0):
+		log("Increment counters")
 		dict_add(counters, set_pop(join_nodes), 0)
 
 	// Initialize activity to task dictionary with empty sets
@@ -922,18 +932,22 @@ Void function enact_PM(pm : Element, mapping : Element):
 	Element task_to_activity
 	Element task_to_result
 
+	log("Initializing dicts")
 	activity_to_task = dict_create()
 	task_to_activity = dict_create()
 	task_to_result = dict_create()
 	exec_nodes = allInstances(pm, "Exec")
 	while (set_len(exec_nodes) > 0):
 		dict_add(activity_to_task, set_pop(exec_nodes), set_create())
+		log("Adding activity to task for node")
 
 	// Create the worklist with the Start instance as first element
 	worklist = set_create()
+	log("Fetching all starts")
 	set_add(worklist, set_pop(allInstances(pm, "Start")))
 
 	// Keep on iterating until we reach finish
+	log("Prepare done!")
 	while (True):
 		// Check if there are PM elements to expand
 		if (set_len(worklist) > 0):
@@ -943,6 +957,7 @@ Void function enact_PM(pm : Element, mapping : Element):
 			// Find the type (to see what to do with it)
 			//   this does not yet yield the type of transformation, if it is an Execution
 			type = read_type(pm, element)
+			log("Check element " + element + " of type " + type)
 
 			// Some types have nothing to do, such as start and fork
 			// Therefore, they are not mentioned in the following conditional
@@ -1109,7 +1124,10 @@ String function cmd_model_add(type : String, name : String, code : String):
 				if (element_eq(mm, read_root())):
 					return "Type is not typed by formalisms/SimpleClassDiagrams: " + type!
 
-				new_model = compile_model(code, mm)
+				if (code == ""):
+					new_model = instantiate_model(mm)
+				else:
+					new_model = compile_model(code, mm)
 
 				if (element_eq(new_model, read_root())):
 					return "Compilation error"!
@@ -1127,6 +1145,7 @@ String function cmd_process_execute(process : String, mapping : Element):
 	// Execute a process model until it reaches termination
 	String process_id
 
+	log("Process execute start")
 	process_id = get_entry_id(process)
 	if (process_id != ""):
 		if (allow_read(current_user_id, process_id)):
@@ -2367,6 +2386,7 @@ Void function user_function_skip_init(user_id : String):
 
 	while (True):
 		cmd = input()
+		log("Processing cmd  " + cmd)
 		if (cmd == "help"):
 			output(cmd_help())
 		elif (cmd == "model_add"):

model/model.py

@@ -388,20 +388,7 @@ class ModelverseInterface(AtomicDEVS):
         else:
             for k in self.state.send_operations.keys():
                 if self.state.send_operations[k]:
-                    self.state.send_operations[k].pop(0)
-
-                    if not self.state.send_operations[k]:
-                        del self.state.send_operations[k]
-
-                        # At the end of these operations, so finish up!
-                        if self.state.task_to_spawner[k] is not None:
-                            self.state.keyed_operations.pop(self.state.task_to_operation[self.state.task_to_spawner[k]], None)
-                            self.state.additional_operations.insert(0, [])
-                            self.state.send_operations[self.state.task_to_spawner[k]] = ["__continue__"]
-                        else:
-                            self.state.additional_operations.pop(0)
-                            self.state.operations.pop(0)
-                            print("Clear up to the normal task!")
+                    self.state.send_operations[k][0] = None
 
         self.state.blocked = True
         return self.state
@@ -435,13 +422,24 @@ class ModelverseInterface(AtomicDEVS):
                     # NOTE We now know that there is something to do on an other task, so we just wait for that event to come in
                     self.state.operations.insert(0, [])
                     self.state.operations.insert(0, [])
+                    self.state.operations.insert(0, [])
                 elif prev_output.startswith("Finished task: "):
                     self.state.blocked = True
+                elif " : " in prev_output:
+                    task_name, _ = prev_output.split(" : ", 1)
+                    self.state.blocked = True
+                    self.state.task_to_spawner[task_name] = None
+                    # NOTE We now know that there is something to do on an other task, so we just wait for that event to come in
+                    self.state.operations.insert(0, [])
+                    self.state.operations.insert(0, [])
+                    self.state.operations.insert(0, [])
                 else:
                     print("UNKNOWN: " + str(prev_output))
 
             elif inp[0] != self.taskname:
                 # Got some output on another task
+                self.state.send_operations[inp[0]].pop(0)
+
                 if inp[1].startswith("Please edit this model before sending next input: "):
                     _, model_name = inp[1].split("Please edit this model before sending next input: ", 1)
                     new_taskname = str(uuid.uuid4())
@@ -453,8 +451,19 @@ class ModelverseInterface(AtomicDEVS):
                 elif inp[1].startswith("Please perform manual operation "):
                     _, op_name = inp[1].split("Please perform manual operation ", 1)
                     self.state.task_to_operation[inp[0]] = op_name[1:-1]
-                elif inp[1].startswith("Success: ready for "):
-                    pass
+
+                if not self.state.send_operations[inp[0]]:
+                    del self.state.send_operations[inp[0]]
+
+                    # At the end of these operations, so finish up!
+                    if self.state.task_to_spawner[inp[0]] is not None:
+                        self.state.keyed_operations.pop(self.state.task_to_operation[self.state.task_to_spawner[inp[0]]], None)
+                        self.state.additional_operations.insert(0, [])
+                        self.state.send_operations[self.state.task_to_spawner[inp[0]]] = ["__continue__"]
+                    else:
+                        self.state.additional_operations.pop(0)
+                        self.state.operations.pop(0)
+                        print("Clear up to the normal task!")
 
         return self.state
 
@@ -464,9 +473,13 @@ class ModelverseInterface(AtomicDEVS):
             if self.state.create_additional_task:
                 outp.append(('task_manager', self.state.create_additional_task))
             for k, v in self.state.send_operations.items():
-                outp.append((k, v[0]))
+                if v and v[0] is not None:
+                    outp.append((k, v[0]))
             print("REQUEST special: " + str(outp))
-            return {self.to_mvk: outp}
+            if outp:
+                return {self.to_mvk: outp}
+            else:
+                return {}
         elif self.state.operations:
             print("REQUEST: " + str(self.state.operations[0]))
             return {self.to_mvk: [(self.taskname, self.state.operations[0])]}
@@ -645,12 +658,12 @@ additional_operations = [[], # revise_req
                         ]
 
 #additional_operations = [[]]
-keyed_operations = {"models/revise_req": [["model_overwrite"] + compile_model("models/requirements_model.mvc")],
-                    "models/revise_plant": [["model_overwrite"] + compile_model("models/plant_model.mvc")],
-                    "models/revise_environment": [["model_overwrite"] + compile_model("models/environment_model.mvc")],
-                    "models/revise_control": [["model_overwrite"] + compile_model("models/control_model.mvc")],
-                    "models/revise_query": [["model_overwrite"] + compile_model("models/query_model.mvc")],
-                    "models/revise_architecture": [["model_overwrite"] + compile_model("models/architecture_model.mvc")],
+keyed_operations = {"models/revise_req": [["upload"], compile_model("models/requirements_model.mvc")],
+                    "models/revise_plant": [["upload"], compile_model("models/plant_model.mvc")],
+                    "models/revise_environment": [["upload"], compile_model("models/environment_model.mvc")],
+                    "models/revise_control": [["upload"], compile_model("models/control_model.mvc")],
+                    "models/revise_query": [["upload"], compile_model("models/query_model.mvc")],
+                    "models/revise_architecture": [["upload"], compile_model("models/architecture_model.mvc")],
                     }
 #keyed_operations = {"models/modify_lang": [["instantiate_node", "PN/Class", ""]]}
 finish_on = "FINISHED"