コード例 #1
0
    def __init__(self, output_path, all_configs=None):
        # We want to make sure to construct only one copy of each config, even
        # if configs refer to each other or multiple configs refer to a shared
        # config.  So, all_configs maps names to configs that we have already
        # constructed.
        if all_configs is None:
            # Note that if we just make all_configs default to {} in the method
            # signature, then Python will create a single empty map to use as the
            # default value for all calls rather than create a new one every call.
            # Since we modify all_configs during this method, we would be modifying
            # the shared default value, which would be bad.  If you don't understand
            # what I mean, try typing the following into the interpreter and then
            # calling it several times with no argument:
            #   def f(l = []):
            #     l.append("foo")
            #     return l
            # Ouchies.
            all_configs = {}
        if output_path is None:
            all_configs[""] = self
        else:
            all_configs[output_path] = self

        self.name = output_path
        self.source_dir = DiskDirectory(".")
        if output_path is None:
            self.output_dir = self.source_dir
        else:
            self.source_dir.mkdir(output_path)
            self.output_dir = DiskDirectory(output_path)
        self.mem_dir = VirtualDirectory()
        self.env_dir = VirtualDirectory()
        _restore_pickle(self.mem_dir, self.output_dir, "mem.pickle")
        _restore_pickle(self.env_dir, self.output_dir, "env.pickle")
        self.alt_configs = {}
        self.__make_root_dir()

        self.alt_configs["host"] = self

        if self.env_dir.exists("$mappings"):
            mappings = self.env_dir.read("$mappings").split(":")
            for mapping in mappings:
                if mapping == "":
                    continue
                alias, name = mapping.split("=", 1)
                if name in all_configs:
                    self.alt_configs[alias] = all_configs[name]
                else:
                    if name == "":
                        name = None
                    self.alt_configs[alias] = Configuration(name, all_configs)
コード例 #2
0
    def clean(self, expunge=False):
        for dir in ["tmp", "bin", "lib", "share", "include", "mem", "env"]:
            if self.root_dir.exists(dir):
                shutil.rmtree(self.root_dir.get_disk_path(dir))

        for file in ["mem.pickle", "env.pickle"]:
            if self.root_dir.exists(file):
                os.remove(self.root_dir.get_disk_path(file))

        self.mem_dir = VirtualDirectory()

        if expunge:
            # Try to remove the output directory itself -- will fail if not empty.
            outdir = self.root_dir.get_disk_path(".")
            if outdir.endswith("/."):
                # rmdir doesn't like a trailing "/.".
                outdir = outdir[:-2]
            try:
                os.rmdir(outdir)
            except os.error:
                pass
        else:
            # Restore the parts of env.pickle that were set explicitly.
            new_env_dir = VirtualDirectory()

            if self.env_dir.exists("$mappings"):
                new_env_dir.write("$mappings", self.env_dir.read("$mappings"))
            if self.env_dir.exists("$config"):
                locked_vars = self.env_dir.read("$config")
                new_env_dir.write("$config", locked_vars)

                for var in locked_vars.split(","):
                    if var != "":
                        new_env_dir.write(var, self.env_dir.read(var))
                        new_env_dir.write("set/" + var,
                                          self.env_dir.read("set/" + var))

            self.env_dir = new_env_dir

        self.__make_root_dir()
コード例 #3
0
ファイル: command_test.py プロジェクト: sholiday/cvenv
    def testEnvironmentCommandWithDefault(self):
        bar = Artifact("env/BAR", None)
        bar_set = Artifact("env/set/BAR", None)
        default = Artifact("default", None)
        output = Artifact("foo", None)
        command = EnvironmentCommand(MockRuleContext(bar, bar_set), "BAR",
                                     output, default)

        enumerator = MockArtifactEnumerator({bar_set: "false"})
        command.enumerate_artifacts(enumerator)
        self.assertEquals([bar_set], enumerator.reads)
        self.assertEquals([default], enumerator.inputs)
        self.assertEquals([output], enumerator.outputs)

        enumerator = MockArtifactEnumerator({bar_set: "true"})
        command.enumerate_artifacts(enumerator)
        self.assertEquals([bar_set], enumerator.reads)
        self.assertEquals([bar], enumerator.inputs)
        self.assertEquals([output], enumerator.outputs)

        dir = VirtualDirectory()
        dir.write("env/set/BAR", "true")
        dir.write("env/BAR", "baz")
        context = MockCommandContext(dir)
        log = cStringIO.StringIO()
        self.assertTrue(command.run(context, log))
        self.assertEquals("baz", dir.read("foo"))
        self.assertEquals("", log.getvalue())

        dir = VirtualDirectory()
        dir.write("env/set/BAR", "false")
        dir.write("default", "qux")
        context = MockCommandContext(dir)
        log = cStringIO.StringIO()
        self.assertTrue(command.run(context, log))
        self.assertEquals("qux", dir.read("foo"))
        self.assertEquals("", log.getvalue())

        self.assertEquals("echo ${BAR:$(default)} > foo\n",
                          _print_command(command))
コード例 #4
0
ファイル: command_test.py プロジェクト: sholiday/cvenv
    def testEchoCommand(self):
        dir = VirtualDirectory()
        output = Artifact("foo", None)
        command = EchoCommand("bar", output)

        enumerator = MockArtifactEnumerator()
        command.enumerate_artifacts(enumerator)
        self.assertEquals([], enumerator.reads)
        self.assertEquals([], enumerator.inputs)
        self.assertEquals([output], enumerator.outputs)

        context = MockCommandContext(dir)
        log = cStringIO.StringIO()
        self.assertTrue(command.run(context, log))
        self.assertEquals("bar", dir.read("foo"))
        self.assertEquals("", log.getvalue())

        self.assertEquals("echo 'bar' > foo\n", _print_command(command))
コード例 #5
0
ファイル: command_test.py プロジェクト: sholiday/cvenv
    def testDoAllCommand(self):
        dir = VirtualDirectory()

        inputs = [Artifact("input1", None), Artifact("input2", None)]
        outputs = [Artifact("output1", None), Artifact("output2", None)]

        mock_command1 = MockCommand("command1", inputs[:1], outputs[:1])
        mock_command2 = MockCommand("command2", inputs[1:], outputs[1:])
        command = DoAllCommand([mock_command1, mock_command2])

        enumerator = MockArtifactEnumerator()
        command.enumerate_artifacts(enumerator)
        self.assertEquals([], enumerator.reads)
        self.assertEquals(inputs, enumerator.inputs)
        self.assertEquals(outputs, enumerator.outputs)

        context = MockCommandContext(dir)
        log = cStringIO.StringIO()
        self.assertTrue(command.run(context, log))
        self.assertEquals(
            "Ran MockCommand command1\n"
            "Ran MockCommand command2\n", log.getvalue())

        mock_command2.fails = True
        log = cStringIO.StringIO()
        self.assertFalse(command.run(context, log))
        self.assertEquals(
            "Ran MockCommand command1\n"
            "Ran MockCommand command2\n", log.getvalue())

        mock_command1.fails = True
        log = cStringIO.StringIO()
        self.assertFalse(command.run(context, log))
        self.assertEquals("Ran MockCommand command1\n", log.getvalue())

        self.assertEquals("mock_command command1\n"
                          "mock_command command2\n", _print_command(command))
コード例 #6
0
ファイル: command_test.py プロジェクト: sholiday/cvenv
    def testEnvironmentCommand(self):
        dir = VirtualDirectory()
        bar = Artifact("env/BAR", None)
        bar_set = Artifact("env/set/BAR", None)
        output = Artifact("foo", None)
        command = EnvironmentCommand(MockRuleContext(bar, bar_set), "BAR",
                                     output)

        enumerator = MockArtifactEnumerator({bar_set: "false"})
        command.enumerate_artifacts(enumerator)
        self.assertEquals([bar_set], enumerator.reads)
        self.assertEquals([], enumerator.inputs)
        self.assertEquals([output], enumerator.outputs)

        enumerator = MockArtifactEnumerator({bar_set: "true"})
        command.enumerate_artifacts(enumerator)
        self.assertEquals([bar_set], enumerator.reads)
        self.assertEquals([bar], enumerator.inputs)
        self.assertEquals([output], enumerator.outputs)

        context = MockCommandContext(dir)

        dir.write("env/set/BAR", "false")
        log = cStringIO.StringIO()
        self.assertFalse(command.run(context, log))
        self.assertFalse(dir.exists("foo"))
        self.assertEquals("Environment variable not set: BAR\n",
                          log.getvalue())

        dir.write("env/set/BAR", "true")
        dir.write("env/BAR", "baz")
        log = cStringIO.StringIO()
        self.assertTrue(command.run(context, log))
        self.assertEquals("baz", dir.read("foo"))
        self.assertEquals("", log.getvalue())

        self.assertEquals("echo $BAR > foo\n", _print_command(command))
コード例 #7
0
 def setUp(self):
   self.dir = VirtualDirectory()
   self.loader = Loader(self.dir)
コード例 #8
0
ファイル: builder_test.py プロジェクト: sholiday/cvenv
 def setUp(self):
     self.dir = VirtualDirectory()
     self.context = MockContext("mock.sebs", "src/mock.sebs")
     self.rule = Rule(self.context)
     self.console = make_console(cStringIO.StringIO())  # ignore output
コード例 #9
0
ファイル: filesystem_test.py プロジェクト: sholiday/cvenv
 def setUp(self):
     self.virtual_dir = VirtualDirectory()
     self.dir = MappedDirectory(
         MappedDirectoryTest.MappingImpl("mapped_prefix", self.virtual_dir))
     super(MappedDirectoryTest, self).setUp()
コード例 #10
0
ファイル: filesystem_test.py プロジェクト: sholiday/cvenv
 def setUp(self):
     self.dir = VirtualDirectory()
     super(VirtualDirectoryTest, self).setUp()
コード例 #11
0
ファイル: command_test.py プロジェクト: sholiday/cvenv
 def setUp(self):
     self.__action = Action(None, "dummy", "dummy")
     self.__artifact = Artifact("filename", None)
     self.__dir = VirtualDirectory()
コード例 #12
0
ファイル: command_test.py プロジェクト: sholiday/cvenv
    def testConditionalCommandWithNoElse(self):
        dir = VirtualDirectory()

        inputs = [Artifact("input1", None), Artifact("input2", None)]
        outputs = [Artifact("output1", None), Artifact("output2", None)]
        condition = Artifact("condition", None)

        mock_command1 = MockCommand("command1", inputs[:1], outputs[:1])
        command = ConditionalCommand(condition, mock_command1)

        enumerator = MockArtifactEnumerator()
        command.enumerate_artifacts(enumerator)
        self.assertEquals([condition], enumerator.reads)
        self.assertEquals([], enumerator.inputs)
        self.assertEquals([], enumerator.outputs)

        enumerator = MockArtifactEnumerator({condition: "true"})
        command.enumerate_artifacts(enumerator)
        self.assertEquals([condition], enumerator.reads)
        self.assertEquals(inputs[:1], enumerator.inputs)
        self.assertEquals(outputs[:1], enumerator.outputs)

        enumerator = MockArtifactEnumerator({condition: "false"})
        command.enumerate_artifacts(enumerator)
        self.assertEquals([condition], enumerator.reads)
        self.assertEquals([], enumerator.inputs)
        self.assertEquals([], enumerator.outputs)

        enumerator = MockArtifactEnumerator({condition: "blah"})
        command.enumerate_artifacts(enumerator)
        self.assertEquals([condition], enumerator.reads)
        self.assertEquals([], enumerator.inputs)
        self.assertEquals([], enumerator.outputs)

        context = MockCommandContext(dir)

        dir.write("condition", "true")
        log = cStringIO.StringIO()
        self.assertTrue(command.run(context, log))
        self.assertEquals("Ran MockCommand command1\n", log.getvalue())

        mock_command1.fails = True
        log = cStringIO.StringIO()
        self.assertFalse(command.run(context, log))
        self.assertEquals("Ran MockCommand command1\n", log.getvalue())

        dir.write("condition", "false")
        log = cStringIO.StringIO()
        self.assertTrue(command.run(context, log))
        self.assertEquals("", log.getvalue())

        dir.write("condition", "blah")
        log = cStringIO.StringIO()
        self.assertFalse(command.run(context, log))
        self.assertEquals(
            "Condition artifact was not true or false: %s\n" % condition,
            log.getvalue())

        self.assertEquals("if condition {\n"
                          "  mock_command command1\n"
                          "}\n", _print_command(command))