Convert between export formats.

STUD-1196

cms/djangoapps/contentstore/management/commands/export_convert_format.py

@@ -0,0 +1,71 @@
+"""
+Script for converting a tar.gz file representing an exported course
+to the archive format used by a different version of export.
+
+Sample invocation: ./manage.py export_convert_format mycourse.tar.gz ~/newformat/
+"""
+import os
+from path import path
+from django.core.management.base import BaseCommand, CommandError
+
+from tempfile import mkdtemp
+import tarfile
+import shutil
+from extract_tar import safetar_extractall
+
+from xmodule.modulestore.xml_exporter import convert_between_versions
+
+
+class Command(BaseCommand):
+    """
+    Convert between export formats.
+    """
+    help = 'Convert between versions 0 and 1 of the course export format'
+    args = '<tar.gz archive file> <output path>'
+
+    def handle(self, *args, **options):
+        "Execute the command"
+        if len(args) != 2:
+            raise CommandError("export requires two arguments: <tar.gz file> <output path>")
+
+        source_archive = args[0]
+        output_path = args[1]
+
+        # Create temp directories to extract the source and create the target archive.
+        temp_source_dir = mkdtemp()
+        temp_target_dir = mkdtemp()
+        try:
+            extract_source(source_archive, temp_source_dir)
+
+            desired_version = convert_between_versions(temp_source_dir, temp_target_dir)
+
+            # New zip up the target directory.
+            parts = os.path.basename(source_archive).split('.')
+            archive_name = path(output_path) / "{source_name}_version_{desired_version}.tar.gz".format(
+                source_name=parts[0], desired_version=desired_version
+            )
+            with open(archive_name, "w"):
+                tar_file = tarfile.open(archive_name, mode='w:gz')
+                try:
+                    for item in os.listdir(temp_target_dir):
+                        tar_file.add(path(temp_target_dir) / item, arcname=item)
+
+                finally:
+                    tar_file.close()
+
+            print("Created archive {0}".format(archive_name))
+
+        except ValueError as err:
+            raise CommandError(err)
+
+        finally:
+            shutil.rmtree(temp_source_dir)
+            shutil.rmtree(temp_target_dir)
+
+
+def extract_source(source_archive, target):
+    """
+    Extract the archive into the given target directory.
+    """
+    with tarfile.open(source_archive) as tar_file:
+        safetar_extractall(tar_file, target)

cms/djangoapps/contentstore/management/commands/tests/test_export_convert_format.py

@@ -0,0 +1,65 @@
+"""
+Test for export_convert_format.
+"""
+from unittest import TestCase
+from django.core.management import call_command, CommandError
+from tempfile import mkdtemp
+import shutil
+from path import path
+from contentstore.management.commands.export_convert_format import Command, extract_source
+from xmodule.tests.helpers import directories_equal
+
+
+class ConvertExportFormat(TestCase):
+    """
+    Tests converting between export formats.
+    """
+    def setUp(self):
+        """ Common setup. """
+        self.temp_dir = mkdtemp()
+        self.data_dir = path(__file__).realpath().parent / 'data'
+        self.version0 = self.data_dir / "Version0_drafts.tar.gz"
+        self.version1 = self.data_dir / "Version1_drafts.tar.gz"
+
+        self.command = Command()
+
+    def tearDown(self):
+        """ Common cleanup. """
+        shutil.rmtree(self.temp_dir)
+
+    def test_no_args(self):
+        """ Test error condition of no arguments. """
+        errstring = "export requires two arguments"
+        with self.assertRaisesRegexp(CommandError, errstring):
+            self.command.handle()
+
+    def test_version1_archive(self):
+        """
+        Smoke test for creating a version 1 archive from a version 0.
+        """
+        call_command('export_convert_format', self.version0, self.temp_dir)
+        output = path(self.temp_dir) / 'Version0_drafts_version_1.tar.gz'
+        self.assertTrue(self._verify_archive_equality(output, self.version1))
+
+    def test_version0_archive(self):
+        """
+        Smoke test for creating a version 0 archive from a version 1.
+        """
+        call_command('export_convert_format', self.version1, self.temp_dir)
+        output = path(self.temp_dir) / 'Version1_drafts_version_0.tar.gz'
+        self.assertTrue(self._verify_archive_equality(output, self.version0))
+
+    def _verify_archive_equality(self, file1, file2):
+        """
+        Helper function for determining if 2 archives are equal.
+        """
+        temp_dir_1 = mkdtemp()
+        temp_dir_2 = mkdtemp()
+        try:
+            extract_source(file1, temp_dir_1)
+            extract_source(file2, temp_dir_2)
+            return directories_equal(temp_dir_1, temp_dir_2)
+
+        finally:
+            shutil.rmtree(temp_dir_1)
+            shutil.rmtree(temp_dir_2)