modelverse/kernel/mvk_server/server.py

"""
Generated by Statechart compiler by Glenn De Jonghe, Joeri Exelmans, Simon Van Mierlo, and Yentl Van Tendeloo (for the inspiration)

Date:   Thu Feb  9 16:38:23 2017

Model author: Yentl Van Tendeloo
Model name:   MvK Server
Model description:
Modelverse Kernel server. Server for the MvI, client of the MvS.
"""

from sccd.runtime.statecharts_core import *
import time
import os
import urllib
import sys
import json

from modelverse_kernel.main import ModelverseKernel
sys.path.append("../../state")
from modelverse_state.main import ModelverseState

# package "MvK Server"

class MvKController(RuntimeClassBase):
    def __init__(self, controller, params):
        RuntimeClassBase.__init__(self, controller)
        
        self.semantics.big_step_maximality = StatechartSemantics.TakeMany
        self.semantics.internal_event_lifeline = StatechartSemantics.Queue
        self.semantics.input_event_lifeline = StatechartSemantics.FirstComboStep
        self.semantics.priority = StatechartSemantics.SourceParent
        self.semantics.concurrency = StatechartSemantics.Single
        
        # build Statechart structure
        self.build_statechart_structure()
        
        # call user defined constructor
        MvKController.user_defined_constructor(self, params)
    
    def user_defined_constructor(self, params):
        self.users = []
        self.user_statecharts = {"__hierarchy": None}
        self.input_queue = []
        self.user_queue = {}
        self.source = None
        self.root = None
        
        self.params = params
    
    def user_defined_destructor(self):
        pass
    
    
    # builds Statechart structure
    def build_statechart_structure(self):
        
        # state <root>
        self.states[""] = State(0, self)
        
        # state /init_server
        self.states["/init_server"] = State(1, self)
        self.states["/init_server"].setEnter(self._init_server_enter)
        
        # state /init_executor
        self.states["/init_executor"] = State(2, self)
        self.states["/init_executor"].setEnter(self._init_executor_enter)
        
        # state /get_mvk
        self.states["/get_mvk"] = State(3, self)
        self.states["/get_mvk"].setEnter(self._get_mvk_enter)
        
        # state /read_root
        self.states["/read_root"] = State(4, self)
        self.states["/read_root"].setEnter(self._read_root_enter)
        
        # state /running
        self.states["/running"] = ParallelState(5, self)
        
        # state /running/wait_for_requests
        self.states["/running/wait_for_requests"] = State(6, self)
        
        # state /running/wait_for_requests/wait
        self.states["/running/wait_for_requests/wait"] = State(7, self)
        
        # state /running/push
        self.states["/running/push"] = State(8, self)
        
        # state /running/push/wait
        self.states["/running/push/wait"] = State(9, self)
        
        # state /running/push/process
        self.states["/running/push/process"] = State(10, self)
        
        # state /running/find_users
        self.states["/running/find_users"] = State(11, self)
        
        # state /running/find_users/get_all_links
        self.states["/running/find_users/get_all_links"] = State(12, self)
        self.states["/running/find_users/get_all_links"].setEnter(self._running_find_users_get_all_links_enter)
        
        # state /running/find_users/retrieve_users
        self.states["/running/find_users/retrieve_users"] = State(13, self)
        
        # state /running/find_users/got_usernames
        self.states["/running/find_users/got_usernames"] = State(14, self)
        
        # state /running/find_users/process_users
        self.states["/running/find_users/process_users"] = State(15, self)
        
        # state /running/find_users/creating_user
        self.states["/running/find_users/creating_user"] = State(16, self)
        
        # state /running/find_users/wait
        self.states["/running/find_users/wait"] = State(17, self)
        self.states["/running/find_users/wait"].setEnter(self._running_find_users_wait_enter)
        self.states["/running/find_users/wait"].setExit(self._running_find_users_wait_exit)
        
        # add children
        self.states[""].addChild(self.states["/init_server"])
        self.states[""].addChild(self.states["/init_executor"])
        self.states[""].addChild(self.states["/get_mvk"])
        self.states[""].addChild(self.states["/read_root"])
        self.states[""].addChild(self.states["/running"])
        self.states["/running"].addChild(self.states["/running/wait_for_requests"])
        self.states["/running"].addChild(self.states["/running/push"])
        self.states["/running"].addChild(self.states["/running/find_users"])
        self.states["/running/wait_for_requests"].addChild(self.states["/running/wait_for_requests/wait"])
        self.states["/running/push"].addChild(self.states["/running/push/wait"])
        self.states["/running/push"].addChild(self.states["/running/push/process"])
        self.states["/running/find_users"].addChild(self.states["/running/find_users/get_all_links"])
        self.states["/running/find_users"].addChild(self.states["/running/find_users/retrieve_users"])
        self.states["/running/find_users"].addChild(self.states["/running/find_users/got_usernames"])
        self.states["/running/find_users"].addChild(self.states["/running/find_users/process_users"])
        self.states["/running/find_users"].addChild(self.states["/running/find_users/creating_user"])
        self.states["/running/find_users"].addChild(self.states["/running/find_users/wait"])
        self.states[""].fixTree()
        self.states[""].default_state = self.states["/init_server"]
        self.states["/running/wait_for_requests"].default_state = self.states["/running/wait_for_requests/wait"]
        self.states["/running/push"].default_state = self.states["/running/push/wait"]
        self.states["/running/find_users"].default_state = self.states["/running/find_users/get_all_links"]
        
        # transition /init_server
        _init_server_0 = Transition(self, self.states["/init_server"], [self.states["/init_executor"]])
        _init_server_0.setAction(self._init_server_0_exec)
        _init_server_0.setTrigger(Event("instance_created", None))
        self.states["/init_server"].addTransition(_init_server_0)
        
        # transition /init_executor
        _init_executor_0 = Transition(self, self.states["/init_executor"], [self.states["/get_mvk"]])
        _init_executor_0.setAction(self._init_executor_0_exec)
        _init_executor_0.setTrigger(Event("instance_created", None))
        self.states["/init_executor"].addTransition(_init_executor_0)
        
        # transition /get_mvk
        _get_mvk_0 = Transition(self, self.states["/get_mvk"], [self.states["/read_root"]])
        _get_mvk_0.setAction(self._get_mvk_0_exec)
        _get_mvk_0.setTrigger(Event("get_mvk_reply", None))
        self.states["/get_mvk"].addTransition(_get_mvk_0)
        
        # transition /read_root
        _read_root_0 = Transition(self, self.states["/read_root"], [self.states["/running"]])
        _read_root_0.setAction(self._read_root_0_exec)
        _read_root_0.setTrigger(Event("raw_exec_reply", None))
        self.states["/read_root"].addTransition(_read_root_0)
        
        # transition /running/wait_for_requests/wait
        _running_wait_for_requests_wait_0 = Transition(self, self.states["/running/wait_for_requests/wait"], [self.states["/running/wait_for_requests/wait"]])
        _running_wait_for_requests_wait_0.setAction(self._running_wait_for_requests_wait_0_exec)
        _running_wait_for_requests_wait_0.setTrigger(Event("from_mvi", None))
        self.states["/running/wait_for_requests/wait"].addTransition(_running_wait_for_requests_wait_0)
        
        # transition /running/push/wait
        _running_push_wait_0 = Transition(self, self.states["/running/push/wait"], [self.states["/running/push/process"]])
        _running_push_wait_0.setTrigger(None)
        _running_push_wait_0.setGuard(self._running_push_wait_0_guard)
        self.states["/running/push/wait"].addTransition(_running_push_wait_0)
        _running_push_wait_1 = Transition(self, self.states["/running/push/wait"], [self.states["/running/push/wait"]])
        _running_push_wait_1.setAction(self._running_push_wait_1_exec)
        _running_push_wait_1.setTrigger(None)
        _running_push_wait_1.setGuard(self._running_push_wait_1_guard)
        self.states["/running/push/wait"].addTransition(_running_push_wait_1)
        
        # transition /running/push/process
        _running_push_process_0 = Transition(self, self.states["/running/push/process"], [self.states["/running/push/wait"]])
        _running_push_process_0.setAction(self._running_push_process_0_exec)
        _running_push_process_0.setTrigger(None)
        _running_push_process_0.setGuard(self._running_push_process_0_guard)
        self.states["/running/push/process"].addTransition(_running_push_process_0)
        _running_push_process_1 = Transition(self, self.states["/running/push/process"], [self.states["/running/push/wait"]])
        _running_push_process_1.setAction(self._running_push_process_1_exec)
        _running_push_process_1.setTrigger(None)
        _running_push_process_1.setGuard(self._running_push_process_1_guard)
        self.states["/running/push/process"].addTransition(_running_push_process_1)
        _running_push_process_2 = Transition(self, self.states["/running/push/process"], [self.states["/running/push/wait"]])
        _running_push_process_2.setAction(self._running_push_process_2_exec)
        _running_push_process_2.setTrigger(None)
        _running_push_process_2.setGuard(self._running_push_process_2_guard)
        self.states["/running/push/process"].addTransition(_running_push_process_2)
        _running_push_process_3 = Transition(self, self.states["/running/push/process"], [self.states["/running/push/wait"]])
        _running_push_process_3.setAction(self._running_push_process_3_exec)
        _running_push_process_3.setTrigger(None)
        _running_push_process_3.setGuard(self._running_push_process_3_guard)
        self.states["/running/push/process"].addTransition(_running_push_process_3)
        
        # transition /running/find_users/get_all_links
        _running_find_users_get_all_links_0 = Transition(self, self.states["/running/find_users/get_all_links"], [self.states["/running/find_users/retrieve_users"]])
        _running_find_users_get_all_links_0.setAction(self._running_find_users_get_all_links_0_exec)
        _running_find_users_get_all_links_0.setTrigger(Event("raw_exec_reply", None))
        self.states["/running/find_users/get_all_links"].addTransition(_running_find_users_get_all_links_0)
        
        # transition /running/find_users/retrieve_users
        _running_find_users_retrieve_users_0 = Transition(self, self.states["/running/find_users/retrieve_users"], [self.states["/running/find_users/got_usernames"]])
        _running_find_users_retrieve_users_0.setAction(self._running_find_users_retrieve_users_0_exec)
        _running_find_users_retrieve_users_0.setTrigger(None)
        _running_find_users_retrieve_users_0.setGuard(self._running_find_users_retrieve_users_0_guard)
        self.states["/running/find_users/retrieve_users"].addTransition(_running_find_users_retrieve_users_0)
        _running_find_users_retrieve_users_1 = Transition(self, self.states["/running/find_users/retrieve_users"], [self.states["/running/find_users/wait"]])
        _running_find_users_retrieve_users_1.setTrigger(None)
        _running_find_users_retrieve_users_1.setGuard(self._running_find_users_retrieve_users_1_guard)
        self.states["/running/find_users/retrieve_users"].addTransition(_running_find_users_retrieve_users_1)
        
        # transition /running/find_users/got_usernames
        _running_find_users_got_usernames_0 = Transition(self, self.states["/running/find_users/got_usernames"], [self.states["/running/find_users/process_users"]])
        _running_find_users_got_usernames_0.setAction(self._running_find_users_got_usernames_0_exec)
        _running_find_users_got_usernames_0.setTrigger(Event("raw_exec_reply", None))
        self.states["/running/find_users/got_usernames"].addTransition(_running_find_users_got_usernames_0)
        
        # transition /running/find_users/process_users
        _running_find_users_process_users_0 = Transition(self, self.states["/running/find_users/process_users"], [self.states["/running/find_users/wait"]])
        _running_find_users_process_users_0.setTrigger(None)
        _running_find_users_process_users_0.setGuard(self._running_find_users_process_users_0_guard)
        self.states["/running/find_users/process_users"].addTransition(_running_find_users_process_users_0)
        _running_find_users_process_users_1 = Transition(self, self.states["/running/find_users/process_users"], [self.states["/running/find_users/creating_user"]])
        _running_find_users_process_users_1.setAction(self._running_find_users_process_users_1_exec)
        _running_find_users_process_users_1.setTrigger(None)
        _running_find_users_process_users_1.setGuard(self._running_find_users_process_users_1_guard)
        self.states["/running/find_users/process_users"].addTransition(_running_find_users_process_users_1)
        _running_find_users_process_users_2 = Transition(self, self.states["/running/find_users/process_users"], [self.states["/running/find_users/process_users"]])
        _running_find_users_process_users_2.setAction(self._running_find_users_process_users_2_exec)
        _running_find_users_process_users_2.setTrigger(None)
        _running_find_users_process_users_2.setGuard(self._running_find_users_process_users_2_guard)
        self.states["/running/find_users/process_users"].addTransition(_running_find_users_process_users_2)
        
        # transition /running/find_users/creating_user
        _running_find_users_creating_user_0 = Transition(self, self.states["/running/find_users/creating_user"], [self.states["/running/find_users/retrieve_users"]])
        _running_find_users_creating_user_0.setAction(self._running_find_users_creating_user_0_exec)
        _running_find_users_creating_user_0.setTrigger(Event("instance_created", None))
        self.states["/running/find_users/creating_user"].addTransition(_running_find_users_creating_user_0)
        
        # transition /running/find_users/wait
        _running_find_users_wait_0 = Transition(self, self.states["/running/find_users/wait"], [self.states["/running/find_users/get_all_links"]])
        _running_find_users_wait_0.setTrigger(Event("_0after"))
        self.states["/running/find_users/wait"].addTransition(_running_find_users_wait_0)
        _running_find_users_wait_1 = Transition(self, self.states["/running/find_users/wait"], [self.states["/running/find_users/get_all_links"]])
        _running_find_users_wait_1.setTrigger(Event("force_user_refresh", None))
        self.states["/running/find_users/wait"].addTransition(_running_find_users_wait_1)
    
    def _init_server_enter(self):
        self.big_step.outputEventOM(Event("create_instance", None, [self, 'to_mvi', 'Server', '', 8001]))
    
    def _init_executor_enter(self):
        self.big_step.outputEventOM(Event("create_instance", None, [self, 'executor', 'Executor']))
    
    def _get_mvk_enter(self):
        self.big_step.outputEventOM(Event("narrow_cast", None, [self, 'executor', Event("get_mvk", None, ['parent'])]))
    
    def _read_root_enter(self):
        self.big_step.outputEventOM(Event("narrow_cast", None, [self, 'executor', Event("raw_exec", None, [[['RR', []]], 'parent'])]))
    
    def _running_find_users_get_all_links_enter(self):
        self.big_step.outputEventOM(Event("narrow_cast", None, [self, 'executor', Event("raw_exec", None, [[['RDK', [self.root]]], 'parent'])]))
    
    def _running_find_users_wait_enter(self):
        self.addTimer(0, 1.0)
    
    def _running_find_users_wait_exit(self):
        self.removeTimer(0)
    
    def _init_server_0_exec(self, parameters):
        instancename = parameters[0]
        self.big_step.outputEventOM(Event("start_instance", None, [self, instancename]))
    
    def _init_executor_0_exec(self, parameters):
        instancename = parameters[0]
        self.big_step.outputEventOM(Event("start_instance", None, [self, instancename]))
    
    def _get_mvk_0_exec(self, parameters):
        mvk = parameters[0]
        self.mvk = mvk
    
    def _read_root_0_exec(self, parameters):
        data = parameters[0]
        self.root = data[0][0]
    
    def _running_wait_for_requests_wait_0_exec(self, parameters):
        source = parameters[0]
        data = parameters[1]
        # No JSON encoding necessary, as it is not complex
        try:
            args = None
            if data["op"] == "set_input":
                if "value" in data:
                    value = [json.loads(data["value"])]
                else:
                    value = json.loads(data["data"])
                for v in value[:-1]:
                    self.input_queue.append((None, data["op"], [v], data["username"]))
                self.input_queue.append((source, data["op"], [value[-1]], data["username"]))
            else:
                self.input_queue.append((source, data["op"], args, data["username"]))
        except ValueError:
            print("Error when deserializing request: " + str(data))
            raise
    
    def _running_push_wait_0_guard(self, parameters):
        return self.input_queue and self.input_queue[0][3] in self.user_statecharts
    
    def _running_push_wait_1_exec(self, parameters):
        self.user_queue.setdefault(self.input_queue[0][3], []).append(self.input_queue.pop(0))
        self.raiseInternalEvent(Event("force_user_refresh", None, []))
    
    def _running_push_wait_1_guard(self, parameters):
        return self.input_queue and self.input_queue[0][3] not in self.user_statecharts
    
    def _running_push_process_0_exec(self, parameters):
        source, op, args, username = self.input_queue.pop(0)
        self.big_step.outputEventOM(Event("narrow_cast", None, [self, self.user_statecharts[username], Event("set_input", None, [source, args])]))
    
    def _running_push_process_0_guard(self, parameters):
        return self.input_queue[0][1] == 'set_input'
    
    def _running_push_process_1_exec(self, parameters):
        source, op, args, username = self.input_queue.pop(0)
        self.big_step.outputEventOM(Event("narrow_cast", None, [self, self.user_statecharts[username], Event("get_output", None, [source, args])]))
    
    def _running_push_process_1_guard(self, parameters):
        return self.input_queue[0][1] == 'get_output'
    
    def _running_push_process_2_exec(self, parameters):
        source, op, args, username = self.input_queue.pop(0)
        self.big_step.outputEventOM(Event("narrow_cast", None, [self, self.user_statecharts[username], Event("pause", None, [source, args])]))
    
    def _running_push_process_2_guard(self, parameters):
        return self.input_queue[0][1] == 'pause'
    
    def _running_push_process_3_exec(self, parameters):
        source, op, args, username = self.input_queue.pop(0)
        self.big_step.outputEventOM(Event("narrow_cast", None, [self, self.user_statecharts[username], Event("resume", None, [source, args])]))
    
    def _running_push_process_3_guard(self, parameters):
        return self.input_queue[0][1] == 'resume'
    
    def _running_find_users_get_all_links_0_exec(self, parameters):
        data = parameters[0]
        self.users = data[0][0]
    
    def _running_find_users_retrieve_users_0_exec(self, parameters):
        self.big_step.outputEventOM(Event("narrow_cast", None, [self, 'executor', Event("raw_exec", None, [[['RV', [user]] for user in self.users], 'parent'])]))
    
    def _running_find_users_retrieve_users_0_guard(self, parameters):
        return self.users
    
    def _running_find_users_retrieve_users_1_guard(self, parameters):
        return not self.users
    
    def _running_find_users_got_usernames_0_exec(self, parameters):
        data = parameters[0]
        data = set([v[0] for v in data])
        self.add_users = [v for v in data if v not in self.user_statecharts]
        self.delete_users = [v for v in self.user_statecharts if v not in data]
    
    def _running_find_users_process_users_0_guard(self, parameters):
        return not self.add_users and not self.delete_users
    
    def _running_find_users_process_users_1_exec(self, parameters):
        self.big_step.outputEventOM(Event("create_instance", None, [self, 'users', 'UserStatechart', self.add_users[0], self.mvk]))
    
    def _running_find_users_process_users_1_guard(self, parameters):
        return self.add_users and not self.delete_users
    
    def _running_find_users_process_users_2_exec(self, parameters):
        self.big_step.outputEventOM(Event("delete_instance", None, [self, self.user_statecharts.pop(self.delete_users.pop(0))]))
    
    def _running_find_users_process_users_2_guard(self, parameters):
        return self.delete_users
    
    def _running_find_users_creating_user_0_exec(self, parameters):
        instancename = parameters[0]
        self.big_step.outputEventOM(Event("start_instance", None, [self, instancename]))
        self.big_step.outputEventOM(Event("narrow_cast", None, [self, instancename, Event("set_returnpath", None, [instancename])]))
        self.user_statecharts[self.add_users[0]] = instancename
        # Repush all this user's messages in the input queue
        self.input_queue.extend(self.user_queue.pop(self.add_users[0], []))
        self.add_users.pop(0)
    
    def initializeStatechart(self):
        # enter default state
        self.default_targets = self.states["/init_server"].getEffectiveTargetStates()
        RuntimeClassBase.initializeStatechart(self)

class Server(RuntimeClassBase):
    def __init__(self, controller, address, port):
        RuntimeClassBase.__init__(self, controller)
        
        self.semantics.big_step_maximality = StatechartSemantics.TakeMany
        self.semantics.internal_event_lifeline = StatechartSemantics.Queue
        self.semantics.input_event_lifeline = StatechartSemantics.FirstComboStep
        self.semantics.priority = StatechartSemantics.SourceParent
        self.semantics.concurrency = StatechartSemantics.Single
        
        # build Statechart structure
        self.build_statechart_structure()
        
        # call user defined constructor
        Server.user_defined_constructor(self, address, port)
    
    def user_defined_constructor(self, address, port):
        self.socket = None
        self.address = address
        self.port = port
    
    def user_defined_destructor(self):
        pass
    
    
    # builds Statechart structure
    def build_statechart_structure(self):
        
        # state <root>
        self.states[""] = State(0, self)
        
        # state /main
        self.states["/main"] = ParallelState(1, self)
        
        # state /main/forward
        self.states["/main/forward"] = State(2, self)
        
        # state /main/forward/forward
        self.states["/main/forward/forward"] = State(3, self)
        
        # state /main/server
        self.states["/main/server"] = State(4, self)
        
        # state /main/server/init
        self.states["/main/server/init"] = State(5, self)
        self.states["/main/server/init"].setEnter(self._main_server_init_enter)
        
        # state /main/server/binding
        self.states["/main/server/binding"] = State(6, self)
        self.states["/main/server/binding"].setEnter(self._main_server_binding_enter)
        
        # state /main/server/listening
        self.states["/main/server/listening"] = State(7, self)
        self.states["/main/server/listening"].setEnter(self._main_server_listening_enter)
        
        # state /main/server/accepting
        self.states["/main/server/accepting"] = State(8, self)
        self.states["/main/server/accepting"].setEnter(self._main_server_accepting_enter)
        self.states["/main/server/accepting"].setExit(self._main_server_accepting_exit)
        
        # state /main/close_socket
        self.states["/main/close_socket"] = State(9, self)
        
        # state /main/close_socket/close
        self.states["/main/close_socket/close"] = State(10, self)
        
        # add children
        self.states[""].addChild(self.states["/main"])
        self.states["/main"].addChild(self.states["/main/forward"])
        self.states["/main"].addChild(self.states["/main/server"])
        self.states["/main"].addChild(self.states["/main/close_socket"])
        self.states["/main/forward"].addChild(self.states["/main/forward/forward"])
        self.states["/main/server"].addChild(self.states["/main/server/init"])
        self.states["/main/server"].addChild(self.states["/main/server/binding"])
        self.states["/main/server"].addChild(self.states["/main/server/listening"])
        self.states["/main/server"].addChild(self.states["/main/server/accepting"])
        self.states["/main/close_socket"].addChild(self.states["/main/close_socket/close"])
        self.states[""].fixTree()
        self.states[""].default_state = self.states["/main"]
        self.states["/main/forward"].default_state = self.states["/main/forward/forward"]
        self.states["/main/server"].default_state = self.states["/main/server/init"]
        self.states["/main/close_socket"].default_state = self.states["/main/close_socket/close"]
        
        # transition /main/forward/forward
        _main_forward_forward_0 = Transition(self, self.states["/main/forward/forward"], [self.states["/main/forward/forward"]])
        _main_forward_forward_0.setAction(self._main_forward_forward_0_exec)
        _main_forward_forward_0.setTrigger(Event("HTTP_output", None))
        self.states["/main/forward/forward"].addTransition(_main_forward_forward_0)
        
        # transition /main/server/init
        _main_server_init_0 = Transition(self, self.states["/main/server/init"], [self.states["/main/server/binding"]])
        _main_server_init_0.setAction(self._main_server_init_0_exec)
        _main_server_init_0.setTrigger(Event("created_socket", "socket_in"))
        self.states["/main/server/init"].addTransition(_main_server_init_0)
        
        # transition /main/server/binding
        _main_server_binding_0 = Transition(self, self.states["/main/server/binding"], [self.states["/main/server/listening"]])
        _main_server_binding_0.setTrigger(Event("bound_socket", "socket_in"))
        _main_server_binding_0.setGuard(self._main_server_binding_0_guard)
        self.states["/main/server/binding"].addTransition(_main_server_binding_0)
        
        # transition /main/server/listening
        _main_server_listening_0 = Transition(self, self.states["/main/server/listening"], [self.states["/main/server/accepting"]])
        _main_server_listening_0.setAction(self._main_server_listening_0_exec)
        _main_server_listening_0.setTrigger(Event("listened_socket", "socket_in"))
        _main_server_listening_0.setGuard(self._main_server_listening_0_guard)
        self.states["/main/server/listening"].addTransition(_main_server_listening_0)
        
        # transition /main/server/accepting
        _main_server_accepting_0 = Transition(self, self.states["/main/server/accepting"], [self.states["/main/server/accepting"]])
        _main_server_accepting_0.setAction(self._main_server_accepting_0_exec)
        _main_server_accepting_0.setTrigger(Event("accepted_socket", "socket_in"))
        self.states["/main/server/accepting"].addTransition(_main_server_accepting_0)
        _main_server_accepting_1 = Transition(self, self.states["/main/server/accepting"], [self.states["/main/server/accepting"]])
        _main_server_accepting_1.setAction(self._main_server_accepting_1_exec)
        _main_server_accepting_1.setTrigger(Event("instance_created", None))
        self.states["/main/server/accepting"].addTransition(_main_server_accepting_1)
        _main_server_accepting_2 = Transition(self, self.states["/main/server/accepting"], [self.states["/main/server/accepting"]])
        _main_server_accepting_2.setTrigger(Event("_0after"))
        self.states["/main/server/accepting"].addTransition(_main_server_accepting_2)
        
        # transition /main/close_socket/close
        _main_close_socket_close_0 = Transition(self, self.states["/main/close_socket/close"], [self.states["/main/close_socket/close"]])
        _main_close_socket_close_0.setAction(self._main_close_socket_close_0_exec)
        _main_close_socket_close_0.setTrigger(Event("close_socket", None))
        self.states["/main/close_socket/close"].addTransition(_main_close_socket_close_0)
    
    def _main_server_init_enter(self):
        self.big_step.outputEvent(Event("create_socket", "socket_out", []))
    
    def _main_server_binding_enter(self):
        self.big_step.outputEvent(Event("bind_socket", "socket_out", [self.socket, (self.address, self.port)]))
    
    def _main_server_listening_enter(self):
        self.big_step.outputEvent(Event("listen_socket", "socket_out", [self.socket]))
    
    def _main_server_accepting_enter(self):
        self.addTimer(0, 1.0)
    
    def _main_server_accepting_exit(self):
        self.removeTimer(0)
    
    def _main_forward_forward_0_exec(self, parameters):
        association_name = parameters[0]
        data = parameters[1]
        self.big_step.outputEventOM(Event("narrow_cast", None, [self, 'parent', Event("from_mvi", None, [association_name, data])]))
    
    def _main_server_init_0_exec(self, parameters):
        socket = parameters[0]
        self.socket = socket
    
    def _main_server_binding_0_guard(self, parameters):
        socket = parameters[0]
        return self.socket == socket
    
    def _main_server_listening_0_exec(self, parameters):
        socket = parameters[0]
        self.big_step.outputEvent(Event("accept_socket", "socket_out", [self.socket]))
    
    def _main_server_listening_0_guard(self, parameters):
        socket = parameters[0]
        return self.socket == socket
    
    def _main_server_accepting_0_exec(self, parameters):
        socket = parameters[0]
        connected_socket = parameters[1]
        self.big_step.outputEventOM(Event("create_instance", None, [self, 'sockets', 'Socket', connected_socket]))
        self.big_step.outputEvent(Event("accept_socket", "socket_out", [self.socket]))
    
    def _main_server_accepting_1_exec(self, parameters):
        instancename = parameters[0]
        self.big_step.outputEventOM(Event("start_instance", None, [self, instancename]))
        self.big_step.outputEventOM(Event("narrow_cast", None, [self, instancename, Event("set_association_name", None, [instancename])]))
    
    def _main_close_socket_close_0_exec(self, parameters):
        association_name = parameters[0]
        self.big_step.outputEventOM(Event("delete_instance", None, [self, association_name]))
    
    def initializeStatechart(self):
        # enter default state
        self.default_targets = self.states["/main"].getEffectiveTargetStates()
        RuntimeClassBase.initializeStatechart(self)

class Socket(RuntimeClassBase):
    def __init__(self, controller, my_socket):
        RuntimeClassBase.__init__(self, controller)
        
        self.semantics.big_step_maximality = StatechartSemantics.TakeMany
        self.semantics.internal_event_lifeline = StatechartSemantics.Queue
        self.semantics.input_event_lifeline = StatechartSemantics.FirstComboStep
        self.semantics.priority = StatechartSemantics.SourceParent
        self.semantics.concurrency = StatechartSemantics.Single
        
        # build Statechart structure
        self.build_statechart_structure()
        
        # call user defined constructor
        Socket.user_defined_constructor(self, my_socket)
    
    def user_defined_constructor(self, my_socket):
        self.socket = my_socket
        self.received_data = ""
        self.send_data = ""
        self.closed = False
        self.association_name = None
    
    def user_defined_destructor(self):
        pass
    
    
    # builds Statechart structure
    def build_statechart_structure(self):
        
        # state <root>
        self.states[""] = State(0, self)
        
        # state /init
        self.states["/init"] = State(1, self)
        
        # state /connected
        self.states["/connected"] = ParallelState(2, self)
        
        # state /connected/listening
        self.states["/connected/listening"] = State(3, self)
        
        # state /connected/listening/listen
        self.states["/connected/listening/listen"] = State(4, self)
        self.states["/connected/listening/listen"].setEnter(self._connected_listening_listen_enter)
        
        # state /connected/listening/closed
        self.states["/connected/listening/closed"] = State(5, self)
        self.states["/connected/listening/closed"].setEnter(self._connected_listening_closed_enter)
        
        # state /connected/sending
        self.states["/connected/sending"] = State(6, self)
        
        # state /connected/sending/waiting_for_data
        self.states["/connected/sending/waiting_for_data"] = State(7, self)
        
        # state /connected/sending/transferring
        self.states["/connected/sending/transferring"] = State(8, self)
        
        # state /connected/queueing
        self.states["/connected/queueing"] = State(9, self)
        
        # state /connected/queueing/queueing
        self.states["/connected/queueing/queueing"] = State(10, self)
        
        # state /connected/parsing
        self.states["/connected/parsing"] = State(11, self)
        
        # state /connected/parsing/wait_for_header
        self.states["/connected/parsing/wait_for_header"] = State(12, self)
        
        # state /connected/parsing/closing
        self.states["/connected/parsing/closing"] = State(13, self)
        self.states["/connected/parsing/closing"].setEnter(self._connected_parsing_closing_enter)
        self.states["/connected/parsing/closing"].setExit(self._connected_parsing_closing_exit)
        
        # state /connected/parsing/wait_for_payload
        self.states["/connected/parsing/wait_for_payload"] = State(14, self)
        
        # state /close
        self.states["/close"] = State(15, self)
        self.states["/close"].setEnter(self._close_enter)
        
        # add children
        self.states[""].addChild(self.states["/init"])
        self.states[""].addChild(self.states["/connected"])
        self.states[""].addChild(self.states["/close"])
        self.states["/connected"].addChild(self.states["/connected/listening"])
        self.states["/connected"].addChild(self.states["/connected/sending"])
        self.states["/connected"].addChild(self.states["/connected/queueing"])
        self.states["/connected"].addChild(self.states["/connected/parsing"])
        self.states["/connected/listening"].addChild(self.states["/connected/listening/listen"])
        self.states["/connected/listening"].addChild(self.states["/connected/listening/closed"])
        self.states["/connected/sending"].addChild(self.states["/connected/sending/waiting_for_data"])
        self.states["/connected/sending"].addChild(self.states["/connected/sending/transferring"])
        self.states["/connected/queueing"].addChild(self.states["/connected/queueing/queueing"])
        self.states["/connected/parsing"].addChild(self.states["/connected/parsing/wait_for_header"])
        self.states["/connected/parsing"].addChild(self.states["/connected/parsing/closing"])
        self.states["/connected/parsing"].addChild(self.states["/connected/parsing/wait_for_payload"])
        self.states[""].fixTree()
        self.states[""].default_state = self.states["/init"]
        self.states["/connected/listening"].default_state = self.states["/connected/listening/listen"]
        self.states["/connected/sending"].default_state = self.states["/connected/sending/waiting_for_data"]
        self.states["/connected/queueing"].default_state = self.states["/connected/queueing/queueing"]
        self.states["/connected/parsing"].default_state = self.states["/connected/parsing/wait_for_header"]
        
        # transition /init
        _init_0 = Transition(self, self.states["/init"], [self.states["/connected"]])
        _init_0.setAction(self._init_0_exec)
        _init_0.setTrigger(Event("set_association_name", None))
        self.states["/init"].addTransition(_init_0)
        
        # transition /connected/listening/listen
        _connected_listening_listen_0 = Transition(self, self.states["/connected/listening/listen"], [self.states["/connected/listening/listen"]])
        _connected_listening_listen_0.setAction(self._connected_listening_listen_0_exec)
        _connected_listening_listen_0.setTrigger(Event("received_socket", "socket_in"))
        _connected_listening_listen_0.setGuard(self._connected_listening_listen_0_guard)
        self.states["/connected/listening/listen"].addTransition(_connected_listening_listen_0)
        _connected_listening_listen_1 = Transition(self, self.states["/connected/listening/listen"], [self.states["/connected/listening/closed"]])
        _connected_listening_listen_1.setAction(self._connected_listening_listen_1_exec)
        _connected_listening_listen_1.setTrigger(Event("received_socket", "socket_in"))
        _connected_listening_listen_1.setGuard(self._connected_listening_listen_1_guard)
        self.states["/connected/listening/listen"].addTransition(_connected_listening_listen_1)
        
        # transition /connected/sending/waiting_for_data
        _connected_sending_waiting_for_data_0 = Transition(self, self.states["/connected/sending/waiting_for_data"], [self.states["/connected/sending/transferring"]])
        _connected_sending_waiting_for_data_0.setAction(self._connected_sending_waiting_for_data_0_exec)
        _connected_sending_waiting_for_data_0.setTrigger(None)
        _connected_sending_waiting_for_data_0.setGuard(self._connected_sending_waiting_for_data_0_guard)
        self.states["/connected/sending/waiting_for_data"].addTransition(_connected_sending_waiting_for_data_0)
        
        # transition /connected/sending/transferring
        _connected_sending_transferring_0 = Transition(self, self.states["/connected/sending/transferring"], [self.states["/connected/sending/waiting_for_data"]])
        _connected_sending_transferring_0.setAction(self._connected_sending_transferring_0_exec)
        _connected_sending_transferring_0.setTrigger(Event("sent_socket", "socket_in"))
        _connected_sending_transferring_0.setGuard(self._connected_sending_transferring_0_guard)
        self.states["/connected/sending/transferring"].addTransition(_connected_sending_transferring_0)
        
        # transition /connected/queueing/queueing
        _connected_queueing_queueing_0 = Transition(self, self.states["/connected/queueing/queueing"], [self.states["/connected/queueing/queueing"]])
        _connected_queueing_queueing_0.setAction(self._connected_queueing_queueing_0_exec)
        _connected_queueing_queueing_0.setTrigger(Event("HTTP_input", None))
        self.states["/connected/queueing/queueing"].addTransition(_connected_queueing_queueing_0)
        
        # transition /connected/parsing/wait_for_header
        _connected_parsing_wait_for_header_0 = Transition(self, self.states["/connected/parsing/wait_for_header"], [self.states["/connected/parsing/wait_for_payload"]])
        _connected_parsing_wait_for_header_0.setAction(self._connected_parsing_wait_for_header_0_exec)
        _connected_parsing_wait_for_header_0.setTrigger(None)
        _connected_parsing_wait_for_header_0.setGuard(self._connected_parsing_wait_for_header_0_guard)
        self.states["/connected/parsing/wait_for_header"].addTransition(_connected_parsing_wait_for_header_0)
        _connected_parsing_wait_for_header_1 = Transition(self, self.states["/connected/parsing/wait_for_header"], [self.states["/connected/parsing/closing"]])
        _connected_parsing_wait_for_header_1.setTrigger(None)
        _connected_parsing_wait_for_header_1.setGuard(self._connected_parsing_wait_for_header_1_guard)
        self.states["/connected/parsing/wait_for_header"].addTransition(_connected_parsing_wait_for_header_1)
        
        # transition /connected/parsing/closing
        _connected_parsing_closing_0 = Transition(self, self.states["/connected/parsing/closing"], [self.states["/connected/parsing/closing"]])
        _connected_parsing_closing_0.setAction(self._connected_parsing_closing_0_exec)
        _connected_parsing_closing_0.setTrigger(Event("_0after"))
        self.states["/connected/parsing/closing"].addTransition(_connected_parsing_closing_0)
        
        # transition /connected/parsing/wait_for_payload
        _connected_parsing_wait_for_payload_0 = Transition(self, self.states["/connected/parsing/wait_for_payload"], [self.states["/connected/parsing/wait_for_header"]])
        _connected_parsing_wait_for_payload_0.setAction(self._connected_parsing_wait_for_payload_0_exec)
        _connected_parsing_wait_for_payload_0.setTrigger(None)
        _connected_parsing_wait_for_payload_0.setGuard(self._connected_parsing_wait_for_payload_0_guard)
        self.states["/connected/parsing/wait_for_payload"].addTransition(_connected_parsing_wait_for_payload_0)
        
        # transition /connected
        _connected_0 = Transition(self, self.states["/connected"], [self.states["/close"]])
        _connected_0.setTrigger(Event("close", None))
        self.states["/connected"].addTransition(_connected_0)
    
    def _connected_listening_listen_enter(self):
        self.big_step.outputEvent(Event("recv_socket", "socket_out", [self.socket]))
    
    def _connected_listening_closed_enter(self):
        self.closed = True
    
    def _connected_parsing_closing_enter(self):
        self.addTimer(0, 0.0)
    
    def _connected_parsing_closing_exit(self):
        self.removeTimer(0)
    
    def _close_enter(self):
        self.big_step.outputEvent(Event("close_socket", "socket_out", [self.socket]))
        self.big_step.outputEventOM(Event("narrow_cast", None, [self, 'parent', Event("close_socket", None, [self.association_name])]))
    
    def _init_0_exec(self, parameters):
        association_name = parameters[0]
        self.association_name = association_name
    
    def _connected_listening_listen_0_exec(self, parameters):
        socket = parameters[0]
        data = parameters[1]
        self.received_data += data
        self.raiseInternalEvent(Event("received_data", None, []))
    
    def _connected_listening_listen_0_guard(self, parameters):
        socket = parameters[0]
        data = parameters[1]
        return (self.socket == socket) and (len(data) > 0)
    
    def _connected_listening_listen_1_exec(self, parameters):
        socket = parameters[0]
        data = parameters[1]
        self.raiseInternalEvent(Event("received_data", None, []))
    
    def _connected_listening_listen_1_guard(self, parameters):
        socket = parameters[0]
        data = parameters[1]
        return (self.socket == socket) and (len(data) == 0)
    
    def _connected_sending_waiting_for_data_0_exec(self, parameters):
        self.big_step.outputEvent(Event("send_socket", "socket_out", [self.socket, self.send_data]))
    
    def _connected_sending_waiting_for_data_0_guard(self, parameters):
        return len(self.send_data) > 0
    
    def _connected_sending_transferring_0_exec(self, parameters):
        socket = parameters[0]
        sent_bytes = parameters[1]
        self.send_data = self.send_data[sent_bytes:]
    
    def _connected_sending_transferring_0_guard(self, parameters):
        socket = parameters[0]
        sent_bytes = parameters[1]
        return self.socket == socket
    
    def _connected_queueing_queueing_0_exec(self, parameters):
        data = parameters[0]
        #post_data = "&".join(["%s=%s" % (urllib.quote(k), urllib.quote(v)) for k, v in data.iteritems()])
        #post_data = "&".join(["%s=%s" % (k, v) for k, v in data.iteritems()])
        post_data = data
        self.send_data += "HTTP/1.0 200 OK\r\n"
        self.send_data += "Content-Length: %s\r\n" % len(post_data)
        self.send_data += "Content-Type: %s; charset=UTF-8\r\n" % "text/plain"
        self.send_data += "\r\n"
        self.send_data += str(post_data)
    
    def _connected_parsing_wait_for_header_0_exec(self, parameters):
        header, self.received_data = self.received_data.split("\r\n\r\n", 1)
        header = header.lower()
        if "content-length" in header:
            _, after = header.split("content-length:", 1)
            after = after.split("\r\n", 1)[0]
            after = after.strip()
            self.length = int(after)
        else:
            self.length = float('inf')
    
    def _connected_parsing_wait_for_header_0_guard(self, parameters):
        return '\r\n\r\n' in self.received_data and self.received_data.startswith('POST')
    
    def _connected_parsing_wait_for_header_1_guard(self, parameters):
        return self.closed and len(self.received_data) == 0
    
    def _connected_parsing_closing_0_exec(self, parameters):
        self.raiseInternalEvent(Event("close", None, []))
    
    def _connected_parsing_wait_for_payload_0_exec(self, parameters):
        if self.length == float('inf'):
            data = self.received_data
            self.received_data = ""
        else:
            data = self.received_data[:self.length]
            self.received_data = self.received_data[self.length:]
        
        # We support POST data only, so everything is in the data
        try:
            params = dict([p.split('=') for p in data.split('&')])
            data = {k: urllib.unquote_plus(v) for k, v in params.iteritems()}
        except:
            data = {}
        self.big_step.outputEventOM(Event("narrow_cast", None, [self, 'parent', Event("HTTP_output", None, [self.association_name, data])]))
    
    def _connected_parsing_wait_for_payload_0_guard(self, parameters):
        return len(self.received_data) >= self.length or self.closed
    
    def initializeStatechart(self):
        # enter default state
        self.default_targets = self.states["/init"].getEffectiveTargetStates()
        RuntimeClassBase.initializeStatechart(self)

class HTTPClient(RuntimeClassBase):
    def __init__(self, controller, hostname, port):
        RuntimeClassBase.__init__(self, controller)
        
        self.semantics.big_step_maximality = StatechartSemantics.TakeMany
        self.semantics.internal_event_lifeline = StatechartSemantics.Queue
        self.semantics.input_event_lifeline = StatechartSemantics.FirstComboStep
        self.semantics.priority = StatechartSemantics.SourceParent
        self.semantics.concurrency = StatechartSemantics.Single
        
        # build Statechart structure
        self.build_statechart_structure()
        
        # call user defined constructor
        HTTPClient.user_defined_constructor(self, hostname, port)
    
    def user_defined_constructor(self, hostname, port):
        self.socket = None
        self.destination = (hostname, port)
        self.received_data = ""
        self.send_data = ""
        self.queue = []
        self.destinations = []
    
    def user_defined_destructor(self):
        pass
    
    
    # builds Statechart structure
    def build_statechart_structure(self):
        
        # state <root>
        self.states[""] = State(0, self)
        
        # state /init
        self.states["/init"] = State(1, self)
        self.states["/init"].setEnter(self._init_enter)
        
        # state /connecting
        self.states["/connecting"] = State(2, self)
        self.states["/connecting"].setEnter(self._connecting_enter)
        
        # state /connected
        self.states["/connected"] = ParallelState(3, self)
        
        # state /connected/listening
        self.states["/connected/listening"] = State(4, self)
        
        # state /connected/listening/listen
        self.states["/connected/listening/listen"] = State(5, self)
        self.states["/connected/listening/listen"].setEnter(self._connected_listening_listen_enter)
        
        # state /connected/listening/close
        self.states["/connected/listening/close"] = State(6, self)
        
        # state /connected/sending
        self.states["/connected/sending"] = State(7, self)
        
        # state /connected/sending/waiting_for_data
        self.states["/connected/sending/waiting_for_data"] = State(8, self)
        
        # state /connected/sending/transferring
        self.states["/connected/sending/transferring"] = State(9, self)
        
        # state /connected/queueing
        self.states["/connected/queueing"] = State(10, self)
        
        # state /connected/queueing/queueing
        self.states["/connected/queueing/queueing"] = State(11, self)
        self.states["/connected/queueing/queueing"].setEnter(self._connected_queueing_queueing_enter)
        
        # state /connected/parsing
        self.states["/connected/parsing"] = State(12, self)
        
        # state /connected/parsing/wait_for_header
        self.states["/connected/parsing/wait_for_header"] = State(13, self)
        
        # state /connected/parsing/wait_for_payload
        self.states["/connected/parsing/wait_for_payload"] = State(14, self)
        
        # add children
        self.states[""].addChild(self.states["/init"])
        self.states[""].addChild(self.states["/connecting"])
        self.states[""].addChild(self.states["/connected"])
        self.states["/connected"].addChild(self.states["/connected/listening"])
        self.states["/connected"].addChild(self.states["/connected/sending"])
        self.states["/connected"].addChild(self.states["/connected/queueing"])
        self.states["/connected"].addChild(self.states["/connected/parsing"])
        self.states["/connected/listening"].addChild(self.states["/connected/listening/listen"])
        self.states["/connected/listening"].addChild(self.states["/connected/listening/close"])
        self.states["/connected/sending"].addChild(self.states["/connected/sending/waiting_for_data"])
        self.states["/connected/sending"].addChild(self.states["/connected/sending/transferring"])
        self.states["/connected/queueing"].addChild(self.states["/connected/queueing/queueing"])
        self.states["/connected/parsing"].addChild(self.states["/connected/parsing/wait_for_header"])
        self.states["/connected/parsing"].addChild(self.states["/connected/parsing/wait_for_payload"])
        self.states[""].fixTree()
        self.states[""].default_state = self.states["/init"]
        self.states["/connected/listening"].default_state = self.states["/connected/listening/listen"]
        self.states["/connected/sending"].default_state = self.states["/connected/sending/waiting_for_data"]
        self.states["/connected/queueing"].default_state = self.states["/connected/queueing/queueing"]
        self.states["/connected/parsing"].default_state = self.states["/connected/parsing/wait_for_header"]
        
        # transition /init
        _init_0 = Transition(self, self.states["/init"], [self.states["/connecting"]])
        _init_0.setAction(self._init_0_exec)
        _init_0.setTrigger(Event("created_socket", "socket_in"))
        self.states["/init"].addTransition(_init_0)
        
        # transition /connecting
        _connecting_0 = Transition(self, self.states["/connecting"], [self.states["/connected"]])
        _connecting_0.setAction(self._connecting_0_exec)
        _connecting_0.setTrigger(Event("connected_socket", "socket_in"))
        _connecting_0.setGuard(self._connecting_0_guard)
        self.states["/connecting"].addTransition(_connecting_0)
        
        # transition /connected/listening/listen
        _connected_listening_listen_0 = Transition(self, self.states["/connected/listening/listen"], [self.states["/connected/listening/listen"]])
        _connected_listening_listen_0.setAction(self._connected_listening_listen_0_exec)
        _connected_listening_listen_0.setTrigger(Event("received_socket", "socket_in"))
        _connected_listening_listen_0.setGuard(self._connected_listening_listen_0_guard)
        self.states["/connected/listening/listen"].addTransition(_connected_listening_listen_0)
        _connected_listening_listen_1 = Transition(self, self.states["/connected/listening/listen"], [self.states["/connected/listening/close"]])
        _connected_listening_listen_1.setTrigger(Event("received_socket", "socket_in"))
        _connected_listening_listen_1.setGuard(self._connected_listening_listen_1_guard)
        self.states["/connected/listening/listen"].addTransition(_connected_listening_listen_1)
        
        # transition /connected/sending/waiting_for_data
        _connected_sending_waiting_for_data_0 = Transition(self, self.states["/connected/sending/waiting_for_data"], [self.states["/connected/sending/transferring"]])
        _connected_sending_waiting_for_data_0.setAction(self._connected_sending_waiting_for_data_0_exec)
        _connected_sending_waiting_for_data_0.setTrigger(None)
        _connected_sending_waiting_for_data_0.setGuard(self._connected_sending_waiting_for_data_0_guard)
        self.states["/connected/sending/waiting_for_data"].addTransition(_connected_sending_waiting_for_data_0)
        
        # transition /connected/sending/transferring
        _connected_sending_transferring_0 = Transition(self, self.states["/connected/sending/transferring"], [self.states["/connected/sending/waiting_for_data"]])
        _connected_sending_transferring_0.setAction(self._connected_sending_transferring_0_exec)
        _connected_sending_transferring_0.setTrigger(Event("sent_socket", "socket_in"))
        _connected_sending_transferring_0.setGuard(self._connected_sending_transferring_0_guard)
        self.states["/connected/sending/transferring"].addTransition(_connected_sending_transferring_0)
        
        # transition /connected/queueing/queueing
        _connected_queueing_queueing_0 = Transition(self, self.states["/connected/queueing/queueing"], [self.states["/connected/queueing/queueing"]])
        _connected_queueing_queueing_0.setAction(self._connected_queueing_queueing_0_exec)
        _connected_queueing_queueing_0.setTrigger(Event("HTTP_input", None))
        self.states["/connected/queueing/queueing"].addTransition(_connected_queueing_queueing_0)
        
        # transition /connected/parsing/wait_for_header
        _connected_parsing_wait_for_header_0 = Transition(self, self.states["/connected/parsing/wait_for_header"], [self.states["/connected/parsing/wait_for_payload"]])
        _connected_parsing_wait_for_header_0.setAction(self._connected_parsing_wait_for_header_0_exec)
        _connected_parsing_wait_for_header_0.setTrigger(None)
        _connected_parsing_wait_for_header_0.setGuard(self._connected_parsing_wait_for_header_0_guard)
        self.states["/connected/parsing/wait_for_header"].addTransition(_connected_parsing_wait_for_header_0)
        
        # transition /connected/parsing/wait_for_payload
        _connected_parsing_wait_for_payload_0 = Transition(self, self.states["/connected/parsing/wait_for_payload"], [self.states["/connected/parsing/wait_for_header"]])
        _connected_parsing_wait_for_payload_0.setAction(self._connected_parsing_wait_for_payload_0_exec)
        _connected_parsing_wait_for_payload_0.setTrigger(None)
        _connected_parsing_wait_for_payload_0.setGuard(self._connected_parsing_wait_for_payload_0_guard)
        self.states["/connected/parsing/wait_for_payload"].addTransition(_connected_parsing_wait_for_payload_0)
    
    def _init_enter(self):
        self.big_step.outputEvent(Event("create_socket", "", []))
    
    def _connecting_enter(self):
        self.big_step.outputEvent(Event("connect_socket", "", [self.socket, self.destination]))
    
    def _connected_listening_listen_enter(self):
        self.big_step.outputEvent(Event("recv_socket", "socket_out", [self.socket]))
    
    def _connected_queueing_queueing_enter(self):
        pass
    
    def _init_0_exec(self, parameters):
        socket = parameters[0]
        self.socket = socket
    
    def _connecting_0_exec(self, parameters):
        socket = parameters[0]
        self.big_step.outputEventOM(Event("broad_cast", None, [Event("http_client_ready", None, [])]))
    
    def _connecting_0_guard(self, parameters):
        socket = parameters[0]
        return self.socket == socket
    
    def _connected_listening_listen_0_exec(self, parameters):
        socket = parameters[0]
        data = parameters[1]
        self.received_data += data
    
    def _connected_listening_listen_0_guard(self, parameters):
        socket = parameters[0]
        data = parameters[1]
        return (self.socket == socket) and (len(data) > 0)
    
    def _connected_listening_listen_1_guard(self, parameters):
        socket = parameters[0]
        data = parameters[1]
        return (self.socket == socket) and (len(data) == 0)
    
    def _connected_sending_waiting_for_data_0_exec(self, parameters):
        self.big_step.outputEvent(Event("send_socket", "socket_out", [self.socket, self.send_data]))
    
    def _connected_sending_waiting_for_data_0_guard(self, parameters):
        return len(self.send_data) > 0
    
    def _connected_sending_transferring_0_exec(self, parameters):
        socket = parameters[0]
        sent_bytes = parameters[1]
        self.send_data = self.send_data[sent_bytes:]
    
    def _connected_sending_transferring_0_guard(self, parameters):
        socket = parameters[0]
        sent_bytes = parameters[1]
        return self.socket == socket
    
    def _connected_queueing_queueing_0_exec(self, parameters):
        data = parameters[0]
        destination = parameters[1]
        self.send_data += "POST / HTTP/1.0\r\n"
        self.send_data += "Content-Length: %i\r\n" % len(str(data))
        self.send_data += "\r\n"
        self.send_data += data
        self.destinations.append(destination)
    
    def _connected_parsing_wait_for_header_0_exec(self, parameters):
        header, self.received_data = self.received_data.split("\r\n\r\n", 1)
        header = header.lower()
        if "content-length" in header:
            _, after = header.split("content-length:", 1)
            after, _ = after.split("\r\n", 1)
            after = after.strip()
            self.length = int(after)
        else:
            self.length = float('inf')
    
    def _connected_parsing_wait_for_header_0_guard(self, parameters):
        return '\r\n\r\n' in self.received_data
    
    def _connected_parsing_wait_for_payload_0_exec(self, parameters):
        data = self.received_data[:self.length]
        self.received_data = self.received_data[self.length:]
        params = dict([p.split('=') for p in data.split('&')])
        data = {k: urllib.unquote_plus(v) for k, v in params.iteritems()}
        self.big_step.outputEventOM(Event("narrow_cast", None, [self, self.destinations.pop(0), Event("HTTP_output", None, [data])]))
    
    def _connected_parsing_wait_for_payload_0_guard(self, parameters):
        return len(self.received_data) >= self.length
    
    def initializeStatechart(self):
        # enter default state
        self.default_targets = self.states["/init"].getEffectiveTargetStates()
        RuntimeClassBase.initializeStatechart(self)

class UserStatechart(RuntimeClassBase):
    def __init__(self, controller, username, mvk):
        RuntimeClassBase.__init__(self, controller)
        
        self.semantics.big_step_maximality = StatechartSemantics.TakeMany
        self.semantics.internal_event_lifeline = StatechartSemantics.Queue
        self.semantics.input_event_lifeline = StatechartSemantics.FirstComboStep
        self.semantics.priority = StatechartSemantics.SourceParent
        self.semantics.concurrency = StatechartSemantics.Single
        
        # build Statechart structure
        self.build_statechart_structure()
        
        # call user defined constructor
        UserStatechart.user_defined_constructor(self, username, mvk)
    
    def user_defined_constructor(self, username, mvk):
        self.username = username
        self.mvk = mvk
        
        self.output_queue = []
        self.source_execution = None
        
        self.request_id = 0
        self.outstanding_execution = None
        self.outstanding_input = {}
        self.outstanding_output = None
    
    def user_defined_destructor(self):
        pass
    
    
    # builds Statechart structure
    def build_statechart_structure(self):
        
        # state <root>
        self.states[""] = State(0, self)
        
        # state /init
        self.states["/init"] = State(1, self)
        
        # state /running
        self.states["/running"] = ParallelState(2, self)
        
        # state /running/execution
        self.states["/running/execution"] = State(3, self)
        
        # state /running/execution/executing
        self.states["/running/execution/executing"] = State(4, self)
        
        # state /running/execution/executing/executing
        self.states["/running/execution/executing/executing"] = State(5, self)
        self.states["/running/execution/executing/executing"].setEnter(self._running_execution_executing_executing_enter)
        
        # state /running/execution/executing/timeout
        self.states["/running/execution/executing/timeout"] = State(6, self)
        self.states["/running/execution/executing/timeout"].setEnter(self._running_execution_executing_timeout_enter)
        self.states["/running/execution/executing/timeout"].setExit(self._running_execution_executing_timeout_exit)
        
        # state /running/execution/paused
        self.states["/running/execution/paused"] = State(7, self)
        
        # state /running/set_input
        self.states["/running/set_input"] = State(8, self)
        
        # state /running/set_input/fetch
        self.states["/running/set_input/fetch"] = State(9, self)
        
        # state /running/get_output_queue
        self.states["/running/get_output_queue"] = State(10, self)
        
        # state /running/get_output_queue/waiting
        self.states["/running/get_output_queue/waiting"] = State(11, self)
        
        # state /running/get_output
        self.states["/running/get_output"] = State(12, self)
        
        # state /running/get_output/try_execute
        self.states["/running/get_output/try_execute"] = State(13, self)
        
        # state /running/get_output/waiting
        self.states["/running/get_output/waiting"] = State(14, self)
        self.states["/running/get_output/waiting"].setEnter(self._running_get_output_waiting_enter)
        self.states["/running/get_output/waiting"].setExit(self._running_get_output_waiting_exit)
        
        # add children
        self.states[""].addChild(self.states["/init"])
        self.states[""].addChild(self.states["/running"])
        self.states["/running"].addChild(self.states["/running/execution"])
        self.states["/running"].addChild(self.states["/running/set_input"])
        self.states["/running"].addChild(self.states["/running/get_output_queue"])
        self.states["/running"].addChild(self.states["/running/get_output"])
        self.states["/running/execution"].addChild(self.states["/running/execution/executing"])
        self.states["/running/execution"].addChild(self.states["/running/execution/paused"])
        self.states["/running/execution/executing"].addChild(self.states["/running/execution/executing/executing"])
        self.states["/running/execution/executing"].addChild(self.states["/running/execution/executing/timeout"])
        self.states["/running/set_input"].addChild(self.states["/running/set_input/fetch"])
        self.states["/running/get_output_queue"].addChild(self.states["/running/get_output_queue/waiting"])
        self.states["/running/get_output"].addChild(self.states["/running/get_output/try_execute"])
        self.states["/running/get_output"].addChild(self.states["/running/get_output/waiting"])
        self.states[""].fixTree()
        self.states[""].default_state = self.states["/init"]
        self.states["/running/execution"].default_state = self.states["/running/execution/executing"]
        self.states["/running/execution/executing"].default_state = self.states["/running/execution/executing/executing"]
        self.states["/running/set_input"].default_state = self.states["/running/set_input/fetch"]
        self.states["/running/get_output_queue"].default_state = self.states["/running/get_output_queue/waiting"]
        self.states["/running/get_output"].default_state = self.states["/running/get_output/try_execute"]
        
        # transition /init
        _init_0 = Transition(self, self.states["/init"], [self.states["/running"]])
        _init_0.setAction(self._init_0_exec)
        _init_0.setTrigger(Event("set_returnpath", None))
        self.states["/init"].addTransition(_init_0)
        
        # transition /running/execution/executing/executing
        _running_execution_executing_executing_0 = Transition(self, self.states["/running/execution/executing/executing"], [self.states["/running/execution/executing/executing"]])
        _running_execution_executing_executing_0.setTrigger(Event("executed", None))
        _running_execution_executing_executing_0.setGuard(self._running_execution_executing_executing_0_guard)
        self.states["/running/execution/executing/executing"].addTransition(_running_execution_executing_executing_0)
        _running_execution_executing_executing_1 = Transition(self, self.states["/running/execution/executing/executing"], [self.states["/running/execution/executing/timeout"]])
        _running_execution_executing_executing_1.setTrigger(Event("executed", None))
        _running_execution_executing_executing_1.setGuard(self._running_execution_executing_executing_1_guard)
        self.states["/running/execution/executing/executing"].addTransition(_running_execution_executing_executing_1)
        
        # transition /running/execution/executing/timeout
        _running_execution_executing_timeout_0 = Transition(self, self.states["/running/execution/executing/timeout"], [self.states["/running/execution/executing/executing"]])
        _running_execution_executing_timeout_0.setTrigger(Event("_0after"))
        self.states["/running/execution/executing/timeout"].addTransition(_running_execution_executing_timeout_0)
        _running_execution_executing_timeout_1 = Transition(self, self.states["/running/execution/executing/timeout"], [self.states["/running/execution/executing/executing"]])
        _running_execution_executing_timeout_1.setTrigger(Event("set_input_done", None))
        self.states["/running/execution/executing/timeout"].addTransition(_running_execution_executing_timeout_1)
        
        # transition /running/execution/paused
        _running_execution_paused_0 = Transition(self, self.states["/running/execution/paused"], [self.states["/running/execution/executing"]])
        _running_execution_paused_0.setAction(self._running_execution_paused_0_exec)
        _running_execution_paused_0.setTrigger(Event("resume", None))
        self.states["/running/execution/paused"].addTransition(_running_execution_paused_0)
        
        # transition /running/set_input/fetch
        _running_set_input_fetch_0 = Transition(self, self.states["/running/set_input/fetch"], [self.states["/running/set_input/fetch"]])
        _running_set_input_fetch_0.setAction(self._running_set_input_fetch_0_exec)
        _running_set_input_fetch_0.setTrigger(Event("set_input", None))
        self.states["/running/set_input/fetch"].addTransition(_running_set_input_fetch_0)
        _running_set_input_fetch_1 = Transition(self, self.states["/running/set_input/fetch"], [self.states["/running/set_input/fetch"]])
        _running_set_input_fetch_1.setAction(self._running_set_input_fetch_1_exec)
        _running_set_input_fetch_1.setTrigger(Event("executed", None))
        _running_set_input_fetch_1.setGuard(self._running_set_input_fetch_1_guard)
        self.states["/running/set_input/fetch"].addTransition(_running_set_input_fetch_1)
        
        # transition /running/get_output_queue/waiting
        _running_get_output_queue_waiting_0 = Transition(self, self.states["/running/get_output_queue/waiting"], [self.states["/running/get_output_queue/waiting"]])
        _running_get_output_queue_waiting_0.setAction(self._running_get_output_queue_waiting_0_exec)
        _running_get_output_queue_waiting_0.setTrigger(Event("get_output", None))
        self.states["/running/get_output_queue/waiting"].addTransition(_running_get_output_queue_waiting_0)
        
        # transition /running/get_output/try_execute
        _running_get_output_try_execute_0 = Transition(self, self.states["/running/get_output/try_execute"], [self.states["/running/get_output/try_execute"]])
        _running_get_output_try_execute_0.setAction(self._running_get_output_try_execute_0_exec)
        _running_get_output_try_execute_0.setTrigger(None)
        _running_get_output_try_execute_0.setGuard(self._running_get_output_try_execute_0_guard)
        self.states["/running/get_output/try_execute"].addTransition(_running_get_output_try_execute_0)
        _running_get_output_try_execute_1 = Transition(self, self.states["/running/get_output/try_execute"], [self.states["/running/get_output/try_execute"]])
        _running_get_output_try_execute_1.setAction(self._running_get_output_try_execute_1_exec)
        _running_get_output_try_execute_1.setTrigger(Event("executed", None))
        _running_get_output_try_execute_1.setGuard(self._running_get_output_try_execute_1_guard)
        self.states["/running/get_output/try_execute"].addTransition(_running_get_output_try_execute_1)
        _running_get_output_try_execute_2 = Transition(self, self.states["/running/get_output/try_execute"], [self.states["/running/get_output/waiting"]])
        _running_get_output_try_execute_2.setAction(self._running_get_output_try_execute_2_exec)
        _running_get_output_try_execute_2.setTrigger(Event("executed", None))
        _running_get_output_try_execute_2.setGuard(self._running_get_output_try_execute_2_guard)
        self.states["/running/get_output/try_execute"].addTransition(_running_get_output_try_execute_2)
        
        # transition /running/get_output/waiting
        _running_get_output_waiting_0 = Transition(self, self.states["/running/get_output/waiting"], [self.states["/running/get_output/try_execute"]])
        _running_get_output_waiting_0.setTrigger(Event("_1after"))
        self.states["/running/get_output/waiting"].addTransition(_running_get_output_waiting_0)
        
        # transition /running/execution/executing
        _running_execution_executing_0 = Transition(self, self.states["/running/execution/executing"], [self.states["/running/execution/paused"]])
        _running_execution_executing_0.setAction(self._running_execution_executing_0_exec)
        _running_execution_executing_0.setTrigger(Event("pause", None))
        self.states["/running/execution/executing"].addTransition(_running_execution_executing_0)
    
    def _running_execution_executing_executing_enter(self):
        self.big_step.outputEventOM(Event("narrow_cast", None, [self, 'parent/executor', Event("execute", None, [self.returnpath, self.username, 'execute_rule', [], self.request_id])]))
        self.outstanding_execution = self.request_id
        self.request_id += 1
    
    def _running_execution_executing_timeout_enter(self):
        self.addTimer(0, 1.0)
    
    def _running_execution_executing_timeout_exit(self):
        self.removeTimer(0)
    
    def _running_get_output_waiting_enter(self):
        self.addTimer(1, 1.0)
    
    def _running_get_output_waiting_exit(self):
        self.removeTimer(1)
    
    def _running_execution_executing_0_exec(self, parameters):
        source = parameters[0]
        args = parameters[1]
        self.big_step.outputEventOM(Event("narrow_cast", None, [self, 'parent/to_mvi/' + source, Event("HTTP_input", None, [json.dumps({'user': self.username, 'state': 'paused', 'info': self.mvk.debug_info})])]))
    
    def _init_0_exec(self, parameters):
        returnpath = parameters[0]
        self.returnpath = returnpath
    
    def _running_execution_executing_executing_0_guard(self, parameters):
        returnvalue = parameters[0]
        success = parameters[1]
        request_id = parameters[2]
        return success and self.outstanding_execution == request_id
    
    def _running_execution_executing_executing_1_guard(self, parameters):
        returnvalue = parameters[0]
        success = parameters[1]
        request_id = parameters[2]
        return not success and self.outstanding_execution == request_id
    
    def _running_execution_paused_0_exec(self, parameters):
        source = parameters[0]
        args = parameters[1]
        self.big_step.outputEventOM(Event("narrow_cast", None, [self, 'parent/to_mvi/' + source, Event("HTTP_input", None, [json.dumps({'user': self.username, 'state': 'running'})])]))
    
    def _running_set_input_fetch_0_exec(self, parameters):
        source = parameters[0]
        args = parameters[1]
        self.big_step.outputEventOM(Event("narrow_cast", None, [self, 'parent/executor', Event("execute", None, [self.returnpath, self.username, 'set_input', args, self.request_id])]))
        if source is not None:
            self.outstanding_input[self.request_id] = source
            self.request_id += 1
    
    def _running_set_input_fetch_1_exec(self, parameters):
        returnvalue = parameters[0]
        success = parameters[1]
        request_id = parameters[2]
        source = self.outstanding_input.pop(request_id)
        self.big_step.outputEventOM(Event("narrow_cast", None, [self, 'parent/to_mvi/' + source, Event("HTTP_input", None, [json.dumps(returnvalue)])]))
        self.raiseInternalEvent(Event("set_input_done", None, []))
    
    def _running_set_input_fetch_1_guard(self, parameters):
        returnvalue = parameters[0]
        success = parameters[1]
        request_id = parameters[2]
        return request_id in self.outstanding_input
    
    def _running_get_output_queue_waiting_0_exec(self, parameters):
        source = parameters[0]
        args = parameters[1]
        self.output_queue.append(source)
    
    def _running_get_output_try_execute_0_exec(self, parameters):
        self.big_step.outputEventOM(Event("narrow_cast", None, [self, 'parent/executor', Event("execute", None, [self.returnpath, self.username, 'get_output', [], self.request_id])]))
        self.outstanding_output = self.request_id
        self.request_id += 1
    
    def _running_get_output_try_execute_0_guard(self, parameters):
        return self.outstanding_output is None and self.output_queue
    
    def _running_get_output_try_execute_1_exec(self, parameters):
        returnvalue = parameters[0]
        success = parameters[1]
        request_id = parameters[2]
        self.big_step.outputEventOM(Event("narrow_cast", None, [self, 'parent/to_mvi/' + self.output_queue.pop(0), Event("HTTP_input", None, [json.dumps(returnvalue)])]))
        self.outstanding_output = None
    
    def _running_get_output_try_execute_1_guard(self, parameters):
        returnvalue = parameters[0]
        success = parameters[1]
        request_id = parameters[2]
        return success and request_id == self.outstanding_output
    
    def _running_get_output_try_execute_2_exec(self, parameters):
        returnvalue = parameters[0]
        success = parameters[1]
        request_id = parameters[2]
        self.outstanding_output = None
    
    def _running_get_output_try_execute_2_guard(self, parameters):
        returnvalue = parameters[0]
        success = parameters[1]
        request_id = parameters[2]
        return not success and request_id == self.outstanding_output
    
    def initializeStatechart(self):
        # enter default state
        self.default_targets = self.states["/init"].getEffectiveTargetStates()
        RuntimeClassBase.initializeStatechart(self)

class Executor(RuntimeClassBase):
    def __init__(self, controller):
        RuntimeClassBase.__init__(self, controller)
        
        self.semantics.big_step_maximality = StatechartSemantics.TakeMany
        self.semantics.internal_event_lifeline = StatechartSemantics.Queue
        self.semantics.input_event_lifeline = StatechartSemantics.FirstComboStep
        self.semantics.priority = StatechartSemantics.SourceParent
        self.semantics.concurrency = StatechartSemantics.Single
        
        # build Statechart structure
        self.build_statechart_structure()
        
        # call user defined constructor
        Executor.user_defined_constructor(self)
    
    def user_defined_constructor(self):
        self.mvs = ModelverseState("../../bootstrap/bootstrap.m.gz")
        self.request_queue = [("", "", "load_primitives", [], None)]
        self.mvs.GC = True
        self.mvk = ModelverseKernel(self.mvs.read_root()[0])
        self.first = True
        self.mvs_response = None
        
        self.mvs_operations = {
                "CN": self.mvs.create_node,
                "CE": self.mvs.create_edge,
                "CNV": self.mvs.create_nodevalue,
                "CD": self.mvs.create_dict,
        
                "RV": self.mvs.read_value,
                "RO": self.mvs.read_outgoing,
                "RI": self.mvs.read_incoming,
                "RE": self.mvs.read_edge,
                "RD": self.mvs.read_dict,
                "RDN": self.mvs.read_dict_node,
                "RDNE": self.mvs.read_dict_node_edge,
                "RDE": self.mvs.read_dict_edge,
                "RRD": self.mvs.read_reverse_dict,
                "RR": self.mvs.read_root,
                "RDK": self.mvs.read_dict_keys,
        
                "DE": self.mvs.delete_edge,
                "DN": self.mvs.delete_node,
            }
    
    def user_defined_destructor(self):
        pass
    
    
    # builds Statechart structure
    def build_statechart_structure(self):
        
        # state <root>
        self.states[""] = State(0, self)
        
        # state /init
        self.states["/init"] = ParallelState(1, self)
        
        # state /init/raw_exec
        self.states["/init/raw_exec"] = State(2, self)
        
        # state /init/raw_exec/raw_exec
        self.states["/init/raw_exec/raw_exec"] = State(3, self)
        
        # state /init/queue
        self.states["/init/queue"] = State(4, self)
        
        # state /init/queue/queue
        self.states["/init/queue/queue"] = State(5, self)
        
        # state /init/execute
        self.states["/init/execute"] = State(6, self)
        
        # state /init/execute/idle
        self.states["/init/execute/idle"] = State(7, self)
        
        # state /init/execute/execution
        self.states["/init/execute/execution"] = State(8, self)
        self.states["/init/execute/execution"].setEnter(self._init_execute_execution_enter)
        
        # add children
        self.states[""].addChild(self.states["/init"])
        self.states["/init"].addChild(self.states["/init/raw_exec"])
        self.states["/init"].addChild(self.states["/init/queue"])
        self.states["/init"].addChild(self.states["/init/execute"])
        self.states["/init/raw_exec"].addChild(self.states["/init/raw_exec/raw_exec"])
        self.states["/init/queue"].addChild(self.states["/init/queue/queue"])
        self.states["/init/execute"].addChild(self.states["/init/execute/idle"])
        self.states["/init/execute"].addChild(self.states["/init/execute/execution"])
        self.states[""].fixTree()
        self.states[""].default_state = self.states["/init"]
        self.states["/init/raw_exec"].default_state = self.states["/init/raw_exec/raw_exec"]
        self.states["/init/queue"].default_state = self.states["/init/queue/queue"]
        self.states["/init/execute"].default_state = self.states["/init/execute/idle"]
        
        # transition /init/raw_exec/raw_exec
        _init_raw_exec_raw_exec_0 = Transition(self, self.states["/init/raw_exec/raw_exec"], [self.states["/init/raw_exec/raw_exec"]])
        _init_raw_exec_raw_exec_0.setAction(self._init_raw_exec_raw_exec_0_exec)
        _init_raw_exec_raw_exec_0.setTrigger(Event("raw_exec", None))
        self.states["/init/raw_exec/raw_exec"].addTransition(_init_raw_exec_raw_exec_0)
        _init_raw_exec_raw_exec_1 = Transition(self, self.states["/init/raw_exec/raw_exec"], [self.states["/init/raw_exec/raw_exec"]])
        _init_raw_exec_raw_exec_1.setAction(self._init_raw_exec_raw_exec_1_exec)
        _init_raw_exec_raw_exec_1.setTrigger(Event("get_mvk", None))
        self.states["/init/raw_exec/raw_exec"].addTransition(_init_raw_exec_raw_exec_1)
        
        # transition /init/queue/queue
        _init_queue_queue_0 = Transition(self, self.states["/init/queue/queue"], [self.states["/init/queue/queue"]])
        _init_queue_queue_0.setAction(self._init_queue_queue_0_exec)
        _init_queue_queue_0.setTrigger(Event("execute", None))
        self.states["/init/queue/queue"].addTransition(_init_queue_queue_0)
        
        # transition /init/execute/idle
        _init_execute_idle_0 = Transition(self, self.states["/init/execute/idle"], [self.states["/init/execute/execution"]])
        _init_execute_idle_0.setTrigger(None)
        _init_execute_idle_0.setGuard(self._init_execute_idle_0_guard)
        self.states["/init/execute/idle"].addTransition(_init_execute_idle_0)
        
        # transition /init/execute/execution
        _init_execute_execution_0 = Transition(self, self.states["/init/execute/execution"], [self.states["/init/execute/idle"]])
        _init_execute_execution_0.setAction(self._init_execute_execution_0_exec)
        _init_execute_execution_0.setTrigger(None)
        _init_execute_execution_0.setGuard(self._init_execute_execution_0_guard)
        self.states["/init/execute/execution"].addTransition(_init_execute_execution_0)
        _init_execute_execution_1 = Transition(self, self.states["/init/execute/execution"], [self.states["/init/execute/idle"]])
        _init_execute_execution_1.setTrigger(None)
        _init_execute_execution_1.setGuard(self._init_execute_execution_1_guard)
        self.states["/init/execute/execution"].addTransition(_init_execute_execution_1)
    
    def _init_execute_execution_enter(self):
        self.mvk.returnvalue = None
        self.mvk.success = True
        self.first = True
        
        self.returnpath, username, operation, params, self.request_id = self.request_queue.pop(0)
        reply = None
        commands = []
        while 1:
            commands = self.mvk.execute_yields(username, operation, params, reply)
            if commands is None:
                break
            reply = [self.mvs_operations[command[0]](*(command[1]))[0] for command in commands]
    
    def _init_raw_exec_raw_exec_0_exec(self, parameters):
        operations = parameters[0]
        source = parameters[1]
        reply = [self.mvs_operations[command[0]](*command[1]) for command in operations]
        self.big_step.outputEventOM(Event("narrow_cast", None, [self, source, Event("raw_exec_reply", None, [reply])]))
    
    def _init_raw_exec_raw_exec_1_exec(self, parameters):
        source = parameters[0]
        self.big_step.outputEventOM(Event("narrow_cast", None, [self, source, Event("get_mvk_reply", None, [self.mvk])]))
    
    def _init_queue_queue_0_exec(self, parameters):
        returnpath = parameters[0]
        username = parameters[1]
        operation = parameters[2]
        params = parameters[3]
        request_id = parameters[4]
        self.request_queue.append((("/" + returnpath) if returnpath is not None else None, username, operation, params, request_id))
    
    def _init_execute_idle_0_guard(self, parameters):
        return self.request_queue
    
    def _init_execute_execution_0_exec(self, parameters):
        self.big_step.outputEventOM(Event("narrow_cast", None, [self, 'parent' + self.returnpath, Event("executed", None, [self.mvk.returnvalue, self.mvk.success, self.request_id])]))
    
    def _init_execute_execution_0_guard(self, parameters):
        return self.returnpath is not None
    
    def _init_execute_execution_1_guard(self, parameters):
        return self.returnpath is None
    
    def initializeStatechart(self):
        # enter default state
        self.default_targets = self.states["/init"].getEffectiveTargetStates()
        RuntimeClassBase.initializeStatechart(self)

class ObjectManager(ObjectManagerBase):
    def __init__(self, controller):
        ObjectManagerBase.__init__(self, controller)
    
    def instantiate(self, class_name, construct_params):
        if class_name == "MvKController":
            instance = MvKController(self.controller, construct_params[0])
            instance.associations = {}
            instance.associations["to_mvs"] = Association("HTTPClient", 1, 1)
            instance.associations["to_mvi"] = Association("Server", 1, 1)
            instance.associations["users"] = Association("UserStatechart", 0, -1)
            instance.associations["executor"] = Association("Executor", 1, 1)
        elif class_name == "Server":
            instance = Server(self.controller, construct_params[0], construct_params[1])
            instance.associations = {}
            instance.associations["sockets"] = Association("Socket", 0, -1)
            instance.associations["parent"] = Association("MvKController", 1, 1)
        elif class_name == "Socket":
            instance = Socket(self.controller, construct_params[0])
            instance.associations = {}
            instance.associations["parent"] = Association("Server", 1, 1)
        elif class_name == "HTTPClient":
            instance = HTTPClient(self.controller, construct_params[0], construct_params[1])
            instance.associations = {}
            instance.associations["parent"] = Association("MvKController", 1, 1)
        elif class_name == "UserStatechart":
            instance = UserStatechart(self.controller, construct_params[0], construct_params[1])
            instance.associations = {}
            instance.associations["parent"] = Association("MvKController", 1, 1)
        elif class_name == "Executor":
            instance = Executor(self.controller)
            instance.associations = {}
            instance.associations["parent"] = Association("MvKController", 1, 1)
        else:
            raise Exception("Cannot instantiate class " + class_name)
        return instance

class Controller(ThreadsControllerBase):
    def __init__(self, params, keep_running = None, behind_schedule_callback = None):
        if keep_running == None: keep_running = True
        if behind_schedule_callback == None: behind_schedule_callback = None
        ThreadsControllerBase.__init__(self, ObjectManager(self), keep_running, behind_schedule_callback)
        self.addInputPort("socket_in")
        self.addOutputPort("socket_out")
        self.object_manager.createInstance("MvKController", [params])