예제 #1
0
파일: ALPSCTP.py 프로젝트: peterwyj/WSDT
 def CTPC_POST(self, node, content):
     if not self.__ocm_table.exist_owner(node):
         MessageOutput.NODE_UNFOUND(node)
         return ReturnCode.gen(ReturnCode.CTPC_NODE_UNFOUND)
     ctpcmd_post = CTPCommandParser.generate_post(node, repr(content))
     self.receive(self, ctpcmd_post)
     return ReturnCode.gen(ReturnCode.CTPC_SUCCESS)
예제 #2
0
파일: ALPSCTP.py 프로젝트: peterwyj/WSDT
    def CTPC_UNREGISTER(self, node, unregister_type):
        if not self.__ocm_table.exist_owner(node):
            MessageOutput.NODE_UNFOUND(node)
            return ReturnCode.gen(ReturnCode.CTPC_NODE_UNFOUND)

        if unregister_type == CTPCommandParser.COMMANDPARA_CONTROLLER:
            if not self.__ocm_table.exist_controller(node):
                MessageOutput.NODE_NOT_ASSIGNED(node, unregister_type, 'self')
                return ReturnCode.gen(ReturnCode.CTPC_NOT_ASSIGNED)

            controller_node = self.__ocm_table.get_controller(node)
            ctpcmd_unregister = CTPCommandParser.generate_unregister(node,
                                                             controller=controller_node)
            # Wait Response
            returncode = self.__wait_ctpc_response(node, ctpcmd_unregister)
            if ReturnCode.code(returncode) == ReturnCode.CTPC_SUCCESS:
                if self.__ocm_table.exist_controller(node):
                    self.__ocm_table.remove_controller(node)
                self.remove_nodes(controller_node)
                MessageOutput.NODE_UNREGISTERED(node, unregister_type, controller_node)
            elif ReturnCode.code(returncode) == ReturnCode.CTPC_NOT_ASSIGNED:
                MessageOutput.NODE_NOT_ASSIGNED(node, unregister_type, controller_node)
            elif ReturnCode.code(returncode) == ReturnCode.CTPC_ALREADY_ASSIGNED:
                MessageOutput.CONTROLLER_ALREADY_ASSIGNED(node, controller_node)
            return returncode

        elif unregister_type == CTPCommandParser.COMMANDPARA_MONITOR:
            if not self.__ocm_table.get_monitors(node):
                return ReturnCode.gen(ReturnCode.CTPC_NOT_ASSIGNED)

            monitor_node = self.__ocm_table.get_monitors(node)[0]
            ctpcmd_unregister = CTPCommandParser.generate_unregister(node,
                                                             monitor=monitor_node)
            # Wait Response
            returncode = self.__wait_ctpc_response(node, ctpcmd_unregister)
            if ReturnCode.code(returncode) == ReturnCode.CTPC_SUCCESS:
                if self.__ocm_table.get_monitors(node):
                    self.__ocm_table.remove_monitor(node, monitor_node)
                self.remove_nodes(monitor_node)
                MessageOutput.NODE_UNREGISTERED(node, unregister_type, monitor_node)
            elif ReturnCode.code(returncode) == ReturnCode.CTPC_NOT_ASSIGNED:
                MessageOutput.NODE_NOT_ASSIGNED(node, unregister_type, monitor_node)
            return returncode

        else:
            MessageOutput.CTPCOMMAND_ERROR("Unsupported Unregister type: " + unregister_type)
            return ReturnCode.gen(ReturnCode.CTPC_ERROR)
예제 #3
0
파일: ALPSCTP.py 프로젝트: peterwyj/WSDT
 def reset_ocm_table(self):
     # clear all node
     self.__report_node()
     # get self node now
     self.__node_manager.do_node_discover()
     # update other nodes
     ctpcmd_updatenode = CTPCommandParser.generate_updatenode()
     self.__broadcast(ctpcmd_updatenode)
예제 #4
0
파일: ALPSCTP.py 프로젝트: peterwyj/WSDT
    def receive(self, peer, ctp_command):
        success, result = CTPCommandParser.process_command_args(ctp_command)
        if not success:
            MessageOutput.CTPCOMMAND_ERROR(result)
            return
        ctp_command_name, argv = result
        MessageOutput.CTPCOMMAND_RECV(ctp_command_name, argv)

        process_func = self.__CTPC_MAP[ctp_command_name]
        process_func(peer, ctp_command, ctp_command_name, argv)
예제 #5
0
파일: ALPSCTP.py 프로젝트: peterwyj/WSDT
    def CTPC_STOP(self, node, app, optionals=None):
        if not self.__ocm_table.exist_owner(node):
            returncode = ReturnCode.gen(ReturnCode.CTPC_NODE_UNFOUND)

        elif not self.__ocm_table.exist_controller(node):
            returncode = ReturnCode.gen(ReturnCode.CTPC_NOT_ASSIGNED)

        else:
            controller = self.__ocm_table.get_controller(node)
            if optionals:
                ctpcmd_stop = CTPCommandParser.generate_stop(node, controller, app,
                                                             optionals=repr(optionals))
            else:
                ctpcmd_stop = CTPCommandParser.generate_stop(node, controller, app)
            # Wait Response
            returncode = self.__wait_ctpc_response(node, ctpcmd_stop)
        if ReturnCode.code(returncode) == ReturnCode.CTPC_NODE_UNFOUND:
            MessageOutput.NODE_UNFOUND(node)
        elif ReturnCode.code(returncode) == ReturnCode.CTPC_NOT_ASSIGNED:
            MessageOutput.NODE_NOT_ASSIGNED(node, CTPCommandParser.COMMANDPARA_CONTROLLER, 'self')
        elif ReturnCode.code(returncode) == ReturnCode.CTPC_REJECTED:
            MessageOutput.CONTROLLER_ALREADY_ASSIGNED(node, 'self')
        return returncode
예제 #6
0
파일: ALPSCTP.py 프로젝트: peterwyj/WSDT
    def CTPC_RESPONSE(self, node, content):
        if not self.__ocm_table.exist_owner(node):
            MessageOutput.NODE_UNFOUND(node)
            return ReturnCode.gen(ReturnCode.CTPC_NODE_UNFOUND)

        if self.__ocm_table.get_owner(node) != self:
            MessageOutput.CONTROLLER_ALREADY_ASSIGNED(node, 'self')
            return ReturnCode.gen(ReturnCode.CTPC_REJECTED)

        if not self.__ocm_table.exist_controller(node):
            MessageOutput.NODE_NOT_ASSIGNED(node, CTPCommandParser.COMMANDPARA_CONTROLLER, 'self')
            return ReturnCode.gen(ReturnCode.CTPC_NOT_ASSIGNED)

        controller = self.__ocm_table.get_controller(node)
        ctpcmd_response = CTPCommandParser.generate_response(node, controller,
                                                             repr(ReturnCode.gen(argv=content)))
        self.receive(self, ctpcmd_response)
        return ReturnCode.gen(ReturnCode.CTPC_SUCCESS)
예제 #7
0
파일: ALPSCTP.py 프로젝트: peterwyj/WSDT
    def CTPC_EVENT(self, node, content):
        if not self.__ocm_table.exist_owner(node):
            MessageOutput.NODE_UNFOUND(node)
            return ReturnCode.gen(ReturnCode.CTPC_NODE_UNFOUND)

        if self.__ocm_table.get_owner(node) != self:
            MessageOutput.CONTROLLER_ALREADY_ASSIGNED(node, 'self')
            return ReturnCode.gen(ReturnCode.CTPC_REJECTED)

        if not self.__ocm_table.exist_controller(node):
            MessageOutput.NODE_NOT_ASSIGNED(node, CTPCommandParser.COMMANDPARA_CONTROLLER, 'self')
            return ReturnCode.gen(ReturnCode.CTPC_NOT_ASSIGNED)

        monitors = self.__ocm_table.get_monitors(node)
        monitors.insert(0, self.__ocm_table.get_controller(node))
        for monitor in monitors:
            ctpcmd_event = CTPCommandParser.generate_event(node, monitor, repr(content))
            self.receive(self, ctpcmd_event)
        return ReturnCode.gen(ReturnCode.CTPC_SUCCESS)
예제 #8
0
파일: ALPSCTP.py 프로젝트: peterwyj/WSDT
    def CTPC_COMMAND(self, node, app, content):
        if not self.__ocm_table.exist_owner(node):
            returncode = ReturnCode.gen(ReturnCode.CTPC_NODE_UNFOUND)

        elif not self.__ocm_table.exist_controller(node):
            returncode = ReturnCode.gen(ReturnCode.CTPC_NOT_ASSIGNED)

        else:
            controller = self.__ocm_table.get_controller(node)
            ctpcmd_command = CTPCommandParser.generate_command(node, controller, app, repr(content))

            # Wait Response
            returncode = self.__wait_ctpc_response(node, ctpcmd_command)
        if ReturnCode.code(returncode) == ReturnCode.CTPC_NODE_UNFOUND:
            MessageOutput.NODE_UNFOUND(node)
        elif ReturnCode.code(returncode) == ReturnCode.CTPC_NOT_ASSIGNED:
            MessageOutput.NODE_NOT_ASSIGNED(node, CTPCommandParser.COMMANDPARA_CONTROLLER, 'self')
        elif ReturnCode.code(returncode) == ReturnCode.CTPC_REJECTED:
            MessageOutput.CONTROLLER_ALREADY_ASSIGNED(node, 'self')
        return returncode
예제 #9
0
파일: ALPSCTP.py 프로젝트: peterwyj/WSDT
 def __response(self, node, peer, return_code):
     ctpcmd_response = CTPCommandParser.generate_response(node, peer,
                                                          ReturnCode.gen_str(return_code))
     self.receive(peer, ctpcmd_response)
예제 #10
0
파일: ALPSCTP.py 프로젝트: peterwyj/WSDT
 def __report_node(self):
     nodes = self.NODE_SPLIT.join(self.__ocm_table.get_nodes())
     ctpcmd_reportnode = CTPCommandParser.generate_reportnode(nodes)
     self.__broadcast(ctpcmd_reportnode)
예제 #11
0
파일: ALPSCTP.py 프로젝트: peterwyj/WSDT
 def __PROCESS_UPDATENODE(self, peer, ctp_command, ctp_command_name, argv):
     nodes = self.NODE_SPLIT.join(self.__ocm_table.get_nodes())
     ctpcmd_reportnode = CTPCommandParser.generate_reportnode(nodes)
     # just send to whom needed
     self.__send(peer, ctpcmd_reportnode)
예제 #12
0
파일: ALPSCTP.py 프로젝트: peterwyj/WSDT
    def CTPC_REGISTER(self, node, register_type):
        if not self.__ocm_table.exist_owner(node):
            MessageOutput.NODE_UNFOUND(node)
            return ReturnCode.gen(ReturnCode.CTPC_NODE_UNFOUND)

        if register_type == CTPCommandParser.COMMANDPARA_CONTROLLER:
            if self.__ocm_table.exist_controller(node):
                MessageOutput.CONTROLLER_ALREADY_ASSIGNED(node, "self")
                return ReturnCode.gen(ReturnCode.CTPC_ALREADY_ASSIGNED)
            controller_node = "controller[%s]" % node
            if self.__node_manager.hasnode(controller_node):
                MessageOutput.CONTROLLER_ALREADY_ASSIGNED(node, "self")
                return ReturnCode.gen(ReturnCode.CTPC_ALREADY_ASSIGNED)
            ctpcmd_register = CTPCommandParser.generate_register(node,
                                                             controller=controller_node)

            # Add Virtual Controll Node
            self.append_nodes(controller_node)

            # Wait Response
            returncode = self.__wait_ctpc_response(node, ctpcmd_register)
            if ReturnCode.code(returncode) == ReturnCode.CTPC_SUCCESS:
                if not self.__ocm_table.exist_controller(node):
                    self.__ocm_table.set_controller(node, controller_node)
                MessageOutput.NODE_REGISTERED(node, register_type, controller_node)
            else:
                # Register Failed and Delete controller node
                self.remove_nodes(controller_node)
                if ReturnCode.code(returncode) == ReturnCode.CTPC_ALREADY_ASSIGNED:
                    MessageOutput.CONTROLLER_ALREADY_ASSIGNED(node, controller_node)
            return returncode

        elif register_type == CTPCommandParser.COMMANDPARA_MONITOR:
            if self.__ocm_table.get_monitors(node):
                return ReturnCode.gen(ReturnCode.CTPC_ALREADY_ASSIGNED)
            for i in range(1, 1000):
                monitor_node = "monitor[%s]_%s" % (node, i)
                if not self.__node_manager.hasnode(monitor_node):
                    break
            else:
                MessageOutput.CTPCOMMAND_ERROR("The number of Monitor[%s] is too large." % node)
                return ReturnCode.gen(ReturnCode.CTPC_ERROR)
            ctpcmd_register = CTPCommandParser.generate_register(node,
                                                                 monitor=monitor_node)

            # Add Virtual Monitor Node
            self.append_nodes(monitor_node)

            # Wait Response
            returncode = self.__wait_ctpc_response(node, ctpcmd_register)
            if ReturnCode.code(returncode) == ReturnCode.CTPC_SUCCESS:
                if not self.__ocm_table.get_monitors(node):
                    self.__ocm_table.add_monitor(node, monitor_node)
                MessageOutput.NODE_REGISTERED(node, register_type, monitor_node)
            else:
                # Register Failed and Delete monitor node
                self.remove_nodes(monitor_node)
            return returncode

        else:
            MessageOutput.CTPCOMMAND_ERROR("Unsupported Register type: " + register_type)
            return ReturnCode.gen(ReturnCode.CTPC_ERROR)