Esempio n. 1
0
 def __init__(self, stream):
     Phase.__init__(self)
     self.stream = stream
     self.schema = None
     self.klass = None
     self.prop = None
     self.in_list = False
Esempio n. 2
0
 def __init__(self, stream):
     Phase.__init__(self)
     self.stream = stream
     self.schema = None
     self.klass = None
     self.prop = None
     self.in_list = False
Esempio n. 3
0
 def __init__(self, store):
     Phase.__init__(self)
     self.store = store
     self.repo = store.repo
     self.commit = None
     self.tree = None
     self.klass = None
     self.uuid = None
     self.schema = None
     self.in_list_property = False
Esempio n. 4
0
 def __init__(self, store):
     Phase.__init__(self)
     self.store = store
     self.repo = store.repo
     self.commit = None
     self.tree = None
     self.klass = None
     self.uuid = None
     self.schema = None
     self.in_list_property = False
Esempio n. 5
0
    def _apply_create_action(self, action, commit, schema, tree):
        # make sure the class of the new object is known in the schema
        self._validate_object_class(action, action.klass, schema)

        with Phase() as phase:
            # make sure properties to be set exist in the new object's class
            self._validate_object_properties(phase, action, schema,
                                             action.klass,
                                             action.properties.keys())

            # make sure none of the properties to set are raw properties
            # as we have separate actions for them
            self._validate_object_properties_not_raw(phase, action, schema,
                                                     action.klass,
                                                     action.properties)

            # validate object references to other actions
            self._validate_action_object_references(phase, action, schema,
                                                    action.klass,
                                                    action.properties)

        uuid = self.store.generate_uuid(commit, action.klass)
        object_tree = self._create_object_tree(schema, action.klass, uuid,
                                               action.properties)

        # build new class tree with the object added
        try:
            class_entry = tree[action.klass]
            class_tree = self.store.repo[class_entry.oid]
            builder = self.store.repo.TreeBuilder(class_tree)
        except KeyError:
            # this is the first object of this class in the commit, create
            # a new tree from scratch
            builder = self.store.repo.TreeBuilder()
        builder.insert(uuid, object_tree.oid, pygit2.GIT_FILEMODE_TREE)
        new_class_oid = builder.write()

        # build and return a new overall store tree
        builder = self.store.repo.TreeBuilder(tree)
        builder.insert(action.klass, new_class_oid, pygit2.GIT_FILEMODE_TREE)
        new_tree_oid = builder.write()
        new_tree = self.store.repo[new_tree_oid]

        # load the updated class from the new tree
        context = loaders.LoaderContext(self.store)
        context.set_tree(new_tree)
        new_class_entry = new_tree[action.klass]
        klass = self.loader.class_in_tree(context, new_class_entry)

        # load the new object from the new tree
        context.set_class(klass)
        context.set_uuid(uuid)
        obj = self.loader.object_in_tree(context)

        return obj, new_tree
Esempio n. 6
0
    def _apply_update_action(self, action, commit, schema, tree):
        # load the object from the commit or from a previous action
        obj = self._validate_and_resolve_target_object(schema, action, commit)

        with Phase() as phase:
            # make sure properties to be set exist in the object's class
            self._validate_object_properties(phase, action, schema,
                                             obj.klass.name,
                                             action.properties.keys())

            # make sure none of the properties to set are raw properties
            # as we have separate actions for them
            self._validate_object_properties_not_raw(phase, action, schema,
                                                     obj.klass.name,
                                                     action.properties)

            # validate object references to other actions
            self._validate_action_object_references(phase, action, schema,
                                                    obj.klass.name,
                                                    action.properties)

        # obtain the class and object tree from the store
        old_class_entry = tree[obj.klass.name]
        old_class_tree = self.store.repo[old_class_entry.oid]
        old_object_entry = old_class_tree[obj.uuid]
        old_object_tree = self.store.repo[old_object_entry.oid]

        # build a new object tree
        object_tree = self._update_object_tree(schema, obj, action.properties,
                                               old_object_tree)

        # build a new class tree with the object changed
        builder = self.store.repo.TreeBuilder(old_class_tree)
        builder.insert(obj.uuid, object_tree.oid, pygit2.GIT_FILEMODE_TREE)
        new_class_oid = builder.write()

        # build and return a new overall store tree
        builder = self.store.repo.TreeBuilder(tree)
        builder.insert(obj.klass.name, new_class_oid, pygit2.GIT_FILEMODE_TREE)
        new_tree_oid = builder.write()
        new_tree = self.store.repo[new_tree_oid]

        # load the updated class from the new tree
        context = loaders.LoaderContext(self.store)
        context.set_tree(new_tree)
        new_class_entry = new_tree[obj.klass.name]
        updated_class = self.loader.class_in_tree(context, new_class_entry)

        # load the updated object from the updated class
        context.set_class(updated_class)
        context.set_uuid(obj.uuid)
        updated_obj = self.loader.object_in_tree(context)

        return updated_obj, new_tree
Esempio n. 7
0
    def _apply_update_raw_property_action(self, action, commit, schema, tree):
        # load the object from the commit or from a previous action
        obj = self._validate_and_resolve_target_object(schema, action, commit)

        with Phase() as phase:
            # make sure the property to be updated exists in the object's class
            self._validate_object_properties(phase, action, schema,
                                             obj.klass.name, [action.property])

            # make sure the property to update is a raw property
            self._validate_object_properties_raw(phase, action, schema,
                                                 obj.klass.name,
                                                 [action.property])

        # build a new object tree
        old_object_entry = tree[obj.klass.name]
        old_object_tree = self.store.repo[old_object_entry.oid]
        object_tree = self._update_raw_property(schema, obj, action.property,
                                                action.content_type,
                                                action.data, old_object_tree)

        # build a new class tree with the object changed
        class_entry = tree[obj.klass.name]
        class_tree = self.store.repo[class_entry.oid]
        builder = self.store.repo.TreeBuilder(class_tree)
        builder.insert(obj.uuid, object_tree.oid, pygit2.GIT_FILEMODE_TREE)
        new_class_oid = builder.write()

        # build and return a new overall store tree
        builder = self.store.repo.TreeBuilder(tree)
        builder.insert(obj.klass.name, new_class_oid, pygit2.GIT_FILEMODE_TREE)
        new_tree_oid = builder.write()
        new_tree = self.store.repo[new_tree_oid]

        # load the updated class from the new tree
        context = loaders.LoaderContext(self.store)
        context.set_tree(new_tree)
        new_class_entry = new_tree[obj.klass.name]
        updated_class = self.loader.class_in_tree(context, new_class_entry)

        # load the updated object from the updated class
        context.set_class(updated_class)
        context.set_uuid(obj.uuid)
        updated_obj = self.loader.object_in_tree(context)

        return updated_obj, new_tree
Esempio n. 8
0
    def _load_register_files(self):
        config_dirs = self._collect_config_dirs()

        filenames = [
            os.path.join(x, 'consonant', 'register.yaml') for x in config_dirs
        ]

        # first phase: load YAML data from register files
        data = []
        with Phase() as phase:
            for filename in filenames:
                if os.path.exists(filename):
                    try:
                        with open(filename) as f:
                            data.append(
                                (filename, yaml.load(f, Loader=yaml.CLoader)))
                    except Exception, e:
                        phase.error(e)
Esempio n. 9
0
class Register(yaml.YAMLObject):
    """Class to access the system and user register."""

    yaml_tag = u'!Register'

    def __init__(self):
        self.schemas = {}
        self.services = {}

        self._load_register_files()

    def _load_register_files(self):
        config_dirs = self._collect_config_dirs()

        filenames = [
            os.path.join(x, 'consonant', 'register.yaml') for x in config_dirs
        ]

        # first phase: load YAML data from register files
        data = []
        with Phase() as phase:
            for filename in filenames:
                if os.path.exists(filename):
                    try:
                        with open(filename) as f:
                            data.append(
                                (filename, yaml.load(f, Loader=yaml.CLoader)))
                    except Exception, e:
                        phase.error(e)

        # second phase: validate the data
        with Phase() as phase:
            for filename, data in data:
                schemas = data.get('schemas', {})

                if not isinstance(schemas, dict):
                    phase.error(
                        RegisterFormatError(
                            filename,
                            'Schemas are not specified as a dictionary'))

                for key, val in schemas.iteritems():
                    if not isinstance(key, basestring):
                        phase.error(
                            RegisterFormatError(
                                filename,
                                'Schema name "%s" is not a string' % key))
                    if not expressions.schema_name.match(key):
                        phase.error(
                            RegisterFormatError(
                                filename, 'Schema name "%s" is invalid' % key))
                    if not isinstance(val, basestring):
                        phase.error(
                            RegisterFormatError(
                                filename,
                                'Schema name "%s" is mapped to "%s", '
                                'which is not a string' % (key, val)))

                self.schemas.update(schemas)

                services = data.get('services', {})

                if not isinstance(services, dict):
                    phase.error(
                        RegisterFormatError(
                            filename,
                            'Services are not specified as a dictionary'))

                for key, val in services.iteritems():
                    if not isinstance(key, basestring):
                        phase.error(
                            RegisterFormatError(
                                filename,
                                'Service name "%s" is not a string' % key))
                    if not expressions.service_name.match(key):
                        phase.error(
                            RegisterFormatError(
                                filename,
                                'Service name "%s" is invalid' % key))
                    if not isinstance(val, basestring):
                        phase.error(
                            RegisterFormatError(
                                filename,
                                'Service name "%s" is mapped to "%s", '
                                'which is not a string' % (key, val)))

                self.services.update(services)
Esempio n. 10
0
 def __init__(self):
     Phase.__init__(self)
Esempio n. 11
0
 def __init__(self):
     Phase.__init__(self)
Esempio n. 12
0
 def run():
     with Phase() as phase:
         phase.error(Exception('an error'))
         phase.error(Exception('an absolutely fatal error'), now=True)
         phase.error(Exception('an unreached exception'))
Esempio n. 13
0
 def run():
     with Phase() as phase:
         phase.error(Exception('an error'))
         phase.error(RuntimeError('another error'))
Esempio n. 14
0
 def run():
     with Phase() as phase:
         phase.error(Exception('an error'))
Esempio n. 15
0
    def test_a_phase_with_no_errors_raises_no_exception(self):
        """Verify that a phase with no errors raises no exception."""

        with Phase():
            'somevalue'