client.py

#! /usr/bin/env python

"""
Run various tests, as a client.
"""

from __future__ import print_function

import argparse
try:
    import ConfigParser as configparser
except ImportError:
    import configparser
import functools
import logging
import os
import socket
import struct
import sys
import time
import traceback

import p9conn
import protocol

LocalError = p9conn.LocalError
RemoteError = p9conn.RemoteError
TEError = p9conn.TEError

class TestState(object):
    def __init__(self):
        self.config = None
        self.logger = None
        self.successes = 0
        self.skips = 0
        self.failures = 0
        self.exceptions = 0
        self.clnt_tab = {}
        self.mkclient = None
        self.stop = False
        self.gid = 0

    def ccc(self, cid=None):
        """
        Connect or reconnect as client (ccc = check and connect client).

        If caller provides a cid (client ID) we check that specific
        client.  Otherwise the default ID ('base') is used.
        In any case we return the now-connected client, plus the
        attachment (session info) if any.
        """
        if cid is None:
            cid = 'base'
        pair = self.clnt_tab.get(cid)
        if pair is None:
            clnt = self.mkclient()
            pair = [clnt, None]
            self.clnt_tab[cid] = pair
        else:
            clnt = pair[0]
        if not clnt.is_connected():
            clnt.connect()
        return pair

    def dcc(self, cid=None):
        """
        Disconnect client (disconnect checked client).  If no specific
        client ID is provided, this disconnects ALL checked clients!
        """
        if cid is None:
            for cid in list(self.clnt_tab.keys()):
                self.dcc(cid)
        pair = self.clnt_tab.get(cid)
        if pair is not None:
            clnt = pair[0]
            if clnt.is_connected():
                clnt.shutdown()
            del self.clnt_tab[cid]

    def ccs(self, cid=None):
        """
        Like ccc, but establish a session as well, by setting up
        the uname/n_uname.

        Return the client instance (only).
        """
        pair = self.ccc(cid)
        clnt = pair[0]
        if pair[1] is None:
            # No session yet - establish one.  Note, this may fail.
            section = None if cid is None else ('client-' + cid)
            aname = getconf(self.config, section, 'aname', '')
            uname = getconf(self.config, section, 'uname', '')
            if clnt.proto > protocol.plain:
                n_uname = getint(self.config, section, 'n_uname', 1001)
            else:
                n_uname = None
            clnt.attach(afid=None, aname=aname, uname=uname, n_uname=n_uname)
            pair[1] = (aname, uname, n_uname)
        return clnt

def getconf(conf, section, name, default=None, rtype=str):
    """
    Get configuration item for given section, or for "client" if
    there is no entry for that particular section (or if section
    is None).

    This lets us get specific values for specific tests or
    groups ([foo] name=value), falling back to general values
    ([client] name=value).

    The type of the returned value <rtype> can be str, int, bool,
    or float.  The default is str (and see getconfint, getconfbool,
    getconffloat below).

    A default value may be supplied; if it is, that's the default
    return value (this default should have the right type).  If
    no default is supplied, a missing value is an error.
    """
    try:
        # note: conf.get(None, 'foo') raises NoSectionError
        where = section
        result = conf.get(where, name)
    except (configparser.NoSectionError, configparser.NoOptionError):
        try:
            where = 'client'
            result = conf.get(where, name)
        except configparser.NoSectionError:
            sys.exit('no [{0}] section in configuration!'.format(where))
        except configparser.NoOptionError:
            if default is not None:
                return default
            if section is not None:
                where = '[{0}] or [{1}]'.format(section, where)
            else:
                where = '[{0}]'.format(where)
            raise LocalError('need {0}=value in {1}'.format(name, where))
    where = '[{0}]'.format(where)
    if rtype is str:
        return result
    if rtype is int:
        return int(result)
    if rtype is float:
        return float(result)
    if rtype is bool:
        if result.lower() in ('1', 't', 'true', 'y', 'yes'):
            return True
        if result.lower() in ('0', 'f', 'false', 'n', 'no'):
            return False
        raise ValueError('{0} {1}={2}: invalid boolean'.format(where, name,
                                                              result))
    raise ValueError('{0} {1}={2}: internal error: bad result type '
                     '{3!r}'.format(where, name, result, rtype))

def getint(conf, section, name, default=None):
    "get integer config item"
    return getconf(conf, section, name, default, int)

def getfloat(conf, section, name, default=None):
    "get float config item"
    return getconf(conf, section, name, default, float)

def getbool(conf, section, name, default=None):
    "get boolean config item"
    return getconf(conf, section, name, default, bool)

def pluralize(n, singular, plural):
    "return singular or plural based on value of n"
    return plural if n != 1 else singular

class TCDone(Exception):
    "used in succ/fail/skip - skips rest of testcase with"
    pass

class TestCase(object):
    """
    Start a test case.  Most callers must then do a ccs() to connect.

    A failed test will generally disconnect from the server; a
    new ccs() will reconnect, if the server is still alive.
    """
    def __init__(self, name, tstate):
        self.name = name
        self.status = None
        self.detail = None
        self.tstate = tstate
        self._shutdown = None
        self._autoclunk = None
        self._acconn = None

    def auto_disconnect(self, conn):
        self._shutdown = conn

    def succ(self, detail=None):
        "set success status"
        self.status = 'SUCC'
        self.detail = detail
        raise TCDone()

    def fail(self, detail):
        "set failure status"
        self.status = 'FAIL'
        self.detail = detail
        raise TCDone()

    def skip(self, detail=None):
        "set skip status"
        self.status = 'SKIP'
        self.detail = detail
        raise TCDone()

    def autoclunk(self, fid):
        "mark fid to be closed/clunked on test exit"
        if self._acconn is None:
            raise ValueError('autoclunk: no _acconn')
        self._autoclunk.append(fid)

    def trace(self, msg, *args, **kwargs):
        "add tracing info to log-file output"
        level = kwargs.pop('level', logging.INFO)
        self.tstate.logger.log(level, '      ' + msg, *args, **kwargs)

    def ccs(self):
        "call tstate ccs, turn socket.error connect failure into test fail"
        try:
            self.detail = 'connecting'
            ret = self.tstate.ccs()
            self.detail = None
            self._acconn = ret
            return ret
        except socket.error as err:
            self.fail(str(err))

    def __enter__(self):
        self.tstate.logger.log(logging.DEBUG, 'ENTER: %s', self.name)
        self._autoclunk = []
        return self

    def __exit__(self, exc_type, exc_val, exc_tb):
        tstate = self.tstate
        eat_exc = False
        tb_detail = None
        if exc_type is TCDone:
            # we exited with succ, fail, or skip
            eat_exc = True
            exc_type = None
        if exc_type is not None:
            if self.status is None:
                self.status = 'EXCP'
            else:
                self.status += ' EXC'
            if exc_type == TEError:
                # timeout/eof - best guess is that we crashed the server!
                eat_exc = True
                tb_detail = ['timeout or EOF']
            elif exc_type in (socket.error, RemoteError, LocalError):
                eat_exc = True
                tb_detail = traceback.format_exception(exc_type, exc_val,
                                                       exc_tb)
            level = logging.ERROR
            tstate.failures += 1
            tstate.exceptions += 1
        else:
            if self.status is None:
                self.status = 'SUCC'
            if self.status == 'SUCC':
                level = logging.INFO
                tstate.successes += 1
            elif self.status == 'SKIP':
                level = logging.INFO
                tstate.skips += 1
            else:
                level = logging.ERROR
                tstate.failures += 1
        tstate.logger.log(level, '%s: %s', self.status, self.name)
        if self.detail:
            tstate.logger.log(level, '      detail: %s', self.detail)
        if tb_detail:
            for line in tb_detail:
                tstate.logger.log(level, '      %s', line.rstrip())
        for fid in self._autoclunk:
            self._acconn.clunk(fid, ignore_error=True)
        if self._shutdown:
            self._shutdown.shutdown()
        return eat_exc

def main():
    "the usual main"
    parser = argparse.ArgumentParser(description='run tests against a server')

    parser.add_argument('-c', '--config',
        action='append',
        help='specify additional file(s) to read (beyond testconf.ini)')

    args = parser.parse_args()
    config = configparser.SafeConfigParser()
    # use case sensitive keys
    config.optionxform = str

    try:
        with open('testconf.ini', 'r') as stream:
            config.readfp(stream)
    except (OSError, IOError) as err:
        sys.exit(str(err))
    if args.config:
        ok = config.read(args.config)
        failed = set(ok) - set(args.config)
        if len(failed):
            nfailed = len(failed)
            word = 'files' if nfailed > 1 else 'file'
            failed = ', '.join(failed)
            print('failed to read {0} {1}: {2}'.format(nfailed, word, failed))
            sys.exit(1)

    logging.basicConfig(level=config.get('client', 'loglevel').upper())
    logger = logging.getLogger(__name__)
    tstate = TestState()
    tstate.logger = logger
    tstate.config = config

    server = config.get('client', 'server')
    port = config.getint('client', 'port')
    proto = config.get('client', 'protocol')
    may_downgrade = config.getboolean('client', 'may_downgrade')
    timeout = config.getfloat('client', 'timeout')

    tstate.stop = True # unless overwritten below
    with TestCase('send bad packet', tstate) as tc:
        tc.detail = 'connecting to {0}:{1}'.format(server, port)
        try:
            conn = p9conn.P9SockIO(logger, server=server, port=port)
        except socket.error as err:
            tc.fail('cannot connect at all (server down?)')
        tc.auto_disconnect(conn)
        tc.detail = None
        pkt = struct.pack('<I', 256);
        conn.write(pkt)
        # ignore reply if any, we're just trying to trip the server
        tstate.stop = False
        tc.succ()

    if not tstate.stop:
        tstate.mkclient = functools.partial(p9conn.P9Client, logger,
                                           timeout, proto, may_downgrade,
                                           server=server, port=port)
        tstate.stop = True
        with TestCase('send bad Tversion', tstate) as tc:
            try:
                clnt = tstate.mkclient()
            except socket.error as err:
                tc.fail('can no longer connect, did bad pkt crash server?')
            tc.auto_disconnect(clnt)
            clnt.set_monkey('version', b'wrongo, fishbreath!')
            tc.detail = 'connecting'
            try:
                clnt.connect()
            except RemoteError as err:
                tstate.stop = False
                tc.succ(err.args[0])
            tc.fail('server accepted a bad Tversion')

    if not tstate.stop:
        # All NUL characters in strings are invalid.
        with TestCase('send illegal NUL in Tversion', tstate) as tc:
            clnt = tstate.mkclient()
            tc.auto_disconnect(clnt)
            clnt.set_monkey('version', b'9P2000\0')
            # Forcibly allow downgrade so that Tversion
            # succeeds if they ignore the \0.
            clnt.may_downgrade = True
            tc.detail = 'connecting'
            try:
                clnt.connect()
            except (TEError, RemoteError) as err:
                tc.succ(err.args[0])
            tc.fail('server accepted NUL in Tversion')

    if not tstate.stop:
        with TestCase('connect normally', tstate) as tc:
            tc.detail = 'connecting'
            try:
                tstate.ccc()
            except RemoteError as err:
                # can't test any further, but this might be success
                tstate.stop = True
                if 'they only support version' in err.args[0]:
                    tc.succ(err.args[0])
                tc.fail(err.args[0])
            tc.succ()

    if not tstate.stop:
        with TestCase('attach with bad afid', tstate) as tc:
            clnt = tstate.ccc()[0]
            section = 'attach-with-bad-afid'
            aname = getconf(tstate.config, section, 'aname', '')
            uname = getconf(tstate.config, section, 'uname', '')
            if clnt.proto > protocol.plain:
                n_uname = getint(tstate.config, section, 'n_uname', 1001)
            else:
                n_uname = None
            try:
                clnt.attach(afid=42, aname=aname, uname=uname, n_uname=n_uname)
            except RemoteError as err:
                tc.succ(err.args[0])
            tc.dcc()
            tc.fail('bad attach afid not rejected')

    try:
        if not tstate.stop:
            # Various Linux tests need gids.  Just get them for everyone.
            tstate.gid = getint(tstate.config, 'client', 'gid', 0)
            more_test_cases(tstate)
    finally:
        tstate.dcc()

    n_tests = tstate.successes + tstate.failures
    print('summary:')
    if tstate.successes:
        print('{0}/{1} tests succeeded'.format(tstate.successes, n_tests))
    if tstate.failures:
        print('{0}/{1} tests failed'.format(tstate.failures, n_tests))
    if tstate.skips:
        print('{0} {1} skipped'.format(tstate.skips,
                                       pluralize(tstate.skips,
                                                 'test', 'tests')))
    if tstate.exceptions:
        print('{0} {1} occurred'.format(tstate.exceptions,
                                       pluralize(tstate.exceptions,
                                                 'exception', 'exceptions')))
    if tstate.stop:
        print('tests stopped early')
    return 1 if tstate.stop or tstate.exceptions or tstate.failures else 0

def more_test_cases(tstate):
    "run cases that can only proceed if connecting works at all"
    with TestCase('attach normally', tstate) as tc:
        tc.ccs()
        tc.succ()
    if tstate.stop:
        return

    # Empty string is not technically illegal.  It's not clear
    # whether it should be accepted or rejected.  However, it
    # used to crash the server entirely, so it's a desirable
    # test case.
    with TestCase('empty string in Twalk request', tstate) as tc:
        clnt = tc.ccs()
        try:
            fid, qid = clnt.lookup(clnt.rootfid, [b''])
        except RemoteError as err:
            tc.succ(err.args[0])
        clnt.clunk(fid)
        tc.succ('note: empty Twalk component name not rejected')

    # Name components may not contain /
    with TestCase('embedded / in lookup component name', tstate) as tc:
        clnt = tc.ccs()
        try:
            fid, qid = clnt.lookup(clnt.rootfid, [b'/'])
            tc.autoclunk(fid)
        except RemoteError as err:
            tc.succ(err.args[0])
        tc.fail('/ in lookup component name not rejected')

    # Proceed from a clean tree.  As a side effect, this also tests
    # either the old style readdir (read() on a directory fid) or
    # the dot-L readdir().
    #
    # The test case will fail if we don't have permission to remove
    # some file(s).
    with TestCase('clean up tree (readdir+remove)', tstate) as tc:
        clnt = tc.ccs()
        fset = clnt.uxreaddir(b'/')
        fset = [i for i in fset if i != '.' and i != '..']
        tc.trace("what's there initially: {0!r}".format(fset))
        try:
            clnt.uxremove(b'/', force=False, recurse=True)
        except RemoteError as err:
            tc.trace('failed to read or clean up tree', level=logging.ERROR)
            tc.trace('this might be a permissions error', level=logging.ERROR)
            tstate.stop = True
            tc.fail(str(err))
        fset = clnt.uxreaddir(b'/')
        fset = [i for i in fset if i != '.' and i != '..']
        tc.trace("what's left after removing everything: {0!r}".format(fset))
        if fset:
            tstate.stop = True
            tc.trace('note: could be a permissions error', level=logging.ERROR)
            tc.fail('/ not empty after removing all: {0!r}'.format(fset))
        tc.succ()
    if tstate.stop:
        return

    # Name supplied to create, mkdir, etc, may not contain /.
    # Note that this test may fail for the wrong reason if /dir
    # itself does not already exist, so first let's make /dir.
    only_dotl = getbool(tstate.config, 'client', 'only_dotl', False)
    with TestCase('mkdir', tstate) as tc:
        clnt = tc.ccs()
        if only_dotl and not clnt.supports(protocol.td.Tmkdir):
            tc.skip('cannot test dot-L mkdir on {0}'.format(clnt.proto))
        try:
            fid, qid = clnt.uxlookup(b'/dir', None)
            tc.autoclunk(fid)
            tstate.stop = True
            tc.fail('found existing /dir after cleaning tree')
        except RemoteError as err:
            # we'll just assume it's "no such file or directory"
            pass
        if only_dotl:
            qid = clnt.mkdir(clnt.rootfid, b'dir', 0o777, tstate.gid)
        else:
            qid, _ = clnt.create(clnt.rootfid, b'dir',
                                 protocol.td.DMDIR | 0o777,
                                 protocol.td.OREAD)
        if qid.type != protocol.td.QTDIR:
            tstate.stop = True
            tc.fail('creating /dir: result is not a directory')
        tc.trace('now attempting to create /dir/sub the wrong way')
        try:
            if only_dotl:
                qid = clnt.mkdir(clnt.rootfid, b'dir/sub', 0o777, tstate.gid)
            else:
                qid, _ = clnt.create(clnt.rootfid, b'dir/sub',
                                     protocol.td.DMDIR | 0o777,
                                     protocol.td.OREAD)
            # it's not clear what happened on the server at this point!
            tc.trace("creating dir/sub (with embedded '/') should have "
                     'failed but did not')
            tstate.stop = True
            fset = clnt.uxreaddir(b'/dir')
            if 'sub' in fset:
                tc.trace('(found our dir/sub detritus)')
                clnt.uxremove(b'dir/sub', force=True)
                fset = clnt.uxreaddir(b'/dir')
                if 'sub' not in fset:
                    tc.trace('(successfully removed our dir/sub detritus)')
                    tstate.stop = False
            tc.fail('created dir/sub as single directory with embedded slash')
        except RemoteError as err:
            # we'll just assume it's the right kind of error
            tc.trace('invalid path dir/sub failed with: %s', str(err))
            tc.succ('embedded slash in mkdir correctly refused')
    if tstate.stop:
        return

    with TestCase('getattr/setattr', tstate) as tc:
        # This test is not really thorough enough, need to test
        # all combinations of settings.  Should also test that
        # old values are restored on failure, although it is not
        # clear how to trigger failures.
        clnt = tc.ccs()
        if not clnt.supports(protocol.td.Tgetattr):
            tc.skip('%s does not support Tgetattr', clnt)
        fid, _, _, _ = clnt.uxopen(b'/dir/file', os.O_CREAT | os.O_RDWR, 0o666,
            gid=tstate.gid)
        tc.autoclunk(fid)
        written = clnt.write(fid, 0, 'bytes\n')
        if written != 6:
            tc.trace('expected to write 6 bytes, actually wrote %d', written,
                     level=logging.WARN)
        attrs = clnt.Tgetattr(fid)
        #tc.trace('getattr: after write, before setattr: got %s', attrs)
        if attrs.size != written:
            tc.fail('getattr: expected size=%d, got size=%d',
                    written, attrs.size)
        # now truncate, set mtime to (3,14), and check result
        set_time_to = p9conn.Timespec(sec=0, nsec=140000000)
        clnt.Tsetattr(fid, size=0, mtime=set_time_to)
        attrs = clnt.Tgetattr(fid)
        #tc.trace('getattr: after setattr: got %s', attrs)
        if attrs.mtime.sec != set_time_to.sec or attrs.size != 0:
            tc.fail('setattr: expected to get back mtime.sec={0}, size=0; '
                    'got mtime.sec={1}, size='
                    '{1}'.format(set_time_to.sec, attrs.mtime.sec, attrs.size))
        # nsec is not as stable but let's check
        if attrs.mtime.nsec != set_time_to.nsec:
            tc.trace('setattr: expected to get back mtime_nsec=%d; '
                     'got %d', set_time_to.nsec, mtime_nsec)
        tc.succ('able to set and see size and mtime')

    # this test should be much later, but we know the current
    # server is broken...
    with TestCase('rename adjusts other fids', tstate) as tc:
        clnt = tc.ccs()
        dirfid, _ = clnt.uxlookup(b'/dir')
        tc.autoclunk(dirfid)
        clnt.uxmkdir(b'd1', 0o777, tstate.gid, startdir=dirfid)
        clnt.uxmkdir(b'd1/sub', 0o777, tstate.gid, startdir=dirfid)
        d1fid, _ = clnt.uxlookup(b'd1', dirfid)
        tc.autoclunk(d1fid)
        subfid, _ = clnt.uxlookup(b'sub', d1fid)
        tc.autoclunk(subfid)
        fid, _, _, _ = clnt.uxopen(b'file', os.O_CREAT | os.O_RDWR,
                                   0o666, startdir=subfid, gid=tstate.gid)
        tc.autoclunk(fid)
        written = clnt.write(fid, 0, 'filedata\n')
        if written != 9:
            tc.trace('expected to write 9 bytes, actually wrote %d', written,
                     level=logging.WARN)
        # Now if we rename /dir/d1 to /dir/d2, the fids for both
        # sub/file and sub itself should still be usable.  This
        # holds for both Trename (Linux only) and Twstat based
        # rename ops.
        #
        # Note that some servers may cache some number of files and/or
        # diretories held open, so we should open many fids to wipe
        # out the cache (XXX notyet).
        if clnt.supports(protocol.td.Trename):
            clnt.rename(d1fid, dirfid, name=b'd2')
        else:
            clnt.wstat(d1fid, name=b'd2')
        try:
            rofid, _, _, _ = clnt.uxopen(b'file', os.O_RDONLY, startdir=subfid)
            clnt.clunk(rofid)
        except RemoteError as err:
            tc.fail('open file in renamed dir/d2/sub: {0}'.format(err))
        tc.succ()

    # Even if xattrwalk is supported by the protocol, it's optional
    # on the server.
    with TestCase('xattrwalk', tstate) as tc:
        clnt = tc.ccs()
        if not clnt.supports(protocol.td.Txattrwalk):
            tc.skip('{0} does not support Txattrwalk'.format(clnt))
        dirfid, _ = clnt.uxlookup(b'/dir')
        tc.autoclunk(dirfid)
        try:
            # need better tests...
            attrfid, size = clnt.xattrwalk(dirfid)
            tc.autoclunk(attrfid)
            data = clnt.read(attrfid, 0, size)
            tc.trace('xattrwalk with no name: data=%r', data)
            tc.succ('xattrwalk size={0} datalen={1}'.format(size, len(data)))
        except RemoteError as err:
            tc.trace('xattrwalk on /dir: {0}'.format(err))
        tc.succ('xattrwalk apparently not implemented')

if __name__ == '__main__':
    try:
        sys.exit(main())
    except KeyboardInterrupt:
        sys.exit('\nInterrupted')