Esempio n. 1
0
    def recv_cfg(self, msg):
        """receive cfg/topology configuration"""
        if msg.type != ConfigurationMessage.ident:
            raise MessageProcessingError('unexpected message: %s' % msg)

        self.logger.debug('got channel configuration')

        # gw node name
        hostname = _getshorthostname()
        if not msg.gateway:
            self.nodename = hostname
            self.logger.warn('gw name not provided, using system hostname %s',
                             self.nodename)
        else:
            self.nodename = msg.gateway

        self.logger.debug('using gateway node name %s', self.nodename)
        if self.nodename.lower() != hostname.lower():
            self.logger.debug('gw name %s does not match system hostname %s',
                              self.nodename, hostname)

        # topology
        task_self().topology = self.topology = msg.data_decode()
        self.logger.debug('decoded propagation tree')
        self.logger.debug('\n%s', self.topology)
        self.setup = True
        self._ack(msg)
Esempio n. 2
0
 def test_rank_placeholder(self):
     """test ExecWorker with several nodes and %n (rank)"""
     nodes = "localhost,%s" % HOSTNAME
     self.execw(nodes=nodes, handler=None, command="echo %n")
     self.assertEqual(task_self().max_retcode(), 0)
     self.assertEqual([str(msg) for msg, _ in task_self().iter_buffers()],
                      ['0', '1'])
Esempio n. 3
0
def check_etat_noeud2(etatnoeud_IHM, nodeset):

    etatnoeud_IHM.listWidget.clear()
    etatnoeud_IHM.listWidget_2.clear()
    etatnoeud_IHM.listWidget_3.clear()

    i = 1

    print nodeset
    for node in nodeset:
        cli = "echo Hello"
        taske = task_self()
        taske.shell(cli, nodes=node)
        taske.run()

        for output, nodelist in task_self().iter_buffers():
            if (output == "Hello"):

                etatnoeud_IHM.listWidget.insertItem(
                    i, "%s" % (NodeSet.fromlist(nodelist)))
                i = i + 1

            else:
                etatnoeud_IHM.listWidget_2.insertItem(
                    i, "%s" % (NodeSet.fromlist(nodelist)))
                i = i + 1
                etatnoeud_IHM.sortie.append(output)
                print "output: %s" % output
Esempio n. 4
0
    def recv_cfg(self, msg):
        """receive cfg/topology configuration"""
        if msg.type != ConfigurationMessage.ident:
            raise MessageProcessingError('unexpected message: %s' % msg)

        self.logger.debug('got channel configuration')

        # gw node name
        hostname = _getshorthostname()
        if not msg.gateway:
            self.nodename = hostname
            self.logger.warn('gw name not provided, using system hostname %s',
                             self.nodename)
        else:
            self.nodename = msg.gateway

        self.logger.debug('using gateway node name %s', self.nodename)
        if self.nodename.lower() != hostname.lower():
            self.logger.debug('gw name %s does not match system hostname %s',
                              self.nodename, hostname)

        # topology
        task_self().topology = self.topology = msg.data_decode()
        self.logger.debug('decoded propagation tree')
        self.logger.debug('\n%s', self.topology)
        self.setup = True
        self._ack(msg)
Esempio n. 5
0
    def test_004_workerclass(self):
        """test Defaults workerclass"""
        self.defaults.distant_workername = 'pdsh'
        task_terminate()
        task = task_self(self.defaults)
        self.assertTrue(task.default("distant_worker") is WorkerPdsh)
        self.defaults.distant_workername = 'ssh'
        self.assertTrue(task.default("distant_worker") is WorkerPdsh)
        task_terminate()

        task = task_self(self.defaults)
        self.assertTrue(task.default("distant_worker") is WorkerSsh)
        task_terminate()

        dname = make_temp_dir()
        modfile = open(os.path.join(dname, 'OutOfTree.py'), 'w')
        modfile.write(dedent("""
            class OutOfTreeWorker(object):
                pass
            WORKER_CLASS = OutOfTreeWorker"""))
        modfile.flush()
        modfile.close()
        sys.path.append(dname)
        self.defaults.distant_workername = 'OutOfTree'
        task = task_self(self.defaults)
        self.assertTrue(task.default("distant_worker").__name__ is 'OutOfTreeWorker')
        task_terminate()
        shutil.rmtree(dname, ignore_errors=True)
Esempio n. 6
0
 def test_node_placeholder(self):
     """test ExecWorker with several nodes and %h (host)"""
     nodes = "localhost,%s" % HOSTNAME
     self.execw(nodes=nodes, handler=None, command="echo %h")
     self.assertEqual(task_self().max_retcode(), 0)
     self.assertEqual(task_self().node_buffer('localhost'), 'localhost')
     self.assertEqual(task_self().node_buffer(HOSTNAME), HOSTNAME)
Esempio n. 7
0
def clush_excepthook(extype, exp, traceback):
    """Exceptions hook for clush: this method centralizes exception
    handling from main thread and from (possible) separate task thread.
    This hook has to be previously installed on startup by overriding
    sys.excepthook and task.excepthook."""
    try:
        raise exp
    except ClushConfigError as econf:
        print >> sys.stderr, "ERROR: %s" % econf
        clush_exit(1)
    except KeyboardInterrupt as kbe:
        uncomp_nodes = getattr(kbe, 'uncompleted_nodes', None)
        if uncomp_nodes:
            print >> sys.stderr, \
                "Keyboard interrupt (%s did not complete)." % uncomp_nodes
        else:
            print >> sys.stderr, "Keyboard interrupt."
        clush_exit(128 + signal.SIGINT)
    except OSError as exp:
        print >> sys.stderr, "ERROR: %s" % exp
        if exp.errno == errno.EMFILE:
            print >> sys.stderr, "ERROR: current `nofile' limits: " \
                "soft=%d hard=%d" % resource.getrlimit(resource.RLIMIT_NOFILE)
        clush_exit(1)
    except GENERIC_ERRORS as exc:
        clush_exit(handle_generic_error(exc))

    # Error not handled
    task_self().default_excepthook(extype, exp, traceback)
Esempio n. 8
0
 def test_rank_placeholder(self):
     """test ExecWorker with several nodes and %n (rank)"""
     nodes = "localhost,%s" % HOSTNAME
     self.execw(nodes=nodes, handler=None, command="echo %n")
     self.assertEqual(task_self().max_retcode(), 0)
     self.assertEqual([str(msg) for msg, _ in task_self().iter_buffers()],
                      ['0', '1'])
Esempio n. 9
0
 def test_node_placeholder(self):
     """test ExecWorker with several nodes and %h (host)"""
     nodes = "localhost,%s" % HOSTNAME
     self.execw(nodes=nodes, handler=None, command="echo %h")
     self.assertEqual(task_self().max_retcode(), 0)
     self.assertEqual(task_self().node_buffer('localhost'), 'localhost')
     self.assertEqual(task_self().node_buffer(HOSTNAME), HOSTNAME)
Esempio n. 10
0
 def test_one_action_error(self):
     """A group with only an error action is on error"""
     act = TestAction('/bin/false')
     self.grp.add(act)
     self.grp.launch()
     task_self().run()
     self.assertEqual(act.status(), ACT_ERROR)
     self.assertEqual(self.grp.status(), ACT_ERROR)
Esempio n. 11
0
 def test_rcopy(self):
     """test file rcopy setup in tree mode (1 gateway)"""
     self.test_ok = False
     self.tfile = make_temp_file("dummy-src")
     self.tdir = make_temp_dir()
     task_self().rcopy(self.tfile.name, self.tdir, "n60")
     task_self().resume()
     self.assertTrue(self.test_ok)
Esempio n. 12
0
 def test_one_action(self):
     """A group with its only action both run ok"""
     act = TestAction('/bin/true')
     self.grp.add(act)
     self.grp.launch()
     task_self().run()
     self.assertEqual(act.status(), ACT_OK)
     self.assertEqual(self.grp.status(), ACT_OK)
Esempio n. 13
0
 def test_rcopy(self):
     """test file rcopy setup in tree mode (1 gateway)"""
     self.test_ok = False
     self.tfile = make_temp_file("dummy-src")
     self.tdir = make_temp_dir()
     task_self().rcopy(self.tfile.name, self.tdir, "n60")
     task_self().resume()
     self.assertTrue(self.test_ok)
Esempio n. 14
0
 def test_one_action_error(self):
     """A group with only an error action is on error"""
     act = TestAction('/bin/false')
     self.grp.add(act)
     self.grp.launch()
     task_self().run()
     self.assertEqual(act.status(), ACT_ERROR)
     self.assertEqual(self.grp.status(), ACT_ERROR)
Esempio n. 15
0
 def test_one_action(self):
     """A group with its only action both run ok"""
     act = TestAction('/bin/true')
     self.grp.add(act)
     self.grp.launch()
     task_self().run()
     self.assertEqual(act.status(), ACT_OK)
     self.assertEqual(self.grp.status(), ACT_OK)
Esempio n. 16
0
    def test_003_io_pipes(self):
        """test StreamWorker bound to pipe readers and writers"""

        # os.write -> pipe1 -> worker -> pipe2 -> os.read

        class TestH(EventHandler):
            def __init__(self, testcase):
                self.testcase = testcase
                self.worker = None
                self.pickup_count = 0
                self.hup_count = 0

            def ev_pickup(self, worker):
                self.pickup_count += 1

            def ev_read(self, worker):
                self.testcase.assertEqual(worker.current_sname, "pipe1")
                worker.write(worker.current_msg, "pipe2")

            def ev_timer(self, timer):
                # call set_write_eof on specific stream after some delay
                worker = self.worker
                self.worker = 'DONE'
                worker.set_write_eof("pipe2")

            def ev_hup(self, worker):
                # ev_hup called at the end (after set_write_eof is called)
                self.hup_count += 1
                self.testcase.assertEqual(self.worker, 'DONE')
                # no rc code should be set
                self.testcase.assertEqual(worker.current_rc, None)

        # create a StreamWorker instance bound to several pipes
        hdlr = TestH(self)
        worker = StreamWorker(handler=hdlr)
        hdlr.worker = worker

        rfd1, wfd1 = os.pipe()
        worker.set_reader("pipe1", rfd1)
        os.write(wfd1, b"Some data\n")
        os.close(wfd1)

        rfd2, wfd2 = os.pipe()
        worker.set_writer("pipe2", wfd2)

        timer1 = task_self().timer(1.0, handler=hdlr)
        self.run_worker(worker)
        self.assertEqual(os.read(rfd2, 1024), b"Some data")
        os.close(rfd2)
        # wfd2 should be closed by CS
        self.assertRaises(OSError, os.close, wfd2)
        # rfd1 should be closed by CS
        self.assertRaises(OSError, os.close, rfd1)
        # check pickup/hup
        self.assertEqual(hdlr.hup_count, 1)
        self.assertEqual(hdlr.pickup_count, 1)
        self.assertTrue(task_self().max_retcode() is None)
Esempio n. 17
0
 def test_copy(self):
     """test file copy setup in tree mode (1 gateway)"""
     self.test_ok = False
     self.tfile = make_temp_file("dummy")
     # add leading '/' like clush so that WorkerTree knows it's a dir
     task_self().copy(self.tfile.name, join(dirname(self.tfile.name), ''),
                      "n60")
     task_self().resume()
     self.assertTrue(self.test_ok)
Esempio n. 18
0
    def test_003_io_pipes(self):
        """test StreamWorker bound to pipe readers and writers"""

        # os.write -> pipe1 -> worker -> pipe2 -> os.read

        class TestH(EventHandler):
            def __init__(self, testcase):
                self.testcase = testcase
                self.worker = None
                self.pickup_count = 0
                self.hup_count = 0

            def ev_pickup(self, worker):
                self.pickup_count += 1

            def ev_read(self, worker):
                self.testcase.assertEqual(worker.current_sname, "pipe1")
                worker.write(worker.current_msg, "pipe2")

            def ev_timer(self, timer):
                # call set_write_eof on specific stream after some delay
                worker = self.worker
                self.worker = 'DONE'
                worker.set_write_eof("pipe2")

            def ev_hup(self, worker):
                # ev_hup called at the end (after set_write_eof is called)
                self.hup_count += 1
                self.testcase.assertEqual(self.worker, 'DONE')
                # no rc code should be set
                self.testcase.assertEqual(worker.current_rc, None)

        # create a StreamWorker instance bound to several pipes
        hdlr = TestH(self)
        worker = StreamWorker(handler=hdlr)
        hdlr.worker = worker

        rfd1, wfd1 = os.pipe()
        worker.set_reader("pipe1", rfd1)
        os.write(wfd1, b"Some data\n")
        os.close(wfd1)

        rfd2, wfd2 = os.pipe()
        worker.set_writer("pipe2", wfd2)

        timer1 = task_self().timer(1.0, handler=hdlr)
        self.run_worker(worker)
        self.assertEqual(os.read(rfd2, 1024), b"Some data")
        os.close(rfd2)
        # wfd2 should be closed by CS
        self.assertRaises(OSError, os.close, wfd2)
        # rfd1 should be closed by CS
        self.assertRaises(OSError, os.close, rfd1)
        # check pickup/hup
        self.assertEqual(hdlr.hup_count, 1)
        self.assertEqual(hdlr.pickup_count, 1)
        self.assertTrue(task_self().max_retcode() is None)
Esempio n. 19
0
    def _already_done(self):
        """Return a Result object is the target is already unmounted."""
        if self.comp.is_stopped():
            return Result(message="%s is already stopped" % self.comp.label)

        # LBUG #18624
        if not self.comp.dev_isblk:
            task_self().set_info("fanout", 1)

        return None
Esempio n. 20
0
    def _already_done(self):
        """Return a Result object is the target is already unmounted."""
        if self.comp.is_stopped():
            return Result(message="%s is already stopped" % self.comp.label)

        # LBUG #18624
        if not self.comp.dev_isblk:
            task_self().set_info("fanout", 1)

        return None
Esempio n. 21
0
 def test_copy(self):
     """test file copy setup in tree mode (1 gateway)"""
     self.test_ok = False
     self.tfile = make_temp_file("dummy")
     # add leading '/' like clush so that WorkerTree knows it's a dir
     task_self().copy(self.tfile.name,
                      join(dirname(self.tfile.name), ''),
                      "n60")
     task_self().resume()
     self.assertTrue(self.test_ok)
Esempio n. 22
0
    def _already_done(self):
        """Raise an exception if the target is mounted."""
        self.comp.raise_if_started("Cannot %s" % self.NAME)

        # LBUG #18624 : workaround for "multiple mkfs.lustre on loop devices"
        if not self.comp.dev_isblk:
            # configure one engine client max per task (sequential, bah.)
            task_self().set_info("fanout", 1)

        return None
Esempio n. 23
0
 def test_two_actions_2_errors(self):
     """A group with 2 error actions is on error"""
     act1 = TestAction('/bin/false')
     act2 = TestAction('/bin/false')
     self.grp.add(act1)
     self.grp.add(act2)
     self.grp.launch()
     task_self().run()
     self.assertEqual(act1.status(), ACT_ERROR)
     self.assertEqual(act2.status(), ACT_ERROR)
     self.assertEqual(self.grp.status(), ACT_ERROR)
Esempio n. 24
0
 def test_two_actions_ok_and_error(self):
     """A group with a ok action and an error action is on error"""
     act1 = TestAction('/bin/true')
     act2 = TestAction('/bin/false')
     self.grp.add(act1)
     self.grp.add(act2)
     self.grp.launch()
     task_self().run()
     self.assertEqual(act1.status(), ACT_OK)
     self.assertEqual(act2.status(), ACT_ERROR)
     self.assertEqual(self.grp.status(), ACT_ERROR)
Esempio n. 25
0
    def stop(self, args):
        nodes = NodeSet()

        nbNoeud = len(args) - 2
        # print'nbNoeud: %d'%nbNoeud
        for i in range(1, nbNoeud + 1):
            nodes.add(args[i])
            print args[i] + ' : sudo service ' + args[nbNoeud + 1] + ' stop'

        task_self().run('sudo service ' + args[nbNoeud + 1] + ' stop',
                        nodes=nodes)
Esempio n. 26
0
 def test_two_actions_ok_and_ok(self):
     """A group with 2 actions all run fine"""
     act1 = TestAction('/bin/true')
     act2 = TestAction('/bin/true')
     self.grp.add(act1)
     self.grp.add(act2)
     self.grp.launch()
     task_self().run()
     self.assertEqual(act1.status(), ACT_OK)
     self.assertEqual(act2.status(), ACT_OK)
     self.assertEqual(self.grp.status(), ACT_OK)
Esempio n. 27
0
 def test_two_actions_2_errors(self):
     """A group with 2 error actions is on error"""
     act1 = TestAction('/bin/false')
     act2 = TestAction('/bin/false')
     self.grp.add(act1)
     self.grp.add(act2)
     self.grp.launch()
     task_self().run()
     self.assertEqual(act1.status(), ACT_ERROR)
     self.assertEqual(act2.status(), ACT_ERROR)
     self.assertEqual(self.grp.status(), ACT_ERROR)
Esempio n. 28
0
 def test_two_actions_ok_and_error(self):
     """A group with a ok action and an error action is on error"""
     act1 = TestAction('/bin/true')
     act2 = TestAction('/bin/false')
     self.grp.add(act1)
     self.grp.add(act2)
     self.grp.launch()
     task_self().run()
     self.assertEqual(act1.status(), ACT_OK)
     self.assertEqual(act2.status(), ACT_ERROR)
     self.assertEqual(self.grp.status(), ACT_ERROR)
Esempio n. 29
0
 def test_two_actions_ok_and_ok(self):
     """A group with 2 actions all run fine"""
     act1 = TestAction('/bin/true')
     act2 = TestAction('/bin/true')
     self.grp.add(act1)
     self.grp.add(act2)
     self.grp.launch()
     task_self().run()
     self.assertEqual(act1.status(), ACT_OK)
     self.assertEqual(act2.status(), ACT_OK)
     self.assertEqual(self.grp.status(), ACT_OK)
Esempio n. 30
0
    def test_abort_on_read(self):
        """test ExecWorker.abort() on read"""

        class TestH(EventHandler):
            def ev_read(self, worker):
                worker.abort()
                worker.abort()  # safe but no effect

        self.execw(nodes='localhost', handler=TestH(),
                   command="echo ok; tail -f /dev/null")
        self.assertEqual(task_self().max_retcode(), None)
        self.assertEqual(task_self().node_buffer('localhost'), b'ok')
Esempio n. 31
0
    def test_abort_on_close(self):
        """test ExecWorker.abort() on close"""

        class TestH(EventHandler):
            def ev_close(self, worker, timedout):
                worker.abort()
                worker.abort()  # safe but no effect

        self.execw(nodes='localhost', handler=TestH(),
                   command="echo ok; sleep .1")
        self.assertEqual(task_self().max_retcode(), 0)
        self.assertEqual(task_self().node_buffer('localhost'), b'ok')
Esempio n. 32
0
 def test_copy_wrong_directory(self):
     """test copying wrong directory with an ExecWorker"""
     srcdir = make_temp_dir()
     dst = make_temp_file("data")
     ref1 = make_temp_file("data1", dir=srcdir)
     try:
         self.execw(nodes="localhost", handler=None, source=srcdir, dest=dst.name, stderr=True)
         self.assertEqual(task_self().max_retcode(), 1)
         self.assertTrue(len(task_self().node_error("localhost")) > 0)
         self.assertTrue(os.path.isfile(ref1.name))
     finally:
         del ref1
         os.rmdir(srcdir)
Esempio n. 33
0
    def test_004_workerclass(self):
        """test Defaults workerclass"""
        self.defaults.distant_workername = 'pdsh'
        task_terminate()
        task = task_self(self.defaults)
        self.assertTrue(task.default("distant_worker") is WorkerPdsh)
        self.defaults.distant_workername = 'ssh'
        self.assertTrue(task.default("distant_worker") is WorkerPdsh)
        task_terminate()

        task = task_self(self.defaults)
        self.assertTrue(task.default("distant_worker") is WorkerSsh)
        task_terminate()
Esempio n. 34
0
    def test_004_workerclass(self):
        """test Defaults workerclass"""
        self.defaults.distant_workername = 'pdsh'
        task_terminate()
        task = task_self(self.defaults)
        self.assertTrue(task.default("distant_worker") is WorkerPdsh)
        self.defaults.distant_workername = 'ssh'
        self.assertTrue(task.default("distant_worker") is WorkerPdsh)
        task_terminate()

        task = task_self(self.defaults)
        self.assertTrue(task.default("distant_worker") is WorkerSsh)
        task_terminate()
Esempio n. 35
0
 def test_copy_wrong_directory(self):
     """test copying wrong directory with an ExecWorker"""
     srcdir = make_temp_dir()
     dst = make_temp_file(b"data")
     ref1 = make_temp_file(b"data1", dir=srcdir)
     try:
         self.execw(nodes='localhost', handler=None, source=srcdir,
                    dest=dst.name, stderr=True)
         self.assertEqual(task_self().max_retcode(), 1)
         self.assertTrue(len(task_self().node_error("localhost")) > 0)
         self.assertTrue(os.path.isfile(ref1.name))
     finally:
         del ref1
         os.rmdir(srcdir)
Esempio n. 36
0
    def test_one_dep_error(self):
        """A group with an error dependency is on error, content is not run"""
        act = TestAction('/bin/false')
        act1 = TestAction('/bin/true')
        self.grp.add(act1)

        self.grp.depends_on(act)

        self.grp.launch()
        task_self().run()

        self.assertEqual(act.status(), ACT_ERROR)
        self.assertEqual(act1.status(), ACT_WAITING)
        self.assertEqual(self.grp.status(), ACT_ERROR)
Esempio n. 37
0
    def test_one_dep_ok(self):
        """A group with one ok dependency is ok"""
        act = TestAction('/bin/true')
        act1 = TestAction('/bin/true')
        self.grp.add(act1)

        self.grp.depends_on(act)

        self.grp.launch()
        task_self().run()

        self.assertEqual(act.status(), ACT_OK)
        self.assertEqual(act1.status(), ACT_OK)
        self.assertEqual(self.grp.status(), ACT_OK)
Esempio n. 38
0
    def test_one_dep_ok(self):
        """A group with one ok dependency is ok"""
        act = TestAction('/bin/true')
        act1 = TestAction('/bin/true')
        self.grp.add(act1)

        self.grp.depends_on(act)

        self.grp.launch()
        task_self().run()

        self.assertEqual(act.status(), ACT_OK)
        self.assertEqual(act1.status(), ACT_OK)
        self.assertEqual(self.grp.status(), ACT_OK)
Esempio n. 39
0
    def test_one_dep_error(self):
        """A group with an error dependency is on error, content is not run"""
        act = TestAction('/bin/false')
        act1 = TestAction('/bin/true')
        self.grp.add(act1)

        self.grp.depends_on(act)

        self.grp.launch()
        task_self().run()

        self.assertEqual(act.status(), ACT_ERROR)
        self.assertEqual(act1.status(), ACT_WAITING)
        self.assertEqual(self.grp.status(), ACT_ERROR)
Esempio n. 40
0
    def status(self, args, afficher):
        node0 = NodeSet()
        nbNoeud = len(args) - 2

        #print'nbNoeud: %d'%nbNoeud

        for i in range(1, nbNoeud + 1):
            node0.add(args[i])

        print 'sudo service ' + args[nbNoeud + 1] + ' status'
        task_self().run('sudo service ' + args[nbNoeud + 1] + ' status',
                        nodes=node0)

        return self.recevoir(afficher)
Esempio n. 41
0
    def test_one_dep_after_error(self):
        """An action with an error group dependency is on error"""
        act = TestAction('/bin/true')
        self.grp = ActionGroup()
        act1 = TestAction('/bin/false')
        self.grp.add(act1)

        act.depends_on(self.grp)

        act.launch()
        task_self().run()

        self.assertEqual(act1.status(), ACT_ERROR)
        self.assertEqual(self.grp.status(), ACT_ERROR)
        self.assertEqual(act.status(), ACT_ERROR)
Esempio n. 42
0
    def test_one_dep_after_error(self):
        """An action with an error group dependency is on error"""
        act = TestAction('/bin/true')
        self.grp = ActionGroup()
        act1 = TestAction('/bin/false')
        self.grp.add(act1)

        act.depends_on(self.grp)

        act.launch()
        task_self().run()

        self.assertEqual(act1.status(), ACT_ERROR)
        self.assertEqual(self.grp.status(), ACT_ERROR)
        self.assertEqual(act.status(), ACT_ERROR)
    def testExecuteTasksOnNeighbors(self):
        """test execute tasks on directly connected machines"""
        tmpfile = tempfile.NamedTemporaryFile()

        myhost = my_node()
        cfgparser = load_cfg('topology1.conf')
        neighbor = cfgparser.get('CONFIG', 'NEIGHBOR')
        gateways = cfgparser.get('CONFIG', 'GATEWAYS')
        targets = cfgparser.get('CONFIG', 'TARGETS')

        tmpfile.write('[Main]\n')
        tmpfile.write('%s: %s\n' % (myhost, neighbor))
        tmpfile.write('%s: %s\n' % (neighbor, gateways))
        tmpfile.write('%s: %s\n' % (gateways, targets))
        tmpfile.flush()
        parser = TopologyParser()
        parser.load(tmpfile.name)

        tree = parser.tree(myhost)
        wtree = WorkerTree(NodeSet(targets), None, 0, command='echo ok',
                           topology=tree, newroot=myhost)
        # XXX Need to propagate topology for this to work in tests
        raise RuntimeError

        task = task_self()
        task.set_info('debug', True)
        task.schedule(wtree)
        task.resume()

        for buf, nodes in task.iter_buffers():
            print '-' * 15
            print str(nodes)
            print '-' * 15
            print buf
            print ''
Esempio n. 44
0
 def testTaskScheduleTwice(self):
     """test task worker schedule twice error"""
     task = task_self()
     self.assert_(task != None)
     worker = task.shell("/bin/echo itsme")
     self.assertRaises(WorkerError, task.schedule, worker)
     task.abort()
Esempio n. 45
0
 def testTaskScheduleTwice(self):
     """test task worker schedule twice error"""
     task = task_self()
     self.assert_(task != None)
     worker = task.shell("/bin/echo itsme")
     self.assertRaises(WorkerError, task.schedule, worker)
     task.abort()
Esempio n. 46
0
    def testInvalidCommunication(self):
        """test detecting invalid data upon reception"""
        ftest = tempfile.NamedTemporaryFile()
        ftest.write('<?xml version="1.0" encoding="UTF-8"?>\n')
        ftest.write('This is an invalid line\n')
        ftest.write('<channel>\n')
        ftest.write('</channel>\n')

        ## write data on the disk
        # actually we should do more but this seems sufficient
        ftest.flush()

        chan = _TestingChannel()
        task = task_self()

        fin = open(ftest.name)
        fout = open('/dev/null', 'w')
        worker = WorkerSimple(fin, fout, None, None, handler=chan)
        task.schedule(worker)

        self.assertRaises(MessageProcessingError, task.resume)

        fin.close()
        fout.close()
        ftest.close()
Esempio n. 47
0
    def testDistantChannel(self):
        """schyzophrenic self communication test over SSH"""
        # create a bunch of messages
        spec = {
            # msg type: number of samples
            ConfigurationMessage.ident: 1,
            ControlMessage.ident: 1,
            ACKMessage.ident: 1,
            ErrorMessage.ident: 1
        }
        ftest = tempfile.NamedTemporaryFile()
        ftest.write('<?xml version="1.0" encoding="UTF-8"?>\n')
        ftest.write('<channel>\n')
        for mtype, count in spec.items():
            for i in range(count):
                sample = gen_map[mtype]()
                sample.msgid = i
                ftest.write(sample.xml() + '\n')
        ftest.write('</channel>\n')

        ## write data on the disk
        # actually we should do more but this seems sufficient
        ftest.flush()

        task = task_self()
        chan = _TestingChannel()
        task.shell('cat ' + ftest.name, nodes='localhost', handler=chan)
        task.resume()

        ftest.close()
        self.assertEquals(chan.validate(spec), True)
Esempio n. 48
0
 def testWorkerNotScheduledDistant(self):
     """test library misusage (distant worker not scheduled)"""
     task = task_self()
     worker = WorkerSsh(HOSTNAME, command="/bin/hostname", handler=None, timeout=0)
     self.assert_(worker != None)
     task.resume()
     self.assertRaises(WorkerError, worker.node_buffer, HOSTNAME)
Esempio n. 49
0
def main():
    """ Main script function """
    # Initialize option parser
    parser = optparse.OptionParser()
    parser.add_option("-d", "--debug", action="store_true", dest="debug",
                      default=False, help="Enable debug mode")
    parser.add_option("-n", "--nodes", action="store", dest="nodes",
                      default="@all", help="Target nodes (default @all group)")
    parser.add_option("-f", "--fanout", action="store", dest="fanout",
                      default="128", help="Fanout window size (default 128)",
                      type=int)
    parser.add_option("-t", "--timeout", action="store", dest="timeout",
                      default="5", help="Timeout in seconds (default 5)",
                      type=float)
    options, _ = parser.parse_args()

    # Get current task (associated to main thread)
    task = task_self()
    nodes_target = NodeSet(options.nodes)
    task.set_info("fanout", options.fanout)
    if options.debug:
        print "nodeset : %s" % nodes_target
        task.set_info("debug", True)

    # Create ClusterShell event handler
    handler = CheckNodesHandler(CheckNodesResult())

    # Schedule remote command and run task (blocking call)
    task.run("who -b", nodes=nodes_target, handler=handler, \
        timeout=options.timeout)
Esempio n. 50
0
def get_remote_output(host_list, command, timeout=120):
    """Run the command on each specified host in parallel.

    Args:
        host_list (list): list of hosts
        command (str): command to run on each host
        timeout (int, optional): number of seconds to wait for all jobs to
            complete. Defaults to 120 seconds.

    Returns:
        Task: a Task object containing the result of the running the command on
            the specified hosts

    """
    # Create a ClusterShell Task to run the command in parallel on the hosts
    if isinstance(host_list, list):
        nodes = NodeSet.fromlist(host_list)
    else:
        nodes = NodeSet(host_list)
    task = task_self()
    # task.set_info('debug', True)
    # Enable forwarding of the ssh authentication agent connection
    task.set_info("ssh_options", "-oForwardAgent=yes")
    print("Running on {}: {}".format(nodes, command))
    task.run(command=command, nodes=nodes, timeout=timeout)
    return task
Esempio n. 51
0
def command(nodeset, command):
    output = {}

    task = task_self()

    vlog(4,'clush_ipmi: nodeset:%s command:%s' % (nodeset, command))

    if not sgi_cluster.is_sac():
        vlog(1, "only run this from SAC node")
        return False

    for node in nodeset:
        lead = sgi_cluster.get_lead(node)
        if lead:
            if lead == socket.gethostname():
                cmd = '/usr/diags/bin/bcmd -H {0} {1}'.format(sgi_cluster.get_bmc(node), command)
                vlog(4, 'calling bcmd on localhost: %s' % cmd)
                task.shell(
                    cmd, 
                    timeout=120,  
                    handler=__OutputHandler(node, output)
                ) 
            else:
                cmd = '/usr/diags/bin/bcmd -H {0} {1}'.format(sgi_cluster.get_bmc(node), command)
                vlog(4, 'calling bcmd on %s: %s' % (lead, cmd))
                task.shell(
                    cmd,
                    nodes=lead, 
                    timeout=120,  
                    handler=__OutputHandler(node, output)
                )

    task.run()

    return output
    def testDistantChannel(self):
        """schyzophrenic self communication test over SSH"""
        # create a bunch of messages
        spec = {
            # msg type: number of samples
            ConfigurationMessage.ident: 1,
            ControlMessage.ident: 1,
            ACKMessage.ident: 1,
            ErrorMessage.ident: 1
        }
        ftest = tempfile.NamedTemporaryFile()
        ftest.write('<?xml version="1.0" encoding="UTF-8"?>\n')
        ftest.write('<channel>\n')
        for mtype, count in spec.iteritems():
            for i in xrange(count):
                sample = gen_map[mtype]()
                sample.msgid = i
                ftest.write(sample.xml() + '\n')
        ftest.write('</channel>\n')

        ## write data on the disk
        # actually we should do more but this seems sufficient
        ftest.flush()

        task = task_self()
        chan = _TestingChannel()
        task.shell('cat ' + ftest.name, nodes='localhost', handler=chan)
        task.resume()

        ftest.close()
        self.assertEquals(chan.validate(spec), True)
Esempio n. 53
0
    def __init__(self, task=task_self()):
        EventHandler.__init__(self)
        self.task = task

        # Action duration
        self.start = None
        self.duration = None
    def testInvalidCommunication(self):
        """test detecting invalid data upon reception"""
        ftest = tempfile.NamedTemporaryFile()
        ftest.write('<?xml version="1.0" encoding="UTF-8"?>\n')
        ftest.write('This is an invalid line\n')
        ftest.write('<channel>\n')
        ftest.write('</channel>\n')

        ## write data on the disk
        # actually we should do more but this seems sufficient
        ftest.flush()

        chan = _TestingChannel()
        task = task_self()

        fin = open(ftest.name)
        fout = open('/dev/null', 'w')
        worker = WorkerSimple(fin, fout, None, None, handler=chan)
        task.schedule(worker)

        self.assertRaises(MessageProcessingError, task.resume)

        fin.close()
        fout.close()
        ftest.close()
Esempio n. 55
0
    def recv_ctl(self, msg):
        """receive control message with actions to perform"""
        if msg.type == ControlMessage.ident:
            self.logger.debug('GatewayChannel._state_ctl')
            if msg.action == 'shell':
                data = msg.data_decode()
                cmd = data['cmd']

                stderr = data['stderr']
                timeout = data['timeout']
                remote = data['remote']

                #self.propagation.invoke_gateway = data['invoke_gateway']
                self.logger.debug('decoded gw invoke (%s)',
                                  data['invoke_gateway'])

                taskinfo = data['taskinfo']
                self.logger.debug('assigning task infos (%s)', data['taskinfo'])

                task = task_self()
                task._info.update(taskinfo)
                task.set_info('print_debug', _gw_print_debug)

                if task.info('debug'):
                    self.logger.setLevel(logging.DEBUG)

                self.logger.debug('inherited fanout value=%d',
                                  task.info("fanout"))

                self.logger.debug('launching execution/enter gathering state')

                responder = TreeWorkerResponder(task, self, msg.srcid)

                self.propagation = TreeWorker(msg.target, responder, timeout,
                                              command=cmd,
                                              topology=self.topology,
                                              newroot=self.nodename,
                                              stderr=stderr,
                                              remote=remote)
                # FIXME ev_start-not-called workaround
                responder.worker = self.propagation
                self.propagation.upchannel = self
                task.schedule(self.propagation)
                self.logger.debug("TreeWorker scheduled")
                self._ack(msg)
            elif msg.action == 'write':
                data = msg.data_decode()
                self.logger.debug('GatewayChannel write: %d bytes',
                                  len(data['buf']))
                self.propagation.write(data['buf'])
                self._ack(msg)
            elif msg.action == 'eof':
                self.logger.debug('GatewayChannel eof')
                self.propagation.set_write_eof()
                self._ack(msg)
            else:
                self.logger.error('unexpected CTL action: %s', msg.action)
        else:
            self.logger.error('unexpected message: %s', str(msg))
Esempio n. 56
0
    def test_perform_remote_false_action(self):
        """Test perform an action in remote mode=False"""

        action = Action('start', command='hostname -s', target='node1')
        action.remote = False
        svc = Service('Local')
        svc.add_action(action)

        mytopo = tempfile.NamedTemporaryFile('w')
        mytopo.write(u"[routes]\n%s: node1\n" % HOSTNAME)
        mytopo.flush()
        task_self().load_topology(mytopo.name)
        mytopo.close()

        svc.run('start')
        buff = action.worker.node_buffer('node1')
        self.assertEqual(buff, HOSTNAME)
Esempio n. 57
0
    def __init__(self):

        task = task_self()

        task.set_info("print_debug", print_csdebug)
        fanout = Globals().get_ssh_fanout()
        if fanout > 0:
            task.set_info("fanout", fanout)