Ejemplo n.º 1
0
    def test_neuron_cell_base(self):

        with self.getTestDir() as dirn:

            conf = {'bind': '127.0.0.1', 'host': 'localhost'}

            with s_cell.Cell(dirn, conf) as cell:
                # Ensure making the cell makes auth files
                self.true(os.path.isfile(cell._path('cell.auth')))
                self.true(os.path.isfile(cell._path('user.auth')))

                # A bunch of API tests here
                auth = cell.genUserAuth('*****@*****.**')
                self.istufo(auth)

                root = cell.getRootCert()
                self.isinstance(root, s_vault.Cert)

                # We have a default ping handler
                hdlrs = cell.handlers()
                self.isinstance(hdlrs, dict)
                self.isin('cell:ping', hdlrs)

                p1 = cell.getCellPath('hehe.wut')
                p2 = cell.getCellPath('woah', 'dude.txt')
                self.isinstance(p1, str)
                self.isinstance(p2, str)
                self.eq(os.path.relpath(p1, dirn),
                        os.path.join('cell', 'hehe.wut'))
                self.eq(os.path.relpath(p2, dirn),
                        os.path.join('cell', 'woah', 'dude.txt'))
                self.false(os.path.isdir(os.path.join(dirn, 'cell', 'woah')))

                p3 = cell.getCellDir('woah')
                self.eq(os.path.relpath(p3, dirn),
                        os.path.join('cell', 'woah'))
                self.true(os.path.isdir(p3))
                # Demonstrate the use of getCellDict()
                celld = cell.getCellDict('derry:sewers')
                celld.set('float:junction', 'the narrows')
                celld.set('float:place', (None, {'paperboat': 1}))

            with s_cell.Cell(dirn, conf) as cell:

                # These are largely demonstrative tests
                celld = cell.getCellDict('derry:sewers')
                self.eq(celld.get('float:junction'), 'the narrows')
                self.eq(celld.get('float:place'), (None, {'paperboat': 1}))
                celld.pop('float:place')
                self.none(celld.get('float:place'))
Ejemplo n.º 2
0
    def test_neuron_bad_sequence(self):
        '''
        Have the initiator send the listener a message with the wrong sequence number
        '''

        with self.getTestDir() as dirn:

            conf = {'bind': '127.0.0.1', 'host': 'localhost'}

            with self.getLoggerStream('synapse.lib.cell',
                                      'remote peer') as stream, s_cell.Cell(
                                          dirn, conf) as cell:

                user = cell.celluser
                addr = cell.getCellAddr()

                with user.open(addr, timeout=2) as sess:

                    sess.tx('Test message')

                    # hand increment the sequence so we break
                    next(sess._crypter._tx_sn)

                    sess.tx('Test message')
                    stream.wait(.1)

            stream.seek(0)
            log_msgs = stream.read()
            self.isin('out of sequence', log_msgs)

            # Currently this fails due to fini killing the whole socket
            self.isin('Remote peer issued error', log_msgs)
Ejemplo n.º 3
0
    def test_neuron_wrong_version(self):
        '''
        Have the initiator send the listener a weird version
        '''

        with self.getTestDir() as dirn:

            conf = {'bind': '127.0.0.1', 'host': 'localhost'}

            with self.getLoggerStream('synapse.lib.cell',
                                      'incompatible') as stream, s_cell.Cell(
                                          dirn, conf) as cell:

                user = cell.celluser
                addr = cell.getCellAddr()

                def bad_version_initiate(sess):
                    sess.link.tx(('helo', {
                        'version': (42, 42),
                        'ephem_pub': b'',
                        'cert': b''
                    }))

                with mock.patch('synapse.lib.cell.Sess._initiateSession',
                                bad_version_initiate):
                    self.raises(CellUserErr, user.open, addr, timeout=1)
            stream.seek(0)
            self.isin('incompatible version', stream.read())
Ejemplo n.º 4
0
    def test_neuron_cell_openlist(self):

        with self.getTestDir() as dirn:

            conf = {'bind': '127.0.0.1', 'host': 'localhost'}
            cell = s_cell.Cell(dirn)

            with s_cell.Cell(dirn, conf) as cell:

                user = s_cell.CellUser(cell.genUserAuth('foo'))
                addr = list(cell.getCellAddr())

                with user.open(addr, timeout=2) as sess:
                    with sess.task(('cell:ping', {'data': 'haha'})) as chan:
                        retn = chan.next(timeout=2)
                        self.eq(retn, 'haha')
                    retn = sess.call(('cell:ping', {'data': 'rofl'}), timeout=2)
                    self.eq(retn, 'rofl')
Ejemplo n.º 5
0
    def test_neuron_cell_authfail(self):
        '''
        Make a separate cell dir and make sure it can't connect to the first one
        '''
        with self.getTestDir() as dirn, self.getTestDir() as dirn2:

            conf = {'bind': '127.0.0.1', 'host': 'localhost'}

            with s_cell.Cell(dirn, conf) as cell, s_cell.Cell(dirn2) as newp:

                user = s_cell.CellUser(newp.getCellAuth())

                addr = cell.getCellAddr()

                with self.getLoggerStream('synapse.lib.cell') as stream:
                    self.raises(CellUserErr, user.open, addr, timeout=1)

                stream.seek(0)
                mesgs = stream.read()
                self.isin('got bad cert', mesgs)
Ejemplo n.º 6
0
    def test_neuron_cell_notok(self):

        with self.getTestDir() as dirn:

            conf = {'bind': '127.0.0.1', 'host': 'localhost'}

            with s_cell.Cell(dirn, conf) as cell:

                user = s_cell.CellUser(cell.genUserAuth('foo'))

                addr = ('localhost', 1)
                self.raises(CellUserErr, user.open, addr, timeout=1)
                self.raises(CellUserErr, user.open, addr, timeout=-1)
Ejemplo n.º 7
0
    def test_neuron_cell_cellAuth(self):

        with self.getTestDir() as dirn:

            conf = {'bind': '127.0.0.1', 'host': 'localhost'}

            with s_cell.Cell(dirn, conf) as cell:

                auth = cell.getCellAuth()
                self.nn(auth)
                self.isinstance(auth, tuple)
                self.len(2, auth)
                self.eq(auth[0], 'root')
                self.isinstance(auth[1], dict)
                self.isinstance(auth[1].get('cert'), bytes)
Ejemplo n.º 8
0
    def test_neuron_double_initiate(self):
        '''
        Have the initiator send the listener two session initiation messages
        '''

        with self.getTestDir() as dirn:

            conf = {'bind': '127.0.0.1', 'host': 'localhost'}

            with self.getLoggerStream('synapse.lib.cell', 'ProtoErr') as stream, s_cell.Cell(dirn, conf) as cell:

                user = cell.celluser
                addr = cell.getCellAddr()

                with user.open(addr, timeout=2) as sess:
                    sess._initiateSession()
                    self.true(stream.wait(2))
Ejemplo n.º 9
0
    def test_neuron_cell_ping(self):

        with self.getTestDir() as dirn:

            conf = {'bind': '127.0.0.1', 'host': 'localhost'}

            with s_cell.Cell(dirn, conf) as cell:

                user = cell.celluser
                addr = cell.getCellAddr()

                with user.open(addr, timeout=2) as sess:

                    with sess.task(('cell:ping', {'data': 'haha'})) as chan:

                        retn = chan.next(timeout=2)
                        self.eq(retn, 'haha')

                    retn = sess.call(('cell:ping', {'data': 'rofl'}), timeout=2)
                    self.eq(retn, 'rofl')
Ejemplo n.º 10
0
    def test_neuron_neuron(self):

        with self.getTestDir() as dirn:

            steps = self.getTestSteps(('cell:reg',))

            conf = {'host': 'localhost', 'bind': '127.0.0.1', 'port': 0}

            path = s_common.gendir(dirn, 'neuron')

            with s_neuron.Neuron(path, conf) as neur:

                cdef = neur.getConfDef('port')
                self.eq(s_neuron.defport, cdef[1].get('defval'))

                def onreg(mesg):
                    steps.done('cell:reg')

                neur.on('cell:reg', onreg)
                self.eq(neur._genCellName('root'), 'root@localhost')

                path = neur._path('admin.auth')
                auth = s_msgpack.loadfile(path)
                user = s_cell.CellUser(auth)

                pool = s_cell.CellPool(neur.genUserAuth('foo'), neur.getCellAddr())
                pool.neurok.wait(timeout=8)
                self.true(pool.neurok.is_set())

                with user.open(neur.getCellAddr()) as sess:

                    ncli = s_neuron.NeuronClient(sess)

                    auth = ncli.genCellAuth('cell00')
                    path = s_common.gendir(dirn, 'cell')

                    authpath = s_common.genpath(path, 'cell.auth')
                    s_msgpack.dumpfile(auth, authpath)

                    conf = {'host': 'localhost', 'bind': '127.0.0.1'}

                    with s_cell.Cell(path, conf) as cell:

                        steps.wait('cell:reg', timeout=3)
                        steps.clear('cell:reg')

                        # we should be able to get a session to him in the pool...
                        wait = pool.waiter(1, 'cell:add')
                        pool.add('cell00@localhost')

                        self.nn(wait.wait(timeout=3))
                        self.nn(pool.get('cell00@localhost'))

                        ok, cells = sess.call(('cell:list', {}))
                        self.true(ok)

                        self.eq(cells[0][0], 'cell00@localhost')

                        ok, info = sess.call(('cell:get', {'name': 'cell00@localhost'}))
                        self.true(ok)
                        self.eq(info['ctor'], 'synapse.lib.cell.Cell')

                        self.eq(info.get('addr'), cell.getCellAddr())

                    # he'll come up on a new port...
                    with TstCell(path, conf) as cell:

                        wait = pool.waiter(1, 'cell:add')

                        steps.wait('cell:reg', timeout=3)
                        steps.clear('cell:reg')

                        self.nn(wait.wait(timeout=3))
                        self.nn(pool.get('cell00@localhost'))

                        ok, info = sess.call(('cell:get', {'name': 'cell00@localhost'}))
                        self.true(ok)
                        self.eq(info['ctor'], 'synapse.tests.test_neuron.TstCell')

                        mesg = ('cell:ping', {'data': 'hehe'})
                        self.eq(pool.get('cell00@localhost').call(mesg), 'hehe')

                # since we have an active neuron, lets test the CLI tools here as well...
                authpath = os.path.join(dirn, 'neuron', 'admin.auth')
                savepath = os.path.join(dirn, 'woot.auth')

                argv = ['genauth', authpath, 'woot', savepath]
                outp = self.getTestOutp()

                s_tools_neuron.main(argv, outp=outp)

                self.true(outp.expect('saved woot'))
                self.true(outp.expect('woot.auth'))

                auth = s_msgpack.loadfile(savepath)

                self.eq(auth[0], 'woot@localhost')
                self.nn(auth[1].get('neuron'))

                # Use wootauth for provisioning a test cell

                steps.clear('cell:reg')

                path = gendir(dirn, 'wootcell')

                authpath = s_common.genpath(path, 'cell.auth')
                s_msgpack.dumpfile(auth, authpath)

                conf = {'host': 'localhost', 'bind': '127.0.0.1'}
                with s_cell.Cell(path, conf) as cell:

                    wait = pool.waiter(1, 'cell:add')
                    pool.add('woot@localhost')

                    steps.wait('cell:reg', timeout=3)

                    self.nn(wait.wait(timeout=3))
                    self.nn(pool.get('woot@localhost'))

                    mesg = ('cell:ping', {'data': 'w00t!'})
                    self.eq(pool.get('woot@localhost').call(mesg), 'w00t!')

                pool.fini()