コード例 #1
0
 def setup(self, server, loader):
     """Setup the bundle following the setup process.
     
     Note that the bundles dictionary is passed to the setup method.  It
     allows the bundle, when reading its meta-datas, to check its
     requirements.
     
     Return whether the bundle has been correctly setup.  If the
     setup method returns False, the bundle won't be used in the
     final application.
     
     When the server is running, all installed bundles are read and setup
     following this process:
     1.  The bundle meta-datas are read from its file bundle.py.  If this
         meta-datas indicates that the bundle can not be setup, the process
         stops
     2.  The controllers, models and views are loaded
     3.  The configuration is read and follows its own setup process
     
     """
     self.meta_datas = self.read_meta_datas()
     
     # Check the bundle requirements
     for requirement in self.meta_datas.requirements:
         if requirement not in server.bundles:
             print("The {} bundle needs the {} one".format(
                     self.name, requirement))
             return False
     
     for plugin_name in self.meta_datas.plugins:
         self.server.plugin_manager.load_plugin(loader, plugin_name)
         self.server.plugin_manager.call("extend_autoloader",
                 self.server, loader)
         self.server.plugin_manager.call_for(plugin_name,
                 "bundle_autoload", self, loader)
     
     # Load the bundle's configuration
     self.config = Config(self.name)
     cfg_setup = self.config.setup(server)
     if not cfg_setup:
         return False
     
     # Load (with the autoloader) the Python modules
     loader.load_modules("controller", \
             "bundles." + self.name + ".controllers")
     loader.load_modules("model", "bundles." + self.name + ".models")
     loader.load_modules("service", "bundles." + self.name + ".services")
     return True
コード例 #2
0
 def setup(self, server):
     """Setup the bundle following the setup process.
     
     Note that the bundles dictionary is passed to the setup method.  It
     allows the bundle, when reading its meta-datas, to check its
     requirements.
     
     Return whether the bundle has been correctly setup.  If the
     setup method returns False, the bundle won't be used in the
     final application.
     
     When the server is running, all installed bundles are read and setup
     following this process:
     1.  The bundle meta-datas are read from its file bundle.py.  If this
         meta-datas indicates that the bundle can not be setup, the process
         stops
     2.  The controllers, models and views are loaded
     3.  The configuration is read and follows its own setup process
     
     """
     self.meta_datas = self.read_meta_datas()
     
     # Check the bundle requirements
     for requirement in self.meta_datas.requirements:
         if requirement not in server.bundles:
             print("The {} bundle needs the {} one".format(
                     self.name, requirement))
             return False
     
     self.load_controllers(server)
     self.load_models(server)
     self.load_services(server)
     self.config = Config(self.name)
     cfg_setup = self.config.setup(server)
     if not cfg_setup:
         return False
     
     return True
コード例 #3
0
class Bundle:
    
    """Class representing a user bundle, part of a Python Aboard application.
    
    The bundles defined by the user contains part of his application.  The
    whole bundles almost constitute the entire application itself.
    As a matter of fact, the bundle contains:
    *   Configuration (like, for instance, routing informations)
    *   Controllers and their actions
    *   Models
    *   Views (templates)
    
    The bundles should be as independant as possible:  removing a bundle may
    remove some functionalities but the application should still
    work.  Though, some bundles may need other bundles to work and,
    if so, they won't be installed at all if some requirements are
    missing.
    
    """
    
    def __init__(self, name):
        """Create a new bundle."""
        self.name = name
        self.meta_data = None
        self.controllers = {}
        self.models = {}
        self.views = {}
        self.config = None
    
    def setup(self, server):
        """Setup the bundle following the setup process.
        
        Note that the bundles dictionary is passed to the setup method.  It
        allows the bundle, when reading its meta-datas, to check its
        requirements.
        
        Return whether the bundle has been correctly setup.  If the
        setup method returns False, the bundle won't be used in the
        final application.
        
        When the server is running, all installed bundles are read and setup
        following this process:
        1.  The bundle meta-datas are read from its file bundle.py.  If this
            meta-datas indicates that the bundle can not be setup, the process
            stops
        2.  The controllers, models and views are loaded
        3.  The configuration is read and follows its own setup process
        
        """
        self.meta_datas = self.read_meta_datas()
        
        # Check the bundle requirements
        for requirement in self.meta_datas.requirements:
            if requirement not in server.bundles:
                print("The {} bundle needs the {} one".format(
                        self.name, requirement))
                return False
        
        self.load_controllers(server)
        self.load_models(server)
        self.load_services(server)
        self.config = Config(self.name)
        cfg_setup = self.config.setup(server)
        if not cfg_setup:
            return False
        
        return True
    
    def read_meta_datas(self):
        """Read the meta datas."""
        path = "bundles/" + self.name + "/meta_datas.yml"
        if not os.path.exists(path):
            raise ValueError("the meta-datas of the {} bundle can't " \
                    "be found in {}".format(self.name, path))
        
        if not os.access(path, os.R_OK):
            raise ValueError("the meta-datas of the {} bundle can't " \
                    "be read in {}".format(self.name, path))
        
        with open(path, "r") as meta_file:
            meta_dict = yaml.load(meta_file)
        
        return MetaDatas(self.name, meta_dict)
    
    def load_controllers(self, server):
        """Load the bundle controllers."""
        path = "bundles/" + self.name + "/controllers"
        py_path = "bundles." + self.name + ".controllers"
        if os.path.exists(path):
            for file_name in os.listdir(path):
                if not file_name.startswith("__") and \
                        file_name.endswith(".py") and len(file_name) > 3:
                    file_path = path + "/" + file_name
                    py_file_path = py_path + "." + file_name[:-3]
                    self.load_controller(file_name[:-3], file_name,
                            py_file_path, server)
    
    def load_controller(self, py_name, path, py_path, server):
        """Load a controller."""
        controller_name = py_name.capitalize()
        load = __import__(py_path)
        for node in py_path.split(".")[1:]:
            load = getattr(load, node)
        
        controller = getattr(load, controller_name)
        controller = controller(self)
        controller.server = server
        self.controllers[controller_name] = controller
    
    def load_models(self, server):
        """Load the bundle models."""
        path = "bundles/" + self.name + "/models"
        py_path = "bundles." + self.name + ".models"
        if os.path.exists(path):
            for file_name in os.listdir(path):
                if not file_name.startswith("__") and \
                        file_name.endswith(".py") and len(file_name) > 3:
                    file_path = path + "/" + file_name
                    py_file_path = py_path + "." + file_name[:-3]
                    self.load_model(file_name[:-3], file_name,
                            py_file_path, server)
    
    def load_model(self, py_name, path, py_path, server):
        """Load a model."""
        model_name = py_name.capitalize()
        load = __import__(py_path)
        for node in py_path.split(".")[1:]:
            load = getattr(load, node)
        
        model = getattr(load, model_name)
        self.models[model_name] = model
    
    def load_services(self, server):
        """Load the bundle services."""
        path = "bundles/" + self.name + "/services"
        py_path = "bundles." + self.name + ".services"
        print(path, os.path.exists(path))
        if os.path.exists(path):
            for file_name in os.listdir(path):
                print(file_name)
                if not file_name.startswith("__") and \
                        file_name.endswith(".py") and len(file_name) > 3:
                    file_path = path + "/" + file_name
                    py_file_path = py_path + "." + file_name[:-3]
                    self.load_service(file_name[:-3], file_name,
                            py_file_path, server)
    
    def load_service(self, py_name, path, py_path, server):
        """Load a service."""
        service_name = py_name.capitalize()
        load = __import__(py_path)
        for node in py_path.split(".")[1:]:
            load = getattr(load, node)
        
        service = getattr(load, service_name)
        print("service", py_name)
        server.services.register(py_name, service)
コード例 #4
0
class Bundle:
    
    """Class representing a user bundle, part of a Python Aboard application.
    
    The bundles defined by the user contains part of his application.  The
    whole bundles almost constitute the entire application itself.
    As a matter of fact, the bundle contains:
    *   Configuration (like, for instance, routing informations)
    *   Controllers and their actions
    *   Models
    *   Views (templates)
    
    The bundles should be as independant as possible:  removing a bundle may
    remove some functionalities but the application should still
    work.  Though, some bundles may need other bundles to work and,
    if so, they won't be installed at all if some requirements are
    missing.
    
    """
    
    def __init__(self, server, name):
        """Create a new bundle."""
        self.server = server
        self.name = name
        self.meta_data = None
        self.controllers = {}
        self.models = {}
        self.views = {}
        self.config = None
    
    def setup(self, server, loader):
        """Setup the bundle following the setup process.
        
        Note that the bundles dictionary is passed to the setup method.  It
        allows the bundle, when reading its meta-datas, to check its
        requirements.
        
        Return whether the bundle has been correctly setup.  If the
        setup method returns False, the bundle won't be used in the
        final application.
        
        When the server is running, all installed bundles are read and setup
        following this process:
        1.  The bundle meta-datas are read from its file bundle.py.  If this
            meta-datas indicates that the bundle can not be setup, the process
            stops
        2.  The controllers, models and views are loaded
        3.  The configuration is read and follows its own setup process
        
        """
        self.meta_datas = self.read_meta_datas()
        
        # Check the bundle requirements
        for requirement in self.meta_datas.requirements:
            if requirement not in server.bundles:
                print("The {} bundle needs the {} one".format(
                        self.name, requirement))
                return False
        
        for plugin_name in self.meta_datas.plugins:
            self.server.plugin_manager.load_plugin(loader, plugin_name)
            self.server.plugin_manager.call("extend_autoloader",
                    self.server, loader)
            self.server.plugin_manager.call_for(plugin_name,
                    "bundle_autoload", self, loader)
        
        # Load the bundle's configuration
        self.config = Config(self.name)
        cfg_setup = self.config.setup(server)
        if not cfg_setup:
            return False
        
        # Load (with the autoloader) the Python modules
        loader.load_modules("controller", \
                "bundles." + self.name + ".controllers")
        loader.load_modules("model", "bundles." + self.name + ".models")
        loader.load_modules("service", "bundles." + self.name + ".services")
        return True
    
    def read_meta_datas(self):
        """Read the meta datas."""
        path = "bundles/" + self.name + "/bundle.yml"
        if not os.path.exists(path):
            raise ValueError("the meta-datas of the {} bundle can't " \
                    "be found in {}".format(self.name, path))
        
        if not os.access(path, os.R_OK):
            raise ValueError("the meta-datas of the {} bundle can't " \
                    "be read in {}".format(self.name, path))
        
        with open(path, "r") as meta_file:
            meta_dict = yaml.load(meta_file)
        
        return MetaDatas(self.name, meta_dict)