Example #1
0
    def test_graph_flow_with_multireturn_and_multiargs_tasks(self):
        flow = gf.Flow('g-3-multi').add(
            utils.TaskMultiArgOneReturn(name='task1',
                                        rebind=['a', 'b', 'y'], provides='z'),
            utils.TaskMultiReturn(name='task2', provides=['a', 'b', 'c']),
            utils.TaskMultiArgOneReturn(name='task3',
                                        rebind=['c', 'b', 'x'], provides='y'))

        engine = self._make_engine(flow)
        engine.storage.inject({'x': 30})
        engine.run()
        self.assertEqual(engine.storage.fetch_all(), {
            'a': 1,
            'b': 3,
            'c': 5,
            'x': 30,
            'y': 38,
            'z': 42
        })
Example #2
0
def run(engine_options):
    flow = lf.Flow('simple-linear').add(
        utils.TaskOneArgOneReturn(provides='result1'),
        utils.TaskMultiArgOneReturn(provides='result2'))
    eng = engines.load(flow,
                       store=dict(x=111, y=222, z=333),
                       engine='worker-based',
                       **engine_options)
    eng.run()
    return eng.storage.fetch_all()
    def test_graph_flow_retry_and_task(self):
        flow = gf.Flow(
            'gf',
            retry.AlwaysRevert('rt', requires=['x', 'y'], provides=['a', 'b']))
        flow.add(
            utils.TaskMultiArgOneReturn(rebind=['a', 'x', 'c'],
                                        provides=['z']))

        self.assertEqual(flow.requires, set(['x', 'y', 'c']))
        self.assertEqual(flow.provides, set(['a', 'b', 'z']))
 def test_argument_injection(self):
     flow = utils.TaskMultiArgOneReturn(provides='result',
                                        inject={
                                            'x': 1,
                                            'y': 4,
                                            'z': 9
                                        })
     engine = self._make_engine(flow)
     engine.run()
     self.assertEqual({
         'result': 14,
     }, engine.storage.fetch_all())
 def test_arguments_passing(self):
     flow = utils.TaskMultiArgOneReturn(provides='result')
     engine = self._make_engine(flow)
     engine.storage.inject({'x': 1, 'y': 4, 'z': 9, 'a': 17})
     engine.run()
     self.assertEqual({
         'x': 1,
         'y': 4,
         'z': 9,
         'a': 17,
         'result': 14,
     }, engine.storage.fetch_all())
 def test_argument_injection_rebind(self):
     flow = utils.TaskMultiArgOneReturn(provides='result',
                                        rebind=['a', 'b', 'c'],
                                        inject={
                                            'a': 1,
                                            'b': 4,
                                            'c': 9
                                        })
     engine = self._make_engine(flow)
     engine.run()
     self.assertEqual({
         'result': 14,
     }, engine.storage.fetch_all())
Example #7
0
 def test_partial_arguments_mapping(self):
     flow = utils.TaskMultiArgOneReturn(provides='result',
                                        rebind={'x': 'a'})
     engine = self._make_engine(flow)
     engine.storage.inject({'x': 1, 'y': 4, 'z': 9, 'a': 17})
     engine.run()
     self.assertEqual(engine.storage.fetch_all(), {
         'x': 1,
         'y': 4,
         'z': 9,
         'a': 17,
         'result': 30,
     })
Example #8
0
 def test_all_arguments_mapping(self):
     flow = utils.TaskMultiArgOneReturn(provides='result',
                                        rebind=['a', 'b', 'c'])
     engine = self._make_engine(flow)
     engine.storage.inject({'a': 1, 'b': 2, 'c': 3, 'x': 4, 'y': 5, 'z': 6})
     engine.run()
     self.assertEqual(engine.storage.fetch_all(), {
         'a': 1,
         'b': 2,
         'c': 3,
         'x': 4,
         'y': 5,
         'z': 6,
         'result': 6,
     })
Example #9
0
 def test_argument_injection_required(self):
     flow = utils.TaskMultiArgOneReturn(provides='result',
                                        requires=['a', 'b', 'c'],
                                        inject={
                                            'x': 1,
                                            'y': 4,
                                            'z': 9,
                                            'a': 0,
                                            'b': 0,
                                            'c': 0
                                        })
     engine = self._make_engine(flow)
     engine.run()
     self.assertEqual(engine.storage.fetch_all(), {
         'result': 14,
     })
Example #10
0
                'taskflow.tests.utils.TaskMultiArgOneReturn'
            ]
        }
    }

    # parse command line
    try:
        arg = sys.argv[1]
    except IndexError:
        pass
    else:
        try:
            cfg = json.loads(arg)
        except ValueError:
            engine_conf.update(url=arg)
        else:
            engine_conf.update(cfg)
    finally:
        LOG.debug("Worker configuration: %s\n" %
                  json.dumps(engine_conf, sort_keys=True, indent=4))

    # create and run flow
    flow = lf.Flow('simple-linear').add(
        utils.TaskOneArgOneReturn(provides='result1'),
        utils.TaskMultiArgOneReturn(provides='result2'))
    eng = taskflow.engines.load(flow,
                                store=dict(x=111, y=222, z=333),
                                engine_conf=engine_conf)
    eng.run()
    print(json.dumps(eng.storage.fetch_all(), sort_keys=True))