Example #1
0
    def testDeselectBadSelect(self):
        script = """
            src     : std.Counter()
            const_5 : std.Constantify(constant=5)
            const_0 : std.Constant(data=0, n=11)
            ds      : std.Deselect()
            snk     : io.StandardOut(store_tokens=1, quiet=1)

            const_0.token > ds.false
            src.integer > ds.true
            const_0.token > const_5.in
            const_5.out > ds.select
            ds.data > snk.token
        """
        app_info, errors, warnings = compiler.compile(script,
                                                      "testDeselectBadSelect")
        print errors
        d = deployer.Deployer(self.rt1, app_info)
        d.deploy()
        time.sleep(0.5)

        snk = d.actor_map['testDeselectBadSelect:snk']
        actual = utils.report(self.rt1, snk)
        expected = [0] * 10

        self.assert_lists_equal(expected, actual, min_length=10)
Example #2
0
    def testEmptyStringTriggerJoin(self):
        datafile = absolute_filename('data.txt')
        script = """
            fname : std.Constant(data="%s")
            src   : io.FileReader()
            join  : text.LineJoin()
            snk   : io.StandardOut(store_tokens=1, quiet=1)

            fname.token > src.filename
            src.out   > join.line
            join.text > snk.token
        """ % (datafile, )
        app_info, errors, warnings = compiler.compile(script,
                                                      "testCustomTriggerJoin")
        d = deployer.Deployer(self.rt1, app_info)
        d.deploy()
        time.sleep(0.5)

        snk = d.actor_map['testCustomTriggerJoin:snk']
        actual = utils.report(self.rt1, snk)
        with open(datafile, "r") as fp:
            expected = [l.rstrip() for l in fp.readlines()]
            expected = ['\n'.join(expected[:10]), '\n'.join(expected[10:])]

        self.assert_lists_equal(expected, actual, min_length=2)
Example #3
0
    def testAppDestructionAllRemote(self):
        script = """
          src : std.CountTimer()
          sum : std.Sum()
          snk : io.StandardOut(store_tokens=1, quiet=1)
          src.integer > sum.integer
          sum.integer > snk.token
          """
        app_info, errors, warnings = compiler.compile(script, "simple")
        d = deployer.Deployer(self.rt1, app_info)
        d.deploy()
        time.sleep(1)
        src = d.actor_map['simple:src']
        csum = d.actor_map['simple:sum']
        snk = d.actor_map['simple:snk']

        utils.migrate(self.rt1, src, self.rt2.id)
        utils.migrate(self.rt1, csum, self.rt2.id)
        utils.migrate(self.rt1, snk, self.rt2.id)
        time.sleep(1)

        actual = utils.report(self.rt2, snk)
        expected = [sum(range(i + 1)) for i in range(1, 10)]
        self.assert_lists_equal(expected, actual)
        utils.delete_application(self.rt1, d.app_id)
        time.sleep(0.5)
        self.assertIsNone(utils.get_actor(self.rt1, src))
        self.assertIsNone(utils.get_actor(self.rt1, csum))
        self.assertIsNone(utils.get_actor(self.rt1, snk))
        self.assertIsNone(utils.get_application(self.rt1, d.app_id))
Example #4
0
    def testDestroyAppWithLocalActors(self):
        rt = self.runtime

        script = """
      src : std.CountTimer()
      snk : io.StandardOut(store_tokens=1)
      src.integer > snk.token
    """
        app_info, errors, warnings = compiler.compile(script, "simple")
        d = deployer.Deployer(rt, app_info)
        app_id = d.deploy()
        time.sleep(0.2)
        src = d.actor_map['simple:src']
        snk = d.actor_map['simple:snk']

        applications = utils.get_applications(rt)
        assert app_id in applications

        d.destroy()

        applications = utils.get_applications(rt)
        assert app_id not in applications

        actors = utils.get_actors(rt)
        assert src not in actors
        assert snk not in actors
Example #5
0
    def testDeselectFalse(self):
        _log.analyze("TESTRUN", "+", {})
        script = """
            src     : std.Counter()
            const_5 : std.Constantify(constant=5)
            const_0 : std.Constant(data=0, n=-1)
            const_1 : std.Constant(data=1, n=-1)
            comp    : std.Compare(op="<=")
            ds      : std.Deselect()
            snk     : io.StandardOut(store_tokens=1, quiet=1)

            const_0.token > ds.case_true
            const_1.token > ds.case_false
            src.integer > comp.a
            src.integer > const_5.in
            const_5.out > comp.b
            comp.result > ds.select
            ds.data > snk.token
        """
        app_info, errors, warnings = compiler.compile(script, "testDeselectFalse")
        print errors
        d = deployer.Deployer(self.rt1, app_info)
        d.deploy()
        time.sleep(0.5)

        snk = d.actor_map['testDeselectFalse:snk']
        actual = utils.report(self.rt1, snk)
        expected = [0] * 5 + [1] * 5

        self.assert_lists_equal(expected, actual, min_length=10)

        d.destroy()
Example #6
0
    def testStringConstantOnCompPort(self):
        _log.analyze("TESTRUN", "+", {})
        script = """
            define MEANING = "42"
            component Foo() -> out {
                i:std.Identity()
                MEANING > i.token
                i.token > .out
            }
            src   : Foo()
            snk   : io.StandardOut(store_tokens=1, quiet=1)
            src.out > snk.token
        """
        app_info, errors, warnings = compiler.compile(script, "testStringConstantOnCompPort")
        print errors
        d = deployer.Deployer(self.rt1, app_info)
        d.deploy()
        time.sleep(.1)

        snk = d.actor_map['testStringConstantOnCompPort:snk']
        actual = utils.report(self.rt1, snk)
        expected = ["42"]*10

        self.assert_lists_equal(expected, actual, min_length=10)

        d.destroy()
Example #7
0
    def testSimpleState(self):
        _log.analyze("TESTRUN", "+", {})
        script = """
          src : std.CountTimer()
          sum : std.Sum()
          snk : io.StandardOut(store_tokens=1, quiet=1)
          src.integer > sum.integer
          sum.integer > snk.token
          """
        app_info, errors, warnings = compiler.compile(script, "simple")
        d = deployer.Deployer(self.rt1, app_info)
        d.deploy()
        time.sleep(1)
        csum = d.actor_map['simple:sum']
        snk = d.actor_map['simple:snk']

        utils.migrate(self.rt1, csum, self.rt2.id)
        time.sleep(1)

        actual = utils.report(self.rt1, snk)
        expected = [sum(range(i+1)) for i in range(1,10)]

        self.assert_lists_equal(expected, actual)

        d.destroy()
Example #8
0
    def testDestroyAppWithLocalActors(self):
        rt = self.runtime

        script = """
      src : std.CountTimer()
      snk : io.StandardOut(store_tokens=1)
      src.integer > snk.token
    """
        app_info, errors, warnings = compiler.compile(script, "simple")
        d = deployer.Deployer(rt, app_info)
        app_id = d.deploy()
        time.sleep(0.2)
        src = d.actor_map['simple:src']
        snk = d.actor_map['simple:snk']

        applications = utils.get_applications(rt)
        assert app_id in applications

        assert d.destroy()['result'] == 'OK'

        applications = utils.get_applications(rt)
        assert app_id not in applications

        actors = utils.get_actors(rt)
        assert src not in actors
        assert snk not in actors
Example #9
0
    def testEmptyStringTriggerJoin(self):
        _log.analyze("TESTRUN", "+", {})
        datafile = absolute_filename('data.txt')
        script = """
            fname : std.Constant(data="%s")
            src   : io.FileReader()
            join  : text.LineJoin()
            snk   : io.StandardOut(store_tokens=1, quiet=1)

            fname.token > src.filename
            src.out   > join.line
            join.text > snk.token
        """ % (datafile, )
        app_info, errors, warnings = compiler.compile(script, "testCustomTriggerJoin")
        d = deployer.Deployer(self.rt1, app_info)
        d.deploy()
        time.sleep(0.5)

        snk = d.actor_map['testCustomTriggerJoin:snk']
        actual = utils.report(self.rt1, snk)
        with open(datafile, "r") as fp:
            expected = [l.rstrip() for l in fp.readlines()]
            expected = ['\n'.join(expected[:10]), '\n'.join(expected[10:])]

        self.assert_lists_equal(expected, actual, min_length=2)

        d.destroy()
Example #10
0
    def testRegexCaptureNoMatch(self):
        _log.analyze("TESTRUN", "+", {})
        script = """
            src   : std.Constant(data="x24.1632", n=1)
            regex : text.RegexMatch(regex=!"(\d+)\.\d+")
            snk   : io.StandardOut(store_tokens=1, quiet=1)
            term  : std.Terminator()

            src.token      > regex.text
            regex.no_match > snk.token
            regex.match    > term.void
        """
        app_info, errors, warnings = compiler.compile(script, "testRegexCaptureNoMatch")
        print errors
        d = deployer.Deployer(self.rt1, app_info)
        d.deploy()
        time.sleep(.1)

        snk = d.actor_map['testRegexCaptureNoMatch:snk']
        actual = utils.report(self.rt1, snk)
        expected = ["x24.1632"]

        self.assert_lists_equal(expected, actual, min_length=1)

        d.destroy()
Example #11
0
    def test31(self):
        # Verify that fanout defined implicitly in scripts is handled correctly
        _log.analyze("TESTRUN", "+", {})
        script = """
            src : std.Counter()
            snk1 : io.StandardOut(store_tokens=1, quiet=1)
            snk2 : io.StandardOut(store_tokens=1, quiet=1)

            src.integer > snk1.token
            src.integer > snk2.token
        """
        app_info, errors, warnings = compiler.compile(script, "test31")
        d = deployer.Deployer(self.rt1, app_info)
        d.deploy()
        time.sleep(0.1)

        snk1 = d.actor_map['test31:snk1']
        snk2 = d.actor_map['test31:snk2']
        actual1 = utils.report(self.rt1, snk1)
        actual2 = utils.report(self.rt1, snk2)
        expected = list(range(1, 10))

        self.assert_lists_equal(expected, actual1)
        self.assert_lists_equal(expected, actual2)

        d.destroy()
Example #12
0
    def testBasicJoin(self):
        _log.analyze("TESTRUN", "+", {})
        datafile = absolute_filename('data.txt')
        script = """
            fname : std.Constant(data="%s")
            src   : io.FileReader()
            join  : text.LineJoin()
            snk   : io.StandardOut(store_tokens=1, quiet=1)

            fname.token > src.filename
            src.out   > join.line
            join.text > snk.token
        """ % (datafile, )
        app_info, errors, warnings = compiler.compile(script, "testBasicJoin")
        print errors
        d = deployer.Deployer(self.rt1, app_info)
        d.deploy()
        time.sleep(1)

        snk = d.actor_map['testBasicJoin:snk']
        actual = utils.report(self.rt1, snk)
        with open(datafile, "r") as fp:
            expected = ["\n".join([l.rstrip() for l in fp.readlines()])]

        self.assert_lists_equal(expected, actual, min_length=1)

        d.destroy()
    def testDeselectFalse(self):
        script = """
            src     : std.Counter()
            const_5 : std.Constantify(constant=5)
            const_0 : std.Constant(data=0, n=-1)
            const_1 : std.Constant(data=1, n=-1)
            comp    : std.Compare(op="<=")
            ds      : std.Deselect()
            snk     : io.StandardOut(store_tokens=1, quiet=1)

            const_0.token > ds.case_true
            const_1.token > ds.case_false
            src.integer > comp.a
            src.integer > const_5.in
            const_5.out > comp.b
            comp.result > ds.select
            ds.data > snk.token
        """
        app_info, errors, warnings = compiler.compile(script, "testDeselectFalse")
        print errors
        d = deployer.Deployer(self.rt1, app_info)
        d.deploy()
        time.sleep(0.5)

        snk = d.actor_map['testDeselectFalse:snk']
        actual = utils.report(self.rt1, snk)
        expected = [0] * 5 + [1] * 5

        self.assert_lists_equal(expected, actual, min_length=10)
Example #14
0
    def testVoidActor(self):
        # Verify that the null port of a std.Void actor behaves as expected
        _log.analyze("TESTRUN", "+", {})
        script = """
            src1 : std.Counter()
            src2 : std.Void()
            join : std.Join()
            snk  : io.StandardOut(store_tokens=1, quiet=1)

            src1.integer > join.token_1
            src2.void > join.token_2
            join.token > snk.token
        """
        app_info, errors, warnings = compiler.compile(script, "testVoidActor")
        print errors
        d = deployer.Deployer(self.rt1, app_info)
        d.deploy()
        time.sleep(0.4)

        snk = d.actor_map['testVoidActor:snk']
        actual = utils.report(self.rt1, snk)
        expected = list(range(1, 10))

        self.assert_lists_equal(expected, actual)

        d.destroy()
Example #15
0
    def testBadSelect(self):
        _log.analyze("TESTRUN", "+", {})
        script = """
            src   : std.Counter()
            const : std.Constant(data=2, n=-1)
            route : std.Select()
            snk   : io.StandardOut(store_tokens=1, quiet=1)
            term  : std.Terminator()

            src.integer > route.data
            const.token > route.select
            route.case_true  > term.void
            route.case_false > snk.token
        """
        app_info, errors, warnings = compiler.compile(script, "testBadSelect")
        print errors
        d = deployer.Deployer(self.rt1, app_info)
        d.deploy()
        time.sleep(0.5)

        snk = d.actor_map['testBadSelect:snk']
        actual = utils.report(self.rt1, snk)
        expected = list(range(1, 10))

        self.assert_lists_equal(expected, actual)

        d.destroy()
Example #16
0
    def testGreaterThanOrEqual(self):
        _log.analyze("TESTRUN", "+", {})
        script = """
            src   : std.Counter()
            const : std.Constant(data=5, n=-1)
            pred  : std.Compare(op=">=")
            snk   : io.StandardOut(store_tokens=1, quiet=1)

            src.integer > pred.a
            const.token > pred.b
            pred.result > snk.token
        """
        app_info, errors, warnings = compiler.compile(script, "testGreaterThanOrEqual")
        print errors
        d = deployer.Deployer(self.rt1, app_info)
        d.deploy()
        time.sleep(0.1)

        snk = d.actor_map['testGreaterThanOrEqual:snk']
        actual = utils.report(self.rt1, snk)
        expected = [x >= 5 for x in range(1, 10)]

        self.assert_lists_equal(expected, actual)

        d.destroy()
Example #17
0
    def testComponentConstantArgumentAsImplicitActor(self):
        _log.analyze("TESTRUN", "+", {})
        script = """
        define FOO = "hup"
        component Count(data) -> seq {
            i : std.Identity()
            data > i.token
            i.token > .seq
        }
        src : Count(data=FOO)
        snk : io.StandardOut(store_tokens=1, quiet=1)
        src.seq > snk.token
        """

        app_info, errors, warnings = compiler.compile(script, "testComponentConstantArgumentAsImplicitActor")
        d = deployer.Deployer(self.rt1, app_info)
        d.deploy()
        time.sleep(.1)

        snk = d.actor_map['testComponentConstantArgumentAsImplicitActor:snk']
        actual = utils.report(self.rt1, snk)
        expected = ["hup"]*10

        self.assert_lists_equal(expected, actual, min_length=10)

        d.destroy()
    def testAppDestructionAllRemote(self):
        script = """
          src : std.CountTimer()
          sum : std.Sum()
          snk : io.StandardOut(store_tokens=1, quiet=1)
          src.integer > sum.integer
          sum.integer > snk.token
          """
        app_info, errors, warnings = compiler.compile(script, "simple")
        d = deployer.Deployer(self.rt1, app_info)
        d.deploy()
        time.sleep(1)
        src = d.actor_map['simple:src']
        csum = d.actor_map['simple:sum']
        snk = d.actor_map['simple:snk']

        utils.migrate(self.rt1, src, self.rt2.id)
        utils.migrate(self.rt1, csum, self.rt2.id)
        utils.migrate(self.rt1, snk, self.rt2.id)
        time.sleep(1)

        actual = utils.report(self.rt2, snk)
        expected = [sum(range(i+1)) for i in range(1,10)]
        self.assert_lists_equal(expected, actual)
        utils.delete_application(self.rt1, d.app_id)
        time.sleep(0.5)
        self.assertIsNone(utils.get_actor(self.rt1, src))
        self.assertIsNone(utils.get_actor(self.rt1, csum))
        self.assertIsNone(utils.get_actor(self.rt1, snk))
        self.assertIsNone(utils.get_application(self.rt1, d.app_id))
Example #19
0
    def testDeselectBadSelect(self):
        _log.analyze("TESTRUN", "+", {})
        script = """
            src     : std.Counter()
            const_5 : std.Constantify(constant=5)
            const_0 : std.Constant(data=0, n=11)
            ds      : std.Deselect()
            snk     : io.StandardOut(store_tokens=1, quiet=1)

            const_0.token > ds.case_false
            src.integer > ds.case_true
            const_0.token > const_5.in
            const_5.out > ds.select
            ds.data > snk.token
        """
        app_info, errors, warnings = compiler.compile(script, "testDeselectBadSelect")
        print errors
        d = deployer.Deployer(self.rt1, app_info)
        d.deploy()
        time.sleep(0.5)

        snk = d.actor_map['testDeselectBadSelect:snk']
        actual = utils.report(self.rt1, snk)
        expected = [0] * 10

        self.assert_lists_equal(expected, actual, min_length=10)

        d.destroy()
Example #20
0
 def handle_deploy(self, handle, connection, match, data, hdr):
     app_info, errors, warnings = compiler.compile(
         data["script"], filename=data["name"])
     app_info["name"] = data["name"]
     d = deployer.Deployer(
         runtime=None, deployable=app_info, node_info=None, node=self.node)
     app_id = d.deploy()
     self.send_response(
         handle, connection, json.dumps({'application_id': app_id, 'actor_map': d.actor_map}))
Example #21
0
 def handle_deploy(self, handle, connection, match, data):
     print "data: ", data
     app_info, errors, warnings = compiler.compile(
         data["script"], filename=data["name"])
     app_info["name"] = data["name"]
     d = deployer.Deployer(
         runtime=None, deployable=app_info, node_info=None, node=self.node)
     app_id = d.deploy()
     self.send_response(
         handle, connection, json.dumps({'application_id': app_id}))
Example #22
0
    def testAppDestructionAllRemote(self):
        _log.analyze("TESTRUN", "+", {})
        script = """
          src : std.CountTimer()
          sum : std.Sum()
          snk : io.StandardOut(store_tokens=1, quiet=1)
          src.integer > sum.integer
          sum.integer > snk.token
          """
        import sys
        from twisted.python import log
        log.startLogging(sys.stdout)

        app_info, errors, warnings = compiler.compile(script, "simple")
        d = deployer.Deployer(self.rt1, app_info)
        d.deploy()
        time.sleep(.2)
        src = d.actor_map['simple:src']
        csum = d.actor_map['simple:sum']
        snk = d.actor_map['simple:snk']

        utils.migrate(self.rt1, src, self.rt2.id)
        utils.migrate(self.rt1, csum, self.rt2.id)
        utils.migrate(self.rt1, snk, self.rt2.id)
        time.sleep(.5)

        actual = utils.report(self.rt2, snk)
        expected = [sum(range(i+1)) for i in range(1,10)]
        self.assert_lists_equal(expected, actual)
        utils.delete_application(self.rt1, d.app_id)

        for a in range(20):
            all_removed = None
            try:
                self.assertIsNone(utils.get_actor(self.rt1, csum))
                self.assertIsNone(utils.get_actor(self.rt1, snk))
                self.assertIsNone(utils.get_actor(self.rt2, src))
                self.assertIsNone(utils.get_actor(self.rt2, csum))
                self.assertIsNone(utils.get_actor(self.rt2, snk))
                self.assertIsNone(utils.get_actor(self.rt3, src))
                self.assertIsNone(utils.get_actor(self.rt3, csum))
                self.assertIsNone(utils.get_actor(self.rt3, snk))
            except AssertionError as e:
                print a, e
                all_removed = e
            if all_removed is None:
                break
            time.sleep(1)

        if all_removed:
            raise all_removed

        self.assertIsNone(utils.get_application(self.rt1, d.app_id))
        self.assertIsNone(utils.get_application(self.rt2, d.app_id))
        self.assertIsNone(utils.get_application(self.rt3, d.app_id))
Example #23
0
    def testDestroyAppWithMigratedActors(self):
        rt = self.runtime
        rt1 = self.runtimes[0]
        rt2 = self.runtimes[1]

        script = """
      src : std.CountTimer()
      snk : io.StandardOut(store_tokens=1)
      src.integer > snk.token
    """
        app_info, errors, warnings = compiler.compile(script, "simple")
        d = deployer.Deployer(rt, app_info)
        app_id = d.deploy()
        time.sleep(1.0)
        src = d.actor_map['simple:src']
        snk = d.actor_map['simple:snk']

        # FIXME --> remove when operating on closed pending connections during migration is fixed
        utils.disable(rt, src)
        utils.disable(rt, snk)
        # <--
        utils.migrate(rt, snk, rt1.id)
        utils.migrate(rt, src, rt2.id)

        applications = utils.get_applications(rt)
        assert app_id in applications

        d.destroy()

        for retry in range(1, 5):
            applications = utils.get_applications(rt)
            if app_id in applications:
                print("Retrying in %s" % (retry * 0.2, ))
                time.sleep(0.2 * retry)
            else :
                break
        assert app_id not in applications

        for retry in range(1, 5):
            actors = []
            actors.extend(utils.get_actors(rt))
            actors.extend(utils.get_actors(rt1))
            actors.extend(utils.get_actors(rt2))
            intersection = [a for a in actors if a in d.actor_map.values()]
            if len(intersection) > 0:
                print("Retrying in %s" % (retry * 0.2, ))
                time.sleep(0.2 * retry)
            else:
                break

        for actor in d.actor_map.values():
            assert actor not in actors
    def testInlineScript(self):
        script = """
          src : std.CountTimer()
          snk : io.StandardOut(store_tokens=1, quiet=1)
          src.integer > snk.token
          """
        app_info, errors, warnings = compiler.compile(script, "simple")
        d = deployer.Deployer(self.rt1, app_info)
        d.deploy()
        time.sleep(1)
        snk = d.actor_map['simple:snk']

        actual = utils.report(self.rt1, (snk))
        self.assert_lists_equal(range(1, 20), actual)
Example #25
0
    def testInlineScript(self):
        script = """
          src : std.CountTimer()
          snk : io.StandardOut(store_tokens=1, quiet=1)
          src.integer > snk.token
          """
        app_info, errors, warnings = compiler.compile(script, "simple")
        d = deployer.Deployer(self.rt1, app_info)
        d.deploy()
        time.sleep(1)
        snk = d.actor_map['simple:snk']

        actual = utils.report(self.rt1, (snk))
        self.assert_lists_equal(range(1, 20), actual)
    def testLiteralOnPort(self):
        script = """
            snk   : io.StandardOut(store_tokens=1, quiet=1)
            42 > snk.token
        """
        app_info, errors, warnings = compiler.compile(script, "testLiteralOnPort")
        print errors
        d = deployer.Deployer(self.rt1, app_info)
        d.deploy()
        time.sleep(.1)

        snk = d.actor_map['testLiteralOnPort:snk']
        actual = utils.report(self.rt1, snk)
        expected = [42]*10

        self.assert_lists_equal(expected, actual, min_length=10)
Example #27
0
    def testLiteralOnPort(self):
        script = """
            snk   : io.StandardOut(store_tokens=1, quiet=1)
            42 > snk.token
        """
        app_info, errors, warnings = compiler.compile(script,
                                                      "testLiteralOnPort")
        print errors
        d = deployer.Deployer(self.rt1, app_info)
        d.deploy()
        time.sleep(.1)

        snk = d.actor_map['testLiteralOnPort:snk']
        actual = utils.report(self.rt1, snk)
        expected = [42] * 10

        self.assert_lists_equal(expected, actual, min_length=10)
Example #28
0
    def testConstant(self):
        script = """
            define FOO = 42
            src   : std.Constant(data=FOO, n=10)
            snk   : io.StandardOut(store_tokens=1, quiet=1)
            src.token > snk.token
        """
        app_info, errors, warnings = compiler.compile(script, "testConstant")
        print errors
        d = deployer.Deployer(self.rt1, app_info)
        d.deploy()
        time.sleep(.1)

        snk = d.actor_map['testConstant:snk']
        actual = utils.report(self.rt1, snk)
        expected = [42] * 10

        self.assert_lists_equal(expected, actual, min_length=10)
    def testConstant(self):
        script = """
            define FOO = 42
            src   : std.Constant(data=FOO, n=10)
            snk   : io.StandardOut(store_tokens=1, quiet=1)
            src.token > snk.token
        """
        app_info, errors, warnings = compiler.compile(script, "testConstant")
        print errors
        d = deployer.Deployer(self.rt1, app_info)
        d.deploy()
        time.sleep(.1)

        snk = d.actor_map['testConstant:snk']
        actual = utils.report(self.rt1, snk)
        expected = [42]*10

        self.assert_lists_equal(expected, actual, min_length=10)
    def testConstantRecursiveOnPort(self):
        script = """
            define FOO = BAR
            define BAR = "yay"
            snk   : io.StandardOut(store_tokens=1, quiet=1)
            FOO > snk.token
        """
        app_info, errors, warnings = compiler.compile(script, "testConstantRecursiveOnPort")
        print errors
        d = deployer.Deployer(self.rt1, app_info)
        d.deploy()
        time.sleep(.1)

        snk = d.actor_map['testConstantRecursiveOnPort:snk']
        actual = utils.report(self.rt1, snk)
        expected = ["yay"]*10

        self.assert_lists_equal(expected, actual, min_length=10)
Example #31
0
    def testConstantRecursiveOnPort(self):
        script = """
            define FOO = BAR
            define BAR = "yay"
            snk   : io.StandardOut(store_tokens=1, quiet=1)
            FOO > snk.token
        """
        app_info, errors, warnings = compiler.compile(
            script, "testConstantRecursiveOnPort")
        print errors
        d = deployer.Deployer(self.rt1, app_info)
        d.deploy()
        time.sleep(.1)

        snk = d.actor_map['testConstantRecursiveOnPort:snk']
        actual = utils.report(self.rt1, snk)
        expected = ["yay"] * 10

        self.assert_lists_equal(expected, actual, min_length=10)
    def test26(self):
        # Same as test20
        script = """
            src : std.Counter()
            ity : std.Identity()
            snk : io.StandardOut(store_tokens=1, quiet=1)

            src.integer > ity.token
            ity.token > snk.token
          """
        app_info, errors, warnings = compiler.compile(script, "simple")
        d = deployer.Deployer(self.rt1, app_info)
        d.deploy()
        time.sleep(0.4)

        snk = d.actor_map['simple:snk']
        actual = utils.report(self.rt1, snk)
        expected = list(range(1, 10))

        self.assert_lists_equal(expected, actual)
Example #33
0
    def testConstantOnPort(self):
        _log.analyze("TESTRUN", "+", {})
        script = """
            define FOO = "Hello"
            snk   : io.StandardOut(store_tokens=1, quiet=1)
            FOO > snk.token
        """
        app_info, errors, warnings = compiler.compile(script, "testConstantOnPort")
        print errors
        d = deployer.Deployer(self.rt1, app_info)
        d.deploy()
        time.sleep(.1)

        snk = d.actor_map['testConstantOnPort:snk']
        actual = utils.report(self.rt1, snk)
        expected = ["Hello"]*10

        self.assert_lists_equal(expected, actual, min_length=10)

        d.destroy()
Example #34
0
    def test26(self):
        # Same as test20
        script = """
            src : std.Counter()
            ity : std.Identity()
            snk : io.StandardOut(store_tokens=1, quiet=1)

            src.integer > ity.token
            ity.token > snk.token
          """
        app_info, errors, warnings = compiler.compile(script, "simple")
        d = deployer.Deployer(self.rt1, app_info)
        d.deploy()
        time.sleep(0.5)

        snk = d.actor_map['simple:snk']
        actual = utils.report(self.rt1, snk)
        expected = list(range(1, 10))

        self.assert_lists_equal(expected, actual)
Example #35
0
    def test11(self):
        _log.analyze("TESTRUN", "+", {})
        # Same as test10, but scripted
        script = """
            src : std.Counter()
            snk : io.StandardOut(store_tokens=1, quiet=1)

            src.integer > snk.token
        """
        app_info, errors, warnings = compiler.compile(script, "simple")
        d = deployer.Deployer(self.rt1, app_info)
        d.deploy()

        time.sleep(0.06)

        snk = d.actor_map['simple:snk']
        actual = utils.report(self.rt1, snk)

        self.assert_lists_equal(range(1, 10), actual)

        d.destroy()
Example #36
0
    def handle_deploy(self, handle, connection, match, data, hdr):
        try:
            _log.analyze(self.node.id, "+", {})
            app_info, errors, warnings = compiler.compile(
                data["script"], filename=data["name"], verify=data["check"] if "check" in data else True)
            _log.analyze(self.node.id, "+ COMPILED", {'app_info': app_info, 'errors': errors, 'warnings': warnings})
            app_info["name"] = data["name"]
            d = deployer.Deployer(
                runtime=None, deployable=app_info, node_info=None, node=self.node,
                verify=data["check"] if "check" in data else True)
            _log.analyze(self.node.id, "+ Deployer instanciated", {})
            app_id = d.deploy()
            _log.analyze(self.node.id, "+ DEPLOYED", {})
            status = calvinresponse.OK
        except:
            app_id = None
            status = calvinresponse.INTERNAL_ERROR

        self.send_response(
            handle, connection, json.dumps({'application_id': app_id, 'actor_map': d.actor_map}) if app_id else None,
            status=status)
    def testTerminatorActor(self):
        # Verify that the null port of a std.Terminator actor behaves as expected
        script = """
            src  : std.Counter()
            term : std.Terminator()
            snk  : io.StandardOut(store_tokens=1, quiet=1)

            src.integer > term.void
            src.integer > snk.token
        """
        app_info, errors, warnings = compiler.compile(script, "testTerminatorActor")
        print errors
        d = deployer.Deployer(self.rt1, app_info)
        d.deploy()
        time.sleep(0.5)

        snk = d.actor_map['testTerminatorActor:snk']
        actual = utils.report(self.rt1, snk)
        expected = list(range(1, 10))

        self.assert_lists_equal(expected, actual)
    def testComponentArgument(self):
        script = """
        component Count(len) -> seq {
            src : std.Constant(data="hup", n=len)
            src.token > .seq
        }
        src : Count(len=5)
        snk : io.StandardOut(store_tokens=1, quiet=1)
        src.seq > snk.token
        """

        app_info, errors, warnings = compiler.compile(script, "testComponentArgument")
        d = deployer.Deployer(self.rt1, app_info)
        d.deploy()
        time.sleep(.1)

        snk = d.actor_map['testComponentArgument:snk']
        actual = utils.report(self.rt1, snk)
        expected = ["hup"]*5

        self.assert_lists_equal(expected, actual, min_length=5)
Example #39
0
    def testRegexMultiCapture(self):
        script = """
            src   : std.Constant(data="24.1632", n=1)
            regex : text.RegexMatch(regex=!"(\d+)\.(\d+)")
            snk   : io.StandardOut(store_tokens=1, quiet=1)
            term  : std.Terminator()

            src.token      > regex.text
            regex.match    > snk.token
            regex.no_match > term.null
        """
        app_info, errors, warnings = compiler.compile(script, "testRegexMultiCapture")
        print errors
        d = deployer.Deployer(self.rt1, app_info)
        d.deploy()
        time.sleep(0.5)

        snk = d.actor_map['testRegexMultiCapture:snk']
        actual = utils.report(self.rt1, snk)
        expected = ["24"]

        self.assert_lists_equal(expected, actual, min_length=1)
    def testBadOp(self):
        script = """
            src   : std.Counter()
            const : std.Constant(data=5, n=-1)
            pred  : std.Compare(op="<>")
            snk   : io.StandardOut(store_tokens=1, quiet=1)

            src.integer > pred.a
            const.token > pred.b
            pred.result > snk.token
        """
        app_info, errors, warnings = compiler.compile(script, "testBadOp")
        print errors
        d = deployer.Deployer(self.rt1, app_info)
        d.deploy()
        time.sleep(.05)

        snk = d.actor_map['testBadOp:snk']
        actual = utils.report(self.rt1, snk)
        expected = [0] * 10

        self.assert_lists_equal(expected, actual)
Example #41
0
    def testComponentArgument(self):
        script = """
        component Count(len) -> seq {
            src : std.Constant(data="hup", n=len)
            src.token > .seq
        }
        src : Count(len=5)
        snk : io.StandardOut(store_tokens=1, quiet=1)
        src.seq > snk.token
        """

        app_info, errors, warnings = compiler.compile(script,
                                                      "testComponentArgument")
        d = deployer.Deployer(self.rt1, app_info)
        d.deploy()
        time.sleep(.1)

        snk = d.actor_map['testComponentArgument:snk']
        actual = utils.report(self.rt1, snk)
        expected = ["hup"] * 5

        self.assert_lists_equal(expected, actual, min_length=5)
Example #42
0
    def testBadOp(self):
        script = """
            src   : std.Counter()
            const : std.Constant(data=5, n=-1)
            pred  : std.Compare(op="<>")
            snk   : io.StandardOut(store_tokens=1, quiet=1)

            src.integer > pred.a
            const.token > pred.b
            pred.result > snk.token
        """
        app_info, errors, warnings = compiler.compile(script, "testBadOp")
        print errors
        d = deployer.Deployer(self.rt1, app_info)
        d.deploy()
        time.sleep(0.5)

        snk = d.actor_map['testBadOp:snk']
        actual = utils.report(self.rt1, snk)
        expected = [0] * 10

        self.assert_lists_equal(expected, actual)
Example #43
0
    def testTerminatorActor(self):
        # Verify that the null port of a std.Terminator actor behaves as expected
        script = """
            src  : std.Counter()
            term : std.Terminator()
            snk  : io.StandardOut(store_tokens=1, quiet=1)

            src.integer > term.null
            src.integer > snk.token
        """
        app_info, errors, warnings = compiler.compile(script,
                                                      "testTerminatorActor")
        print errors
        d = deployer.Deployer(self.rt1, app_info)
        d.deploy()
        time.sleep(0.5)

        snk = d.actor_map['testTerminatorActor:snk']
        actual = utils.report(self.rt1, snk)
        expected = list(range(1, 10))

        self.assert_lists_equal(expected, actual)
    def testLiteralOnCompPort(self):
        script = """
            component Foo() -> out {
                i:std.Stringify()
                42 > i.in
                i.out > .out
            }
            src   : Foo()
            snk   : io.StandardOut(store_tokens=1, quiet=1)
            src.out > snk.token
        """
        app_info, errors, warnings = compiler.compile(script, "testLiteralOnCompPort")
        print errors
        d = deployer.Deployer(self.rt1, app_info)
        d.deploy()
        time.sleep(.1)

        snk = d.actor_map['testLiteralOnCompPort:snk']
        actual = utils.report(self.rt1, snk)
        expected = ["42"]*10

        self.assert_lists_equal(expected, actual, min_length=10)
Example #45
0
    def testCompileSimple(self):
        rt = self.runtime

        script = """
      src : std.CountTimer()
      snk : io.StandardOut(store_tokens=1)
      src.integer > snk.token
    """
        app_info, errors, warnings = compiler.compile(script, "simple")
        d = deployer.Deployer(rt, app_info)
        d.deploy()  # ignoring app_id here
        time.sleep(0.2)
        src = d.actor_map['simple:src']
        snk = d.actor_map['simple:snk']

        utils.disconnect(rt, src)

        actual = actual_tokens(rt, snk)
        expected = expected_tokens(rt, src, 'std.CountTimer')

        self.assertListPrefix(expected, actual)

        d.destroy()
Example #46
0
    def testCompileSimple(self):
        rt = self.runtime

        script = """
      src : std.CountTimer()
      snk : io.StandardOut(store_tokens=1)
      src.integer > snk.token
    """
        app_info, errors, warnings = compiler.compile(script, "simple")
        d = deployer.Deployer(rt, app_info)
        d.deploy() # ignoring app_id here
        time.sleep(0.5)
        src = d.actor_map['simple:src']
        snk = d.actor_map['simple:snk']

        utils.disconnect(rt, src)

        actual = actual_tokens(rt, snk)
        expected = expected_tokens(rt, src, 'std.CountTimer')

        self.assertListPrefix(expected, actual)

        d.destroy()
Example #47
0
    def testRegexMultiCapture(self):
        script = """
            src   : std.Constant(data="24.1632", n=1)
            regex : text.RegexMatch(regex=!"(\d+)\.(\d+)")
            snk   : io.StandardOut(store_tokens=1, quiet=1)
            term  : std.Terminator()

            src.token      > regex.text
            regex.match    > snk.token
            regex.no_match > term.null
        """
        app_info, errors, warnings = compiler.compile(script,
                                                      "testRegexMultiCapture")
        print errors
        d = deployer.Deployer(self.rt1, app_info)
        d.deploy()
        time.sleep(0.5)

        snk = d.actor_map['testRegexMultiCapture:snk']
        actual = utils.report(self.rt1, snk)
        expected = ["24"]

        self.assert_lists_equal(expected, actual, min_length=1)