Python SplitMigrator.migrate_mongo_course方法代码示例

# 需要导入模块: from xmodule.modulestore.split_migrator import SplitMigrator [as 别名]
# 或者: from xmodule.modulestore.split_migrator.SplitMigrator import migrate_mongo_course [as 别名]
    def clone_course(self, source_course_id, dest_course_id, user_id):
        """
        See the superclass for the general documentation.

        If cloning w/in a store, delegates to that store's clone_course which, in order to be self-
        sufficient, should handle the asset copying (call the same method as this one does)
        If cloning between stores,
            * copy the assets
            * migrate the courseware
        """
        source_modulestore = self._get_modulestore_for_courseid(source_course_id)
        # for a temporary period of time, we may want to hardcode dest_modulestore as split if there's a split
        # to have only course re-runs go to split. This code, however, uses the config'd priority
        dest_modulestore = self._get_modulestore_for_courseid(dest_course_id)
        if source_modulestore == dest_modulestore:
            return source_modulestore.clone_course(source_course_id, dest_course_id, user_id)

        # ensure super's only called once. The delegation above probably calls it; so, don't move
        # the invocation above the delegation call
        super(MixedModuleStore, self).clone_course(source_course_id, dest_course_id, user_id)

        if dest_modulestore.get_modulestore_type() == ModuleStoreEnum.Type.split:
            split_migrator = SplitMigrator(dest_modulestore, source_modulestore)
            split_migrator.migrate_mongo_course(
                source_course_id, user_id, dest_course_id.org, dest_course_id.course, dest_course_id.run
            )

# 需要导入模块: from xmodule.modulestore.split_migrator import SplitMigrator [as 别名]
# 或者: from xmodule.modulestore.split_migrator.SplitMigrator import migrate_mongo_course [as 别名]
    def handle(self, *args, **options):
        course_key, user, org, course, run = self.parse_args(*args)

        migrator = SplitMigrator(
            source_modulestore=modulestore(),
            split_modulestore=modulestore()._get_modulestore_by_type(ModuleStoreEnum.Type.split),
        )

        migrator.migrate_mongo_course(course_key, user, org, course, run)

# 需要导入模块: from xmodule.modulestore.split_migrator import SplitMigrator [as 别名]
# 或者: from xmodule.modulestore.split_migrator.SplitMigrator import migrate_mongo_course [as 别名]
    def handle(self, *args, **options):
        course_key, user, org, offering = self.parse_args(*args)

        migrator = SplitMigrator(
            draft_modulestore=modulestore()._get_modulestore_by_type(ModuleStoreEnum.Type.mongo),
            split_modulestore=modulestore()._get_modulestore_by_type(ModuleStoreEnum.Type.split),
            loc_mapper=loc_mapper(),
        )

        migrator.migrate_mongo_course(course_key, user, org, offering)

# 需要导入模块: from xmodule.modulestore.split_migrator import SplitMigrator [as 别名]
# 或者: from xmodule.modulestore.split_migrator.SplitMigrator import migrate_mongo_course [as 别名]
    def handle(self, *args, **options):
        location, user, package_id = self.parse_args(*args)

        migrator = SplitMigrator(
            draft_modulestore=modulestore('default'),
            direct_modulestore=modulestore('direct'),
            split_modulestore=modulestore('split'),
            loc_mapper=loc_mapper(),
        )

        migrator.migrate_mongo_course(location, user, package_id)

# 需要导入模块: from xmodule.modulestore.split_migrator import SplitMigrator [as 别名]
# 或者: from xmodule.modulestore.split_migrator.SplitMigrator import migrate_mongo_course [as 别名]
    def handle(self, *args, **options):
        course_key, user, org, offering = self.parse_args(*args)

        migrator = SplitMigrator(
            draft_modulestore=modulestore('default'),
            direct_modulestore=modulestore('direct'),
            split_modulestore=modulestore('split'),
            loc_mapper=loc_mapper(),
        )

        migrator.migrate_mongo_course(course_key, user, org, offering)

# 需要导入模块: from xmodule.modulestore.split_migrator import SplitMigrator [as 别名]
# 或者: from xmodule.modulestore.split_migrator.SplitMigrator import migrate_mongo_course [as 别名]
    def setUp(self):
        super(TestRollbackSplitCourse, self).setUp()
        self.old_course = CourseFactory()
        uname = 'testuser'
        email = '[email protected]'
        password = 'foo'
        self.user = User.objects.create_user(uname, email, password)

        # migrate old course to split
        migrator = SplitMigrator(
            draft_modulestore=modulestore()._get_modulestore_by_type(ModuleStoreEnum.Type.mongo),
            split_modulestore=modulestore()._get_modulestore_by_type(ModuleStoreEnum.Type.split),
            loc_mapper=loc_mapper(),
        )
        migrator.migrate_mongo_course(self.old_course.location, self.user)
        self.course = modulestore('split').get_course(self.old_course.id)

# 需要导入模块: from xmodule.modulestore.split_migrator import SplitMigrator [as 别名]
# 或者: from xmodule.modulestore.split_migrator.SplitMigrator import migrate_mongo_course [as 别名]
    def setUp(self):
        super(TestRollbackSplitCourse, self).setUp()
        self.old_course = CourseFactory()
        uname = "testuser"
        email = "[email protected]"
        password = "foo"
        self.user = User.objects.create_user(uname, email, password)

        # migrate old course to split
        migrator = SplitMigrator(
            draft_modulestore=modulestore("default"),
            direct_modulestore=modulestore("direct"),
            split_modulestore=modulestore("split"),
            loc_mapper=loc_mapper(),
        )
        migrator.migrate_mongo_course(self.old_course.location, self.user)
        self.course = modulestore("split").get_course(self.old_course.id)

# 需要导入模块: from xmodule.modulestore.split_migrator import SplitMigrator [as 别名]
# 或者: from xmodule.modulestore.split_migrator.SplitMigrator import migrate_mongo_course [as 别名]
    def setUp(self):
        super(TestRollbackSplitCourse, self).setUp()
        self.old_course = CourseFactory()
        uname = 'testuser'
        email = '[email protected]'
        password = 'foo'
        self.user = User.objects.create_user(uname, email, password)

        # migrate old course to split
        migrator = SplitMigrator(
            draft_modulestore=modulestore('default'),
            direct_modulestore=modulestore('direct'),
            split_modulestore=modulestore('split'),
            loc_mapper=loc_mapper(),
        )
        migrator.migrate_mongo_course(self.old_course.location, self.user)
        locator = loc_mapper().translate_location(self.old_course.id, self.old_course.location)
        self.course = modulestore('split').get_course(locator)

# 需要导入模块: from xmodule.modulestore.split_migrator import SplitMigrator [as 别名]
# 或者: from xmodule.modulestore.split_migrator.SplitMigrator import migrate_mongo_course [as 别名]

#.........这里部分代码省略.........
            draft=False, split=False
        )
        self._create_item(
            indirect2_loc.category, indirect2_loc.name, {'data': ""}, {'display_name': 'conditional show 2'},
            conditional_loc.category, conditional_loc.name,
            draft=False, split=False
        )

        # add direct children
        self.create_random_units(False, conditional_loc)

        # and the ancillary docs (not children)
        self._create_item(
            'static_tab', uuid.uuid4().hex, {'data': ""}, {'display_name': 'Tab uno'},
            None, None, draft=False, split=False
        )
        self._create_item(
            'about', 'overview', {'data': "<p>test</p>"}, {},
            None, None, draft=False, split=False
        )
        self._create_item(
            'course_info', 'updates', {'data': "<ol><li><h2>Sep 22</h2><p>test</p></li></ol>"}, {},
            None, None, draft=False, split=False
        )

    def create_random_units(self, draft, parent_loc):
        """
        Create a random selection of units under the given parent w/ random names & attrs
        :param store: which store (e.g., direct/draft) to create them in
        :param parent: the parent to have point to them
        (only makes sense if store is 'direct' and this is 'draft' or vice versa)
        """
        for _ in range(random.randrange(6)):
            location = parent_loc.replace(
                category=random.choice(['html', 'video', 'problem', 'discussion']),
                name=uuid.uuid4().hex
            )
            metadata = {'display_name': str(uuid.uuid4()), 'graded': True}
            data = {}
            self._create_item(
                location.category, location.name, data, metadata, parent_loc.category, parent_loc.name,
                draft=draft, split=False
            )

    def compare_courses(self, presplit, published):
        # descend via children to do comparison
        old_root = presplit.get_course(self.old_course_key)
        new_root_locator = self.loc_mapper.translate_location_to_course_locator(
            old_root.id, published
        )
        new_root = self.split_mongo.get_course(new_root_locator)
        self.compare_dags(presplit, old_root, new_root, published)

        # grab the detached items to compare they should be in both published and draft
        for category in ['conditional', 'about', 'course_info', 'static_tab']:
            for conditional in presplit.get_items(self.old_course_key, category=category):
                locator = self.loc_mapper.translate_location(
                    conditional.location,
                    published,
                    add_entry_if_missing=False
                )
                self.compare_dags(presplit, conditional, self.split_mongo.get_item(locator), published)

    def compare_dags(self, presplit, presplit_dag_root, split_dag_root, published):
        # check that locations match
        self.assertEqual(
            presplit_dag_root.location,
            self.loc_mapper.translate_locator_to_location(split_dag_root.location).replace(
                revision=MongoRevisionKey.published
            )
        )
        # compare all fields but children
        for name, field in presplit_dag_root.fields.iteritems():
            if not isinstance(field, (Reference, ReferenceList, ReferenceValueDict)):
                self.assertEqual(
                    getattr(presplit_dag_root, name),
                    getattr(split_dag_root, name),
                    "{}/{}: {} != {}".format(
                        split_dag_root.location, name, getattr(presplit_dag_root, name), getattr(split_dag_root, name)
                    )
                )

        # compare children
        if presplit_dag_root.has_children:
            self.assertEqual(
                # need get_children to filter out drafts
                len(presplit_dag_root.get_children()), len(split_dag_root.children),
                "{0.category} '{0.display_name}': children  {1} != {2}".format(
                    presplit_dag_root, presplit_dag_root.children, split_dag_root.children
                )
            )
            for pre_child, split_child in zip(presplit_dag_root.get_children(), split_dag_root.get_children()):
                self.compare_dags(presplit, pre_child, split_child, published)

    def test_migrator(self):
        user = mock.Mock(id=1)
        self.migrator.migrate_mongo_course(self.old_course_key, user)
        # now compare the migrated to the original course
        self.compare_courses(self.old_mongo, True)
        self.compare_courses(self.draft_mongo, False)

# 需要导入模块: from xmodule.modulestore.split_migrator import SplitMigrator [as 别名]
# 或者: from xmodule.modulestore.split_migrator.SplitMigrator import migrate_mongo_course [as 别名]

#.........这里部分代码省略.........
        )
        # create the children
        self._create_item(
            indirect1_loc.block_type, indirect1_loc.block_id, {'data': ""}, {'display_name': 'conditional show 1'},
            conditional_loc.block_type, conditional_loc.block_id,
            draft=False, split=False
        )
        self._create_item(
            indirect2_loc.block_type, indirect2_loc.block_id, {'data': ""}, {'display_name': 'conditional show 2'},
            conditional_loc.block_type, conditional_loc.block_id,
            draft=False, split=False
        )

        # add direct children
        self.create_random_units(False, conditional_loc)

        # and the ancillary docs (not children)
        self._create_item(
            'static_tab', uuid.uuid4().hex, {'data': ""}, {'display_name': 'Tab uno'},
            None, None, draft=False, split=False
        )
        self._create_item(
            'about', 'overview', {'data': "<p>test</p>"}, {},
            None, None, draft=False, split=False
        )
        self._create_item(
            'course_info', 'updates', {'data': "<ol><li><h2>Sep 22</h2><p>test</p></li></ol>"}, {},
            None, None, draft=False, split=False
        )

    def create_random_units(self, draft, parent_loc):
        """
        Create a random selection of units under the given parent w/ random names & attrs
        :param store: which store (e.g., direct/draft) to create them in
        :param parent: the parent to have point to them
        (only makes sense if store is 'direct' and this is 'draft' or vice versa)
        """
        for _ in range(random.randrange(6)):
            location = parent_loc.replace(
                category=random.choice(['html', 'video', 'problem', 'discussion']),
                name=uuid.uuid4().hex
            )
            metadata = {'display_name': str(uuid.uuid4()), 'graded': True}
            data = {}
            self._create_item(
                location.block_type, location.block_id, data, metadata, parent_loc.block_type, parent_loc.block_id,
                draft=draft, split=False
            )

    def compare_courses(self, presplit, new_course_key, published):
        # descend via children to do comparison
        old_root = presplit.get_course(self.old_course_key)
        new_root = self.split_mongo.get_course(new_course_key)
        self.compare_dags(presplit, old_root, new_root, published)

        # grab the detached items to compare they should be in both published and draft
        for category in ['conditional', 'about', 'course_info', 'static_tab']:
            for conditional in presplit.get_items(self.old_course_key, qualifiers={'category': category}):
                locator = new_course_key.make_usage_key(category, conditional.location.block_id)
                self.compare_dags(presplit, conditional, self.split_mongo.get_item(locator), published)

    def compare_dags(self, presplit, presplit_dag_root, split_dag_root, published):
        if split_dag_root.category != 'course':
            self.assertEqual(presplit_dag_root.location.block_id, split_dag_root.location.block_id)
        # compare all fields but references
        for name, field in presplit_dag_root.fields.iteritems():
            # fields generated from UNIQUE_IDs are unique to an XBlock's scope,
            # so if such a field is unset on an XBlock, we don't expect it
            # to persist across courses
            field_generated_from_unique_id = not field.is_set_on(presplit_dag_root) and field.default == UNIQUE_ID
            should_check_field = not (
                field_generated_from_unique_id or isinstance(field, (Reference, ReferenceList, ReferenceValueDict))
            )
            if should_check_field:
                self.assertEqual(
                    getattr(presplit_dag_root, name),
                    getattr(split_dag_root, name),
                    u"{}/{}: {} != {}".format(
                        split_dag_root.location, name, getattr(presplit_dag_root, name), getattr(split_dag_root, name)
                    )
                )

        # compare children
        if presplit_dag_root.has_children:
            self.assertEqual(
                # need get_children to filter out drafts
                len(presplit_dag_root.get_children()), len(split_dag_root.children),
                u"{0.category} '{0.display_name}': children  {1} != {2}".format(
                    presplit_dag_root, presplit_dag_root.children, split_dag_root.children
                )
            )
            for pre_child, split_child in zip(presplit_dag_root.get_children(), split_dag_root.get_children()):
                self.compare_dags(presplit, pre_child, split_child, published)

    def test_migrator(self):
        user = mock.Mock(id=1)
        new_course_key = self.migrator.migrate_mongo_course(self.old_course_key, user.id, new_run='new_run')
        # now compare the migrated to the original course
        self.compare_courses(self.draft_mongo, new_course_key, True)  # published
        self.compare_courses(self.draft_mongo, new_course_key, False)  # draft

# 需要导入模块: from xmodule.modulestore.split_migrator import SplitMigrator [as 别名]
# 或者: from xmodule.modulestore.split_migrator.SplitMigrator import migrate_mongo_course [as 别名]

#.........这里部分代码省略.........

        location = location.replace(category='about', name='overview')
        _overview = self._create_and_get_item(self.old_mongo, location, "<p>test</p>", {}, runtime)
        location = location.replace(category='course_info', name='updates')
        _overview = self._create_and_get_item(
            self.old_mongo,
            location, "<ol><li><h2>Sep 22</h2><p>test</p></li></ol>", {}, runtime
        )

    def create_random_units(self, store, parent, cc_store=None, cc_parent=None):
        """
        Create a random selection of units under the given parent w/ random names & attrs
        :param store: which store (e.g., direct/draft) to create them in
        :param parent: the parent to have point to them
        :param cc_store: (optional) if given, make a small change and save also to this store but w/ same location
        (only makes sense if store is 'direct' and this is 'draft' or vice versa)
        """
        for _ in range(random.randrange(6)):
            location = parent.location.replace(
                category=random.choice(['html', 'video', 'problem', 'discussion']),
                name=uuid.uuid4().hex
            )
            metadata = {'display_name': str(uuid.uuid4()), 'graded': True}
            data = {}
            element = self._create_and_get_item(store, location, data, metadata, parent.runtime)
            parent.children.append(element.location.url())
            if cc_store is not None:
                # change display_name and remove graded to test the delta
                element = self._create_and_get_item(
                    cc_store, location, data, {'display_name': str(uuid.uuid4())}, parent.runtime
                )
                cc_parent.children.append(element.location.url())
        store.update_children(parent.location, parent.children)
        if cc_store is not None:
            cc_store.update_children(cc_parent.location, cc_parent.children)

    def compare_courses(self, presplit, published):
        # descend via children to do comparison
        old_root = presplit.get_item(self.course_location, depth=None)
        new_root_locator = self.loc_mapper.translate_location(
            self.course_location.course_id, self.course_location, published, add_entry_if_missing=False
        )
        new_root = self.split_mongo.get_course(new_root_locator)
        self.compare_dags(presplit, old_root, new_root, published)

        # grab the detached items to compare they should be in both published and draft
        for category in ['conditional', 'about', 'course_info', 'static_tab']:
            location = self.course_location.replace(name=None, category=category)
            for conditional in presplit.get_items(location):
                locator = self.loc_mapper.translate_location(
                    self.course_location.course_id,
                    conditional.location, published, add_entry_if_missing=False
                )
                self.compare_dags(presplit, conditional, self.split_mongo.get_item(locator), published)

    def compare_dags(self, presplit, presplit_dag_root, split_dag_root, published):
        # check that locations match
        self.assertEqual(
            presplit_dag_root.location,
            self.loc_mapper.translate_locator_to_location(split_dag_root.location).replace(revision=None)
        )
        # compare all fields but children
        for name in presplit_dag_root.fields.iterkeys():
            if name != 'children':
                self.assertEqual(
                    getattr(presplit_dag_root, name),
                    getattr(split_dag_root, name),
                    "{}/{}: {} != {}".format(
                        split_dag_root.location, name, getattr(presplit_dag_root, name), getattr(split_dag_root, name)
                    )
                )
        # test split get_item using old Location: old draft store didn't set revision for things above vertical
        # but split does distinguish these; so, set revision if not published
        if not published:
            location = draft.as_draft(presplit_dag_root.location)
        else:
            location = presplit_dag_root.location
        refetched = self.split_mongo.get_item(location)
        self.assertEqual(
            refetched.location, split_dag_root.location,
            "Fetch from split via old Location {} not same as new {}".format(
                refetched.location, split_dag_root.location
            )
        )
        # compare children
        if presplit_dag_root.has_children:
            self.assertEqual(
                len(presplit_dag_root.get_children()), len(split_dag_root.get_children()),
                "{0.category} '{0.display_name}': children count {1} != {2}".format(
                    presplit_dag_root, len(presplit_dag_root.get_children()), split_dag_root.children
                )
            )
            for pre_child, split_child in zip(presplit_dag_root.get_children(), split_dag_root.get_children()):
                self.compare_dags(presplit, pre_child, split_child, published)

    def test_migrator(self):
        self.migrator.migrate_mongo_course(self.course_location, random.getrandbits(32))
        # now compare the migrated to the original course
        self.compare_courses(self.old_mongo, True)
        self.compare_courses(self.draft_mongo, False)

# 需要导入模块: from xmodule.modulestore.split_migrator import SplitMigrator [as 别名]
# 或者: from xmodule.modulestore.split_migrator.SplitMigrator import migrate_mongo_course [as 别名]

#.........这里部分代码省略.........
            conditional_loc.name,
            draft=False,
            split=False,
        )

        # add direct children
        self.create_random_units(False, conditional_loc)

        # and the ancillary docs (not children)
        self._create_item(
            "static_tab",
            uuid.uuid4().hex,
            {"data": ""},
            {"display_name": "Tab uno"},
            None,
            None,
            draft=False,
            split=False,
        )
        self._create_item("about", "overview", {"data": "<p>test</p>"}, {}, None, None, draft=False, split=False)
        self._create_item(
            "course_info",
            "updates",
            {"data": "<ol><li><h2>Sep 22</h2><p>test</p></li></ol>"},
            {},
            None,
            None,
            draft=False,
            split=False,
        )

    def create_random_units(self, draft, parent_loc):
        """
        Create a random selection of units under the given parent w/ random names & attrs
        :param store: which store (e.g., direct/draft) to create them in
        :param parent: the parent to have point to them
        (only makes sense if store is 'direct' and this is 'draft' or vice versa)
        """
        for _ in range(random.randrange(6)):
            location = parent_loc.replace(
                category=random.choice(["html", "video", "problem", "discussion"]), name=uuid.uuid4().hex
            )
            metadata = {"display_name": str(uuid.uuid4()), "graded": True}
            data = {}
            self._create_item(
                location.category,
                location.name,
                data,
                metadata,
                parent_loc.category,
                parent_loc.name,
                draft=draft,
                split=False,
            )

    def compare_courses(self, presplit, new_course_key, published):
        # descend via children to do comparison
        old_root = presplit.get_course(self.old_course_key)
        new_root = self.split_mongo.get_course(new_course_key)
        self.compare_dags(presplit, old_root, new_root, published)

        # grab the detached items to compare they should be in both published and draft
        for category in ["conditional", "about", "course_info", "static_tab"]:
            for conditional in presplit.get_items(self.old_course_key, category=category):
                locator = new_course_key.make_usage_key(category, conditional.location.block_id)
                self.compare_dags(presplit, conditional, self.split_mongo.get_item(locator), published)

    def compare_dags(self, presplit, presplit_dag_root, split_dag_root, published):
        if split_dag_root.category != "course":
            self.assertEqual(presplit_dag_root.location.block_id, split_dag_root.location.block_id)
        # compare all fields but references
        for name, field in presplit_dag_root.fields.iteritems():
            if not isinstance(field, (Reference, ReferenceList, ReferenceValueDict)):
                self.assertEqual(
                    getattr(presplit_dag_root, name),
                    getattr(split_dag_root, name),
                    u"{}/{}: {} != {}".format(
                        split_dag_root.location, name, getattr(presplit_dag_root, name), getattr(split_dag_root, name)
                    ),
                )

        # compare children
        if presplit_dag_root.has_children:
            self.assertEqual(
                # need get_children to filter out drafts
                len(presplit_dag_root.get_children()),
                len(split_dag_root.children),
                u"{0.category} '{0.display_name}': children  {1} != {2}".format(
                    presplit_dag_root, presplit_dag_root.children, split_dag_root.children
                ),
            )
            for pre_child, split_child in zip(presplit_dag_root.get_children(), split_dag_root.get_children()):
                self.compare_dags(presplit, pre_child, split_child, published)

    def test_migrator(self):
        user = mock.Mock(id=1)
        new_course_key = self.migrator.migrate_mongo_course(self.old_course_key, user.id, new_run="new_run")
        # now compare the migrated to the original course
        self.compare_courses(self.draft_mongo, new_course_key, True)  # published
        self.compare_courses(self.draft_mongo, new_course_key, False)  # draft