コード例 #1
0
ファイル: test_fs.py プロジェクト: cbenhagen/python-llfuse
def testfs(tmpdir):

    # We can't use forkserver because we have to make sure
    # that the server inherits the per-test stdout/stderr file
    # descriptors.
    if hasattr(multiprocessing, 'get_context'):
        mp = multiprocessing.get_context('fork')
    else:
        # Older versions only support *fork* anyway
        mp = multiprocessing
    if threading.active_count() != 1:
        raise RuntimeError("Multi-threaded test running is not supported")

    mnt_dir = str(tmpdir)
    with mp.Manager() as mgr:
        cross_process = mgr.Namespace()
        mount_process = mp.Process(target=run_fs,
                                   args=(mnt_dir, cross_process))

        mount_process.start()
        try:
            wait_for_mount(mount_process, mnt_dir)
            yield (mnt_dir, cross_process)
        except:
            cleanup(mnt_dir)
            raise
        else:
            umount(mount_process, mnt_dir)
コード例 #2
0
ファイル: test_examples.py プロジェクト: CameronOC/libfuse
def test_fusexmp_fh(tmpdir, name):
    mnt_dir = str(tmpdir.mkdir('mnt'))
    src_dir = str(tmpdir.mkdir('src'))

    cmdline = [os.path.join(basename, 'example', name),
                '-f', '-o' , 'use_ino,readdir_ino,kernel_cache',
                mnt_dir ]
    mount_process = subprocess.Popen(cmdline)
    try:
        wait_for_mount(mount_process, mnt_dir)
        work_dir = os.path.join(mnt_dir, src_dir)
        tst_write(work_dir)
        tst_mkdir(work_dir)
        tst_symlink(work_dir)
        tst_mknod(work_dir)
        if os.getuid() == 0:
            tst_chown(work_dir)
        # Underlying fs may not have full nanosecond resolution
        tst_utimens(work_dir, ns_tol=1000)
        tst_link(work_dir)
        tst_readdir(work_dir)
        tst_statvfs(work_dir)
        tst_truncate_path(work_dir)
        tst_truncate_fd(work_dir)
        tst_unlink(work_dir)
        tst_passthrough(src_dir, work_dir)
    except:
        cleanup(mnt_dir)
        raise
    else:
        umount(mount_process, mnt_dir)
コード例 #3
0
def test_notify_inval_entry(tmpdir, notify):
    mnt_dir = str(tmpdir)
    cmdline = base_cmdline + \
              [ pjoin(basename, 'example', 'notify_inval_entry'),
                '-f', '--update-interval=1',
                '--timeout=5', mnt_dir ]
    if not notify:
        cmdline.append('--no-notify')
    mount_process = subprocess.Popen(cmdline)
    try:
        wait_for_mount(mount_process, mnt_dir)
        fname = pjoin(mnt_dir, os.listdir(mnt_dir)[0])
        try:
            os.stat(fname)
        except FileNotFoundError:
            # We may have hit a race condition and issued
            # readdir just before the name changed
            fname = pjoin(mnt_dir, os.listdir(mnt_dir)[0])
            os.stat(fname)

        safe_sleep(2)
        if not notify:
            os.stat(fname)
            safe_sleep(5)
        with pytest.raises(FileNotFoundError):
            os.stat(fname)
    except:
        cleanup(mnt_dir)
        raise
    else:
        umount(mount_process, mnt_dir)
コード例 #4
0
ファイル: test_examples.py プロジェクト: everbase/libfuse
def test_ioctl(tmpdir):
    progname = pjoin(basename, 'example', 'ioctl')
    if not os.path.exists(progname):
        pytest.skip('%s not built' % os.path.basename(progname))
    
    mnt_dir = str(tmpdir)
    testfile = pjoin(mnt_dir, 'fioc')
    cmdline = base_cmdline + [progname, '-f', mnt_dir ]
    mount_process = subprocess.Popen(cmdline)
    try:
        wait_for_mount(mount_process, mnt_dir)

        cmdline = base_cmdline + \
                  [ pjoin(basename, 'example', 'ioctl_client'),
                    testfile ]
        assert subprocess.check_output(cmdline) == b'0\n'
        with open(testfile, 'wb') as fh:
            fh.write(b'foobar')
        assert subprocess.check_output(cmdline) == b'6\n'
        subprocess.check_call(cmdline + [ '3' ])
        with open(testfile, 'rb') as fh:
            assert fh.read()== b'foo'
    except:
        cleanup(mnt_dir)
        raise
    else:
        umount(mount_process, mnt_dir)
コード例 #5
0
def startup(client, params):
    c = None

    # detect if the collector already exists in the portal
    f = collector.find_collector(client, params)
    if not f:
        logging.debug('Collector not found')
        c = collector.collector(client, params)
        c = collector.create_collector(client, c)
    else:
        logging.debug('Collector found')
        c = f

        # we want to make a note on the fs that we found an existing collector
        # so that we don't remove it during a future cleanup, but we should
        # only make this note if this is the first time the container is run
        # (otherwise, every subsequent should detect the existing collector
        # that we're going to create below. Not the behavior we want)
        if not os.path.isfile(config.FIRST_RUN):
            util.touch(config.COLLECTOR_FOUND)

    # let subsequent runs know that this isn't the first container run
    util.touch(config.FIRST_RUN)

    # detect if collector is already installed
    if os.path.isdir(config.INSTALL_PATH + config.AGENT_DIRECTORY):
        logging.debug('Collector already installed.')
        util.cleanup()
        return
    collector.install_collector(client, c, params)
コード例 #6
0
ファイル: test_fs.py プロジェクト: mkhon/python-llfuse
def testfs(tmpdir):

    # We can't use forkserver or spawn because of
    # https://github.com/pytest-dev/pytest/issues/958.
    if hasattr(multiprocessing, 'get_context'):
        mp = multiprocessing.get_context('fork')
    else:
        # Older versions only support *fork* anyway
        mp = multiprocessing
    if threading.active_count() != 1:
        raise RuntimeError("Multi-threaded test running is not supported")

    mnt_dir = str(tmpdir)
    with mp.Manager() as mgr:
        cross_process = mgr.Namespace()
        mount_process = mp.Process(target=run_fs,
                                   args=(mnt_dir, cross_process))

        mount_process.start()
        try:
            wait_for_mount(mount_process, mnt_dir)
            yield (mnt_dir, cross_process)
        except:
            cleanup(mnt_dir)
            raise
        else:
            umount(mount_process, mnt_dir)
コード例 #7
0
def test_tmpfs(tmpdir):
    mnt_dir = str(tmpdir)
    cmdline = [sys.executable,
               os.path.join(basename, 'examples', 'tmpfs.py'),
               mnt_dir ]
    mount_process = subprocess.Popen(cmdline, stdin=subprocess.DEVNULL,
                                     universal_newlines=True)
    try:
        wait_for_mount(mount_process, mnt_dir)
        tst_write(mnt_dir)
        tst_mkdir(mnt_dir)
        tst_symlink(mnt_dir)
        tst_mknod(mnt_dir)
        tst_chown(mnt_dir)
        tst_chmod(mnt_dir)
        tst_utimens(mnt_dir)
        tst_link(mnt_dir)
        tst_readdir(mnt_dir)
        tst_statvfs(mnt_dir)
        tst_truncate_path(mnt_dir)
        tst_truncate_fd(mnt_dir)
        tst_unlink(mnt_dir)
    except:
        cleanup(mnt_dir)
        raise
    else:
        umount(mount_process, mnt_dir)
コード例 #8
0
ファイル: test_examples.py プロジェクト: johanalenius/main
def test_passthroughfs(tmpdir):
    mnt_dir = str(tmpdir.mkdir("mnt"))
    src_dir = str(tmpdir.mkdir("src"))
    cmdline = [sys.executable, os.path.join(basename, "examples", "passthroughfs.py"), src_dir, mnt_dir]
    mount_process = subprocess.Popen(cmdline, stdin=subprocess.DEVNULL, universal_newlines=True)
    try:
        wait_for_mount(mount_process, mnt_dir)
        tst_write(mnt_dir)
        tst_mkdir(mnt_dir)
        tst_symlink(mnt_dir)
        tst_mknod(mnt_dir)
        if os.getuid() == 0:
            tst_chown(mnt_dir)
        # Underlying fs may not have full nanosecond resolution
        tst_utimens(mnt_dir, ns_tol=1000)
        tst_link(mnt_dir)
        tst_readdir(mnt_dir)
        tst_statvfs(mnt_dir)
        tst_truncate(mnt_dir)
        tst_passthrough(src_dir, mnt_dir)
    except:
        cleanup(mnt_dir)
        raise
    else:
        umount(mount_process, mnt_dir)
コード例 #9
0
ファイル: test_examples.py プロジェクト: xuze1993/pyfuse3
def test_hello(tmpdir, filename):
    mnt_dir = str(tmpdir)
    cmdline = [
        sys.executable,
        os.path.join(basename, 'examples', filename), mnt_dir
    ]
    mount_process = subprocess.Popen(cmdline,
                                     stdin=subprocess.DEVNULL,
                                     universal_newlines=True)
    try:
        wait_for_mount(mount_process, mnt_dir)
        assert os.listdir(mnt_dir) == ['message']
        filename = os.path.join(mnt_dir, 'message')
        with open(filename, 'r') as fh:
            assert fh.read() == 'hello world\n'
        with pytest.raises(IOError) as exc_info:
            open(filename, 'r+')
        assert exc_info.value.errno == errno.EACCES
        with pytest.raises(IOError) as exc_info:
            open(filename + 'does-not-exist', 'r+')
        assert exc_info.value.errno == errno.ENOENT
    except:
        cleanup(mount_process, mnt_dir)
        raise
    else:
        umount(mount_process, mnt_dir)
コード例 #10
0
ファイル: test_examples.py プロジェクト: xuze1993/pyfuse3
def test_tmpfs(tmpdir):
    mnt_dir = str(tmpdir)
    cmdline = [
        sys.executable,
        os.path.join(basename, 'examples', 'tmpfs.py'), mnt_dir
    ]
    mount_process = subprocess.Popen(cmdline,
                                     stdin=subprocess.DEVNULL,
                                     universal_newlines=True)
    try:
        wait_for_mount(mount_process, mnt_dir)
        tst_write(mnt_dir)
        tst_mkdir(mnt_dir)
        tst_symlink(mnt_dir)
        tst_mknod(mnt_dir)
        tst_chown(mnt_dir)
        tst_chmod(mnt_dir)
        tst_utimens(mnt_dir)
        tst_link(mnt_dir)
        tst_rename(mnt_dir)
        tst_readdir(mnt_dir)
        tst_statvfs(mnt_dir)
        tst_truncate_path(mnt_dir)
        tst_truncate_fd(mnt_dir)
        tst_unlink(mnt_dir)
    except:
        cleanup(mount_process, mnt_dir)
        raise
    else:
        umount(mount_process, mnt_dir)
コード例 #11
0
def test_hello(tmpdir, name, options):
    mnt_dir = str(tmpdir)
    cmdline = base_cmdline + \
              [ pjoin(basename, 'example', name),
                '-f', mnt_dir ] + options
    if name == 'hello_ll':
        # supports single-threading only
        cmdline.append('-s')
    mount_process = subprocess.Popen(cmdline)
    try:
        wait_for_mount(mount_process, mnt_dir)
        assert os.listdir(mnt_dir) == [ 'hello' ]
        filename = pjoin(mnt_dir, 'hello')
        with open(filename, 'r') as fh:
            assert fh.read() == 'Hello World!\n'
        with pytest.raises(IOError) as exc_info:
            open(filename, 'r+')
        assert exc_info.value.errno == errno.EACCES
        with pytest.raises(IOError) as exc_info:
            open(filename + 'does-not-exist', 'r+')
        assert exc_info.value.errno == errno.ENOENT
    except:
        cleanup(mnt_dir)
        raise
    else:
        umount(mount_process, mnt_dir)
コード例 #12
0
def test_fusexmp_fh(tmpdir, name):
    mnt_dir = str(tmpdir.mkdir('mnt'))
    src_dir = str(tmpdir.mkdir('src'))

    cmdline = base_cmdline + \
              [ pjoin(basename, 'example', name),
                '-f', '-o', 'use_ino,readdir_ino,kernel_cache',
                mnt_dir ]
    mount_process = subprocess.Popen(cmdline)
    try:
        wait_for_mount(mount_process, mnt_dir)
        work_dir = pjoin(mnt_dir, src_dir)
        tst_write(work_dir)
        tst_mkdir(work_dir)
        tst_symlink(work_dir)
        tst_mknod(work_dir)
        if os.getuid() == 0:
            tst_chown(work_dir)
        # Underlying fs may not have full nanosecond resolution
        tst_utimens(work_dir, ns_tol=1000)
        tst_link(work_dir)
        tst_readdir(work_dir)
        tst_statvfs(work_dir)
        tst_truncate_path(work_dir)
        tst_truncate_fd(work_dir)
        tst_unlink(work_dir)
        tst_passthrough(src_dir, work_dir)
    except:
        cleanup(mnt_dir)
        raise
    else:
        umount(mount_process, mnt_dir)
コード例 #13
0
def testfs(tmpdir):

    # We can't use forkserver because we have to make sure
    # that the server inherits the per-test stdout/stderr file
    # descriptors.
    if hasattr(multiprocessing, 'get_context'):
        mp = multiprocessing.get_context('fork')
    else:
        # Older versions only support *fork* anyway
        mp = multiprocessing
    if threading.active_count() != 1:
        raise RuntimeError("Multi-threaded test running is not supported")

    mnt_dir = str(tmpdir)
    with mp.Manager() as mgr:
        cross_process = mgr.Namespace()
        mount_process = mp.Process(target=run_fs,
                                   args=(mnt_dir, cross_process))

        mount_process.start()
        try:
            wait_for_mount(mount_process, mnt_dir)
            yield (mnt_dir, cross_process)
        except:
            cleanup(mnt_dir)
            raise
        else:
            umount(mount_process, mnt_dir)
コード例 #14
0
ファイル: test_examples.py プロジェクト: everbase/libfuse
def test_notify_inval_entry(tmpdir, notify):
    mnt_dir = str(tmpdir)
    cmdline = base_cmdline + \
              [ pjoin(basename, 'example', 'notify_inval_entry'),
                '-f', '--update-interval=1',
                '--timeout=5', mnt_dir ]
    if not notify:
        cmdline.append('--no-notify')
    mount_process = subprocess.Popen(cmdline)
    try:
        wait_for_mount(mount_process, mnt_dir)
        fname = pjoin(mnt_dir, os.listdir(mnt_dir)[0])
        try:
            os.stat(fname)
        except FileNotFoundError:
            # We may have hit a race condition and issued
            # readdir just before the name changed
            fname = pjoin(mnt_dir, os.listdir(mnt_dir)[0])
            os.stat(fname)

        safe_sleep(2)
        if not notify:
            os.stat(fname)
            safe_sleep(5)
        with pytest.raises(FileNotFoundError):
            os.stat(fname)
    except:
        cleanup(mnt_dir)
        raise
    else:
        umount(mount_process, mnt_dir)
コード例 #15
0
def test_null(tmpdir):
    progname = pjoin(basename, 'example', 'null')
    if not os.path.exists(progname):
        pytest.skip('%s not built' % os.path.basename(progname))

    mnt_file = str(tmpdir) + '/file'
    with open(mnt_file, 'w') as fh:
        fh.write('dummy')
    cmdline = base_cmdline + [progname, '-f', mnt_file]
    mount_process = subprocess.Popen(cmdline)

    def test_fn(name):
        return os.stat(name).st_size > 4000

    try:
        wait_for_mount(mount_process, mnt_file, test_fn)
        with open(mnt_file, 'rb') as fh:
            assert fh.read(382) == b'\0' * 382
        with open(mnt_file, 'wb') as fh:
            fh.write(b'whatever')
    except:
        cleanup(mnt_file)
        raise
    else:
        umount(mount_process, mnt_file)
コード例 #16
0
def test_ioctl(tmpdir):
    progname = pjoin(basename, 'example', 'ioctl')
    if not os.path.exists(progname):
        pytest.skip('%s not built' % os.path.basename(progname))

    mnt_dir = str(tmpdir)
    testfile = pjoin(mnt_dir, 'fioc')
    cmdline = base_cmdline + [progname, '-f', mnt_dir]
    mount_process = subprocess.Popen(cmdline)
    try:
        wait_for_mount(mount_process, mnt_dir)

        cmdline = base_cmdline + \
                  [ pjoin(basename, 'example', 'ioctl_client'),
                    testfile ]
        assert subprocess.check_output(cmdline) == b'0\n'
        with open(testfile, 'wb') as fh:
            fh.write(b'foobar')
        assert subprocess.check_output(cmdline) == b'6\n'
        subprocess.check_call(cmdline + ['3'])
        with open(testfile, 'rb') as fh:
            assert fh.read() == b'foo'
    except:
        cleanup(mnt_dir)
        raise
    else:
        umount(mount_process, mnt_dir)
コード例 #17
0
ファイル: test_ctests.py プロジェクト: gzhang91/fastcfs_study
def test_notify1(tmpdir, name, notify, output_checker):
    mnt_dir = str(tmpdir)
    cmdline = base_cmdline + \
              [ pjoin(basename, 'example', name),
                '-f', '--update-interval=1', mnt_dir ]
    if not notify:
        cmdline.append('--no-notify')
    mount_process = subprocess.Popen(cmdline, stdout=output_checker.fd,
                                     stderr=output_checker.fd)
    try:
        wait_for_mount(mount_process, mnt_dir)
        filename = pjoin(mnt_dir, 'current_time')
        with open(filename, 'r') as fh:
            read1 = fh.read()
        safe_sleep(2)
        with open(filename, 'r') as fh:
            read2 = fh.read()
        if notify:
            assert read1 != read2
        else:
            assert read1 == read2
    except:
        cleanup(mount_process, mnt_dir)
        raise
    else:
        umount(mount_process, mnt_dir)
コード例 #18
0
ファイル: test_examples.py プロジェクト: everbase/libfuse
def test_hello(tmpdir, name, options):
    mnt_dir = str(tmpdir)
    cmdline = base_cmdline + \
              [ pjoin(basename, 'example', name),
                '-f', mnt_dir ] + options
    if name == 'hello_ll':
        # supports single-threading only
        cmdline.append('-s')
    mount_process = subprocess.Popen(cmdline)
    try:
        wait_for_mount(mount_process, mnt_dir)
        assert os.listdir(mnt_dir) == [ 'hello' ]
        filename = pjoin(mnt_dir, 'hello')
        with open(filename, 'r') as fh:
            assert fh.read() == 'Hello World!\n'
        with pytest.raises(IOError) as exc_info:
            open(filename, 'r+')
        assert exc_info.value.errno == errno.EACCES
        with pytest.raises(IOError) as exc_info:
            open(filename + 'does-not-exist', 'r+')
        assert exc_info.value.errno == errno.ENOENT
    except:
        cleanup(mnt_dir)
        raise
    else:
        umount(mount_process, mnt_dir)
コード例 #19
0
ファイル: test_examples.py プロジェクト: xuze1993/pyfuse3
def test_passthroughfs(tmpdir):
    mnt_dir = str(tmpdir.mkdir('mnt'))
    src_dir = str(tmpdir.mkdir('src'))
    cmdline = [
        sys.executable,
        os.path.join(basename, 'examples', 'passthroughfs.py'), src_dir,
        mnt_dir
    ]
    mount_process = subprocess.Popen(cmdline,
                                     stdin=subprocess.DEVNULL,
                                     universal_newlines=True)
    try:
        wait_for_mount(mount_process, mnt_dir)
        tst_write(mnt_dir)
        tst_mkdir(mnt_dir)
        tst_symlink(mnt_dir)
        tst_mknod(mnt_dir)
        if os.getuid() == 0:
            tst_chown(mnt_dir)
        tst_chmod(mnt_dir)
        # Underlying fs may not have full nanosecond resolution
        tst_utimens(mnt_dir, ns_tol=1000)
        tst_link(mnt_dir)
        tst_rename(mnt_dir)
        tst_readdir(mnt_dir)
        tst_statvfs(mnt_dir)
        tst_truncate_path(mnt_dir)
        tst_truncate_fd(mnt_dir)
        tst_unlink(mnt_dir)
        tst_passthrough(src_dir, mnt_dir)
    except:
        cleanup(mount_process, mnt_dir)
        raise
    else:
        umount(mount_process, mnt_dir)
コード例 #20
0
ファイル: test_ctests.py プロジェクト: everbase/libfuse
def test_notify1(tmpdir, name, notify):
    mnt_dir = str(tmpdir)
    cmdline = base_cmdline + \
              [ pjoin(basename, 'example', name),
                '-f', '--update-interval=1', mnt_dir ]
    if not notify:
        cmdline.append('--no-notify')
    mount_process = subprocess.Popen(cmdline)
    try:
        wait_for_mount(mount_process, mnt_dir)
        filename = pjoin(mnt_dir, 'current_time')
        with open(filename, 'r') as fh:
            read1 = fh.read()
        safe_sleep(2)
        with open(filename, 'r') as fh:
            read2 = fh.read()
        if notify:
            assert read1 != read2
        else:
            assert read1 == read2
    except:
        cleanup(mnt_dir)
        raise
    else:
        umount(mount_process, mnt_dir)
コード例 #21
0
 def cleanup(self):
     """
     Cleanup when exiting with an error.
     """
     logger.error('Current active backup: {}'.format(os.path.realpath(self.current_target_dir)))
     logger.error('Remove active backup and restore symlink to newest bakup')
     util.cleanup(self.current_target_dir)
     self.current_target_dir = None
     os.remove(self.settings['lockfile'])
コード例 #22
0
def test_passthrough(tmpdir, name, debug, capfd):

    # Avoid false positives from libfuse debug messages
    if debug:
        capfd.register_output(r'^   unique: [0-9]+, error: -[0-9]+ .+$',
                              count=0)

    # test_syscalls prints "No error" under FreeBSD
    capfd.register_output(r"^ \d\d \[[^\]]+ message: 'No error: 0'\]", count=0)

    mnt_dir = str(tmpdir.mkdir('mnt'))
    src_dir = str(tmpdir.mkdir('src'))

    cmdline = base_cmdline + \
              [ pjoin(basename, 'example', name),
                '-f', mnt_dir ]
    if debug:
        cmdline.append('-d')
    mount_process = subprocess.Popen(cmdline)
    try:
        wait_for_mount(mount_process, mnt_dir)
        work_dir = mnt_dir + src_dir

        tst_statvfs(work_dir)
        tst_readdir(src_dir, work_dir)
        tst_open_read(src_dir, work_dir)
        tst_open_write(src_dir, work_dir)
        tst_create(work_dir)
        tst_passthrough(src_dir, work_dir)
        tst_append(src_dir, work_dir)
        tst_seek(src_dir, work_dir)
        tst_mkdir(work_dir)
        tst_rmdir(src_dir, work_dir)
        tst_unlink(src_dir, work_dir)
        tst_symlink(work_dir)
        if os.getuid() == 0:
            tst_chown(work_dir)

        # Underlying fs may not have full nanosecond resolution
        tst_utimens(work_dir, ns_tol=1000)

        tst_link(work_dir)
        tst_truncate_path(work_dir)
        tst_truncate_fd(work_dir)
        tst_open_unlink(work_dir)

        subprocess.check_call([
            os.path.join(basename, 'test', 'test_syscalls'), work_dir,
            ':' + src_dir
        ])
    except:
        cleanup(mnt_dir)
        raise
    else:
        umount(mount_process, mnt_dir)
コード例 #23
0
ファイル: test_examples.py プロジェクト: everbase/libfuse
def test_passthrough(tmpdir, name, debug, capfd):
    
    # Avoid false positives from libfuse debug messages
    if debug:
        capfd.register_output(r'^   unique: [0-9]+, error: -[0-9]+ .+$',
                              count=0)

    # test_syscalls prints "No error" under FreeBSD
    capfd.register_output(r"^ \d\d \[[^\]]+ message: 'No error: 0'\]",
                          count=0)

    mnt_dir = str(tmpdir.mkdir('mnt'))
    src_dir = str(tmpdir.mkdir('src'))

    cmdline = base_cmdline + \
              [ pjoin(basename, 'example', name),
                '-f', mnt_dir ]
    if debug:
        cmdline.append('-d')
    mount_process = subprocess.Popen(cmdline)
    try:
        wait_for_mount(mount_process, mnt_dir)
        work_dir = mnt_dir + src_dir

        tst_statvfs(work_dir)
        tst_readdir(src_dir, work_dir)
        tst_open_read(src_dir, work_dir)
        tst_open_write(src_dir, work_dir)
        tst_create(work_dir)
        tst_passthrough(src_dir, work_dir)
        tst_append(src_dir, work_dir)
        tst_seek(src_dir, work_dir)
        tst_mkdir(work_dir)
        tst_rmdir(src_dir, work_dir)
        tst_unlink(src_dir, work_dir)
        tst_symlink(work_dir)
        if os.getuid() == 0:
            tst_chown(work_dir)

        # Underlying fs may not have full nanosecond resolution
        tst_utimens(work_dir, ns_tol=1000)

        tst_link(work_dir)
        tst_truncate_path(work_dir)
        tst_truncate_fd(work_dir)
        tst_open_unlink(work_dir)
        
        subprocess.check_call([ os.path.join(basename, 'test', 'test_syscalls'),
                                work_dir, ':' + src_dir ])
    except:
        cleanup(mnt_dir)
        raise
    else:
        umount(mount_process, mnt_dir)
コード例 #24
0
def test_passthrough_hp(tmpdir, cache):
    mnt_dir = str(tmpdir.mkdir('mnt'))
    src_dir = str(tmpdir.mkdir('src'))

    cmdline = base_cmdline + \
              [ pjoin(basename, 'example', 'passthrough_hp'),
                src_dir, mnt_dir ]

    if not cache:
        cmdline.append('--nocache')

    mount_process = subprocess.Popen(cmdline)
    try:
        wait_for_mount(mount_process, mnt_dir)

        tst_statvfs(mnt_dir)
        tst_readdir(src_dir, mnt_dir)
        tst_readdir_big(src_dir, mnt_dir)
        tst_open_read(src_dir, mnt_dir)
        tst_open_write(src_dir, mnt_dir)
        tst_create(mnt_dir)
        tst_passthrough(src_dir, mnt_dir)
        tst_append(src_dir, mnt_dir)
        tst_seek(src_dir, mnt_dir)
        tst_mkdir(mnt_dir)
        tst_rmdir(src_dir, mnt_dir)
        tst_unlink(src_dir, mnt_dir)
        tst_symlink(mnt_dir)
        if os.getuid() == 0:
            tst_chown(mnt_dir)

        # Underlying fs may not have full nanosecond resolution
        tst_utimens(mnt_dir, ns_tol=1000)

        tst_link(mnt_dir)
        tst_truncate_path(mnt_dir)
        tst_truncate_fd(mnt_dir)
        tst_open_unlink(mnt_dir)

        # test_syscalls assumes that changes in source directory
        # will be reflected immediately in mountpoint, so we
        # can't use it.
        if not cache:
            syscall_test_cmd = [
                os.path.join(basename, 'test', 'test_syscalls'), mnt_dir,
                ':' + src_dir
            ]
            subprocess.check_call(syscall_test_cmd)
    except:
        cleanup(mount_process, mnt_dir)
        raise
    else:
        umount(mount_process, mnt_dir)
コード例 #25
0
def test_fsel(tmpdir):
    mnt_dir = str(tmpdir)
    cmdline = [os.path.join(basename, 'example', 'fsel'), '-f', mnt_dir]
    mount_process = subprocess.Popen(cmdline)
    try:
        wait_for_mount(mount_process, mnt_dir)
        cmdline = [os.path.join(basename, 'example', 'fselclient')]
        subprocess.check_call(cmdline, cwd=mnt_dir)
    except:
        cleanup(mnt_dir)
        raise
    else:
        umount(mount_process, mnt_dir)
コード例 #26
0
ファイル: test_examples.py プロジェクト: CameronOC/libfuse
def test_fsel(tmpdir):
    mnt_dir = str(tmpdir)
    cmdline = [os.path.join(basename, 'example', 'fsel'),
               '-f', mnt_dir ]
    mount_process = subprocess.Popen(cmdline)
    try:
        wait_for_mount(mount_process, mnt_dir)
        cmdline = [ os.path.join(basename, 'example', 'fselclient') ]
        subprocess.check_call(cmdline, cwd=mnt_dir)
    except:
        cleanup(mnt_dir)
        raise
    else:
        umount(mount_process, mnt_dir)
コード例 #27
0
def setup_unreliablefs(tmpdir):
    mnt_dir = str(tmpdir.mkdir('mnt'))
    src_dir = str(tmpdir.mkdir('src'))

    options = "-basedir={}".format(src_dir)
    cmdline = base_cmdline + [
        pjoin(basename, 'build/unreliablefs'), mnt_dir, options
    ]
    mount_process = subprocess.Popen(cmdline)
    wait_for_mount(mount_process, mnt_dir)

    yield mnt_dir, src_dir

    umount(mount_process, mnt_dir)
    cleanup(mount_process, mnt_dir)
コード例 #28
0
def main(filename, udeb=False, debug=False):
    """
    Information about a particular ISO.
    """
    log_level = logging.DEBUG if debug else logging.INFO
    logging.getLogger('requests').setLevel(logging.WARNING)
    logging.basicConfig(stream=sys.stdout,
                        format='%(message)s',
                        level=log_level)

    folder = extract(filename)
    extension = 'udeb' if udeb else 'deb'
    manifest('%s/**/*.%s' % (os.path.join(folder, 'pool'), extension))

    cleanup(folder)
コード例 #29
0
ファイル: test_examples.py プロジェクト: clibs/fuse-linux
def test_poll(tmpdir, output_checker):
    mnt_dir = str(tmpdir)
    cmdline = base_cmdline + [pjoin(basename, 'example', 'poll'),
               '-f', mnt_dir ]
    mount_process = subprocess.Popen(cmdline, stdout=output_checker.fd,
                                     stderr=output_checker.fd)
    try:
        wait_for_mount(mount_process, mnt_dir)
        cmdline = base_cmdline + \
                  [ pjoin(basename, 'example', 'poll_client') ]
        subprocess.check_call(cmdline, cwd=mnt_dir)
    except:
        cleanup(mount_process, mnt_dir)
        raise
    else:
        umount(mount_process, mnt_dir)
コード例 #30
0
ファイル: test_fs.py プロジェクト: savitha18/pyfuse3
def test_terminate(tmpdir):
    mnt_dir = str(tmpdir)
    mp = get_mp()
    with mp.Manager() as mgr:
        fs_state = mgr.Namespace()
        mount_process = mp.Process(target=run_fs, args=(mnt_dir, fs_state))

        mount_process.start()
        try:
            wait_for_mount(mount_process, mnt_dir)
            pyfuse3.setxattr(mnt_dir, 'command', b'terminate')
            mount_process.join(5)
            assert mount_process.exitcode is not None
        except:
            cleanup(mount_process, mnt_dir)
            raise
コード例 #31
0
ファイル: test_fs.py プロジェクト: savitha18/pyfuse3
def testfs(tmpdir):
    mnt_dir = str(tmpdir)
    mp = get_mp()
    with mp.Manager() as mgr:
        cross_process = mgr.Namespace()
        mount_process = mp.Process(target=run_fs,
                                   args=(mnt_dir, cross_process))

        mount_process.start()
        try:
            wait_for_mount(mount_process, mnt_dir)
            yield (mnt_dir, cross_process)
        except:
            cleanup(mnt_process, mnt_dir)
            raise
        else:
            umount(mount_process, mnt_dir)
コード例 #32
0
def test_fuse(tmpdir):
    mnt_dir = str(tmpdir.mkdir('mnt'))
    src_dir = str(tmpdir.mkdir('src'))

    cmdline = [ os.path.join(basename, 'example', 'fusexmp_fh'),
                '-f', '-o' , 'use_ino,readdir_ino,kernel_cache',
                mnt_dir ]
    mount_process = subprocess.Popen(cmdline)
    try:
        wait_for_mount(mount_process, mnt_dir)
        cmdline = [ os.path.join(basename, 'test', 'test'),
                    os.path.join(mnt_dir, src_dir),
                    ':' + src_dir ]
        subprocess.check_call(cmdline)
    except:
        cleanup(mnt_dir)
        raise
    else:
        umount(mount_process, mnt_dir)
コード例 #33
0
 def destroy(self):
     if self._cleanup_required:
         MODULE.info('Appliance mode: cleanup by timeout')
         # cleanup restarts umc, so MODULE.info will never
         # be called. but leave it that way, maybe it can
         # be called in the future.
         if util.cleanup():
             MODULE.info('... cleanup successful')
         else:
             MODULE.warn('... cleanup operation failed')
     return super(Instance, self).destroy()
コード例 #34
0
ファイル: __init__.py プロジェクト: B-Rich/smart
	def destroy(self):
		if self._cleanup_required:
			MODULE.info('Appliance mode: cleanup by timeout')
			# cleanup restarts umc, so MODULE.info will never
			# be called. but leave it that way, maybe it can
			# be called in the future.
			if util.cleanup():
				MODULE.info('... cleanup successful')
			else:
				MODULE.warn('... cleanup operation failed')
		return super(Instance, self).destroy()
コード例 #35
0
def test_hello(tmpdir, name, options, cmdline_builder):
    mnt_dir = str(tmpdir)
    mount_process = subprocess.Popen(cmdline_builder(mnt_dir, name, options))
    try:
        wait_for_mount(mount_process, mnt_dir)
        assert os.listdir(mnt_dir) == ['hello']
        filename = pjoin(mnt_dir, 'hello')
        with open(filename, 'r') as fh:
            assert fh.read() == 'Hello World!\n'
        with pytest.raises(IOError) as exc_info:
            open(filename, 'r+')
        assert exc_info.value.errno == errno.EACCES
        with pytest.raises(IOError) as exc_info:
            open(filename + 'does-not-exist', 'r+')
        assert exc_info.value.errno == errno.ENOENT
    except:
        cleanup(mount_process, mnt_dir)
        raise
    else:
        umount(mount_process, mnt_dir)
コード例 #36
0
def startup(client, params):
    c = None

    # if the kubernetes param is specified, assume this is part of a
    # collector set and parse the id accordingly, bypassing other id lookups
    if params['kubernetes']:
        logging.debug('Kubernetes mode enabled. Parsing id from environment')
        collector_id = kubernetes.get_collector_id()
        logging.debug('Parsed id ' + str(collector_id))
        params['collector_id'] = collector_id

    # detect if the collector already exists in the portal
    f = collector.find_collector(client, params)
    if not f:
        logging.debug('Collector not found')
        if params['kubernetes']:
            err = 'Running in kubernetes mode but existing collector not found'
            util.fail(err)
        c = collector.collector(client, params)
        c = collector.create_collector(client, c)
    else:
        logging.debug('Collector found')
        c = f

        # we want to make a note on the fs that we found an existing collector
        # so that we don't remove it during a future cleanup, but we should
        # only make this note if this is the first time the container is run
        # (otherwise, every subsequent should detect the existing collector
        # that we're going to create below. Not the behavior we want)
        if not os.path.isfile(config.FIRST_RUN):
            util.touch(config.COLLECTOR_FOUND)

    # let subsequent runs know that this isn't the first container run
    util.touch(config.FIRST_RUN)

    # detect if collector is already installed
    if os.path.isdir(config.INSTALL_PATH + config.AGENT_DIRECTORY):
        logging.debug('Collector already installed.')
        util.cleanup()
        return
    collector.install_collector(client, c, params)
コード例 #37
0
def main(filename, debug=False):
    """
    Information about a particular ISO.
    """
    log_level = logging.DEBUG if debug else logging.INFO
    logging.getLogger('requests').setLevel(logging.WARNING)
    logging.basicConfig(stream=sys.stdout, format='%(message)s',
                        level=log_level)

    folder = extract(filename)

    logging.info('ISO Stats')
    logging.info('---')
    stats_iso(filename, folder)
    stats_dirs(folder)
    stats_squashfs(os.path.join(folder, 'install'))
    stats_pool(os.path.join(folder, 'pool'))

    logging.info('')

    cleanup(folder)
コード例 #38
0
 def __init__(self, now, settings):
     """
     Default constructor for the settings class
     :param settings: Parsed configuration yaml file
     :param now: Current time as datetime object
     :raises ValueError if a nonexistent settings file is passed
     """
     self.date_format = settings['date_format']
     self.settings = settings
     self.now = now
     latest = self.settings['latest']
     backup_dir_root = self.settings['target_dir']
     self.backup_dir = os.path.join(backup_dir_root, latest)
     self.init(self.backup_dir, self.settings['full'])
     for i in self.settings['intervals']:
         backup_dir_int = os.path.join(self.backup_dir, i['name'])
         if not os.path.isdir(backup_dir_int):
             os.makedirs(backup_dir_int)
         # If needed do a cleanup (after a crash which could not be catched)
         if os.path.exists(os.path.join(backup_dir_int, latest + '_new')):
             util.cleanup(os.path.join(backup_dir_int, latest + '_new'))
コード例 #39
0
ファイル: test_examples.py プロジェクト: johanalenius/main
def test_lltest(tmpdir):
    mnt_dir = str(tmpdir)
    cmdline = [sys.executable, os.path.join(basename, "examples", "lltest.py"), mnt_dir]
    mount_process = subprocess.Popen(cmdline, stdin=subprocess.DEVNULL, universal_newlines=True)
    try:
        wait_for_mount(mount_process, mnt_dir)
        assert os.listdir(mnt_dir) == ["message"]
        filename = os.path.join(mnt_dir, "message")
        with open(filename, "r") as fh:
            assert fh.read() == "hello world\n"
        with pytest.raises(IOError) as exc_info:
            open(filename, "r+")
        assert exc_info.value.errno == errno.EPERM
        with pytest.raises(IOError) as exc_info:
            open(filename + "does-not-exist", "r+")
        assert exc_info.value.errno == errno.ENOENT
    except:
        cleanup(mnt_dir)
        raise
    else:
        umount(mount_process, mnt_dir)
コード例 #40
0
 def cleanup(self, request):
     # shut down the browser in appliance mode
     # call finished() directly, so the browser will get the response in any case
     # (see Bug #27632)
     MODULE.info('Appliance mode: cleanup')
     self.finished(request.id, True)
     # put it here just in case destroy gets called during util
     self._cleanup_required = False
     if util.cleanup():
         MODULE.info('... cleanup successful')
     else:
         MODULE.warn('... cleanup operation failed')
コード例 #41
0
def test_fioc(tmpdir):
    mnt_dir = str(tmpdir)
    testfile = os.path.join(mnt_dir, 'fioc')
    cmdline = [os.path.join(basename, 'example', 'fioc'), '-f', mnt_dir]
    mount_process = subprocess.Popen(cmdline)
    try:
        wait_for_mount(mount_process, mnt_dir)

        base_cmd = [os.path.join(basename, 'example', 'fioclient'), testfile]
        assert subprocess.check_output(base_cmd) == b'0\n'
        with open(testfile, 'wb') as fh:
            fh.write(b'foobar')
        assert subprocess.check_output(base_cmd) == b'6\n'
        subprocess.check_call(base_cmd + ['3'])
        with open(testfile, 'rb') as fh:
            assert fh.read() == b'foo'
    except:
        cleanup(mnt_dir)
        raise
    else:
        umount(mount_process, mnt_dir)
コード例 #42
0
ファイル: __init__.py プロジェクト: B-Rich/smart
	def cleanup(self, request):
		# shut down the browser in appliance mode
		# call finished() directly, so the browser will get the response in any case
		# (see Bug #27632)
		MODULE.info('Appliance mode: cleanup')
		self.finished(request.id, True)
		# put it here just in case destroy gets called during util
		self._cleanup_required = False
		if util.cleanup():
			MODULE.info('... cleanup successful')
		else:
			MODULE.warn('... cleanup operation failed')
コード例 #43
0
def test_hello(tmpdir, name):
    mnt_dir = str(tmpdir)
    cmdline = [os.path.join(basename, 'example', name), '-f', mnt_dir]
    mount_process = subprocess.Popen(cmdline)
    try:
        wait_for_mount(mount_process, mnt_dir)
        assert os.listdir(mnt_dir) == ['hello']
        filename = os.path.join(mnt_dir, 'hello')
        with open(filename, 'r') as fh:
            assert fh.read() == 'Hello World!\n'
        with pytest.raises(IOError) as exc_info:
            open(filename, 'r+')
        assert exc_info.value.errno == errno.EACCES
        with pytest.raises(IOError) as exc_info:
            open(filename + 'does-not-exist', 'r+')
        assert exc_info.value.errno == errno.ENOENT
    except:
        cleanup(mnt_dir)
        raise
    else:
        umount(mount_process, mnt_dir)
コード例 #44
0
ファイル: test_examples.py プロジェクト: everbase/libfuse
def test_passthrough_ll(tmpdir, writeback, debug, capfd):
    
    progname = pjoin(basename, 'example', 'passthrough_ll')
    if not os.path.exists(progname):
        pytest.skip('%s not built' % os.path.basename(progname))
    
    # Avoid false positives from libfuse debug messages
    if debug:
        capfd.register_output(r'^   unique: [0-9]+, error: -[0-9]+ .+$',
                              count=0)

    mnt_dir = str(tmpdir.mkdir('mnt'))
    src_dir = str(tmpdir.mkdir('src'))

    cmdline = base_cmdline + [ progname, '-f', mnt_dir ]
    if debug:
        cmdline.append('-d')

    if writeback:
        cmdline.append('-o')
        cmdline.append('writeback')
        
    mount_process = subprocess.Popen(cmdline)
    try:
        wait_for_mount(mount_process, mnt_dir)
        work_dir = mnt_dir + src_dir

        tst_statvfs(work_dir)
        tst_readdir(src_dir, work_dir)
        tst_open_read(src_dir, work_dir)
        tst_open_write(src_dir, work_dir)
        tst_create(work_dir)
        tst_passthrough(src_dir, work_dir)
        tst_append(src_dir, work_dir)
        tst_seek(src_dir, work_dir)
    except:
        cleanup(mnt_dir)
        raise
    else:
        umount(mount_process, mnt_dir)
コード例 #45
0
def test_passthrough_ll(tmpdir, writeback, debug, capfd):

    progname = pjoin(basename, 'example', 'passthrough_ll')
    if not os.path.exists(progname):
        pytest.skip('%s not built' % os.path.basename(progname))

    # Avoid false positives from libfuse debug messages
    if debug:
        capfd.register_output(r'^   unique: [0-9]+, error: -[0-9]+ .+$',
                              count=0)

    mnt_dir = str(tmpdir.mkdir('mnt'))
    src_dir = str(tmpdir.mkdir('src'))

    cmdline = base_cmdline + [progname, '-f', mnt_dir]
    if debug:
        cmdline.append('-d')

    if writeback:
        cmdline.append('-o')
        cmdline.append('writeback')

    mount_process = subprocess.Popen(cmdline)
    try:
        wait_for_mount(mount_process, mnt_dir)
        work_dir = mnt_dir + src_dir

        tst_statvfs(work_dir)
        tst_readdir(src_dir, work_dir)
        tst_open_read(src_dir, work_dir)
        tst_open_write(src_dir, work_dir)
        tst_create(work_dir)
        tst_passthrough(src_dir, work_dir)
        tst_append(src_dir, work_dir)
        tst_seek(src_dir, work_dir)
    except:
        cleanup(mnt_dir)
        raise
    else:
        umount(mount_process, mnt_dir)
コード例 #46
0
ファイル: test_examples.py プロジェクト: CameronOC/libfuse
def test_hello(tmpdir, name):
    mnt_dir = str(tmpdir)
    cmdline = [os.path.join(basename, 'example', name),
               '-f', mnt_dir ]
    mount_process = subprocess.Popen(cmdline)
    try:
        wait_for_mount(mount_process, mnt_dir)
        assert os.listdir(mnt_dir) == [ 'hello' ]
        filename = os.path.join(mnt_dir, 'hello')
        with open(filename, 'r') as fh:
            assert fh.read() == 'Hello World!\n'
        with pytest.raises(IOError) as exc_info:
            open(filename, 'r+')
        assert exc_info.value.errno == errno.EACCES
        with pytest.raises(IOError) as exc_info:
            open(filename + 'does-not-exist', 'r+')
        assert exc_info.value.errno == errno.ENOENT
    except:
        cleanup(mnt_dir)
        raise
    else:
        umount(mount_process, mnt_dir)
コード例 #47
0
ファイル: test_examples.py プロジェクト: CameronOC/libfuse
def test_fioc(tmpdir):
    mnt_dir = str(tmpdir)
    testfile = os.path.join(mnt_dir, 'fioc')
    cmdline = [os.path.join(basename, 'example', 'fioc'),
               '-f', mnt_dir ]
    mount_process = subprocess.Popen(cmdline)
    try:
        wait_for_mount(mount_process, mnt_dir)

        base_cmd = [ os.path.join(basename, 'example', 'fioclient'),
                     testfile ]
        assert subprocess.check_output(base_cmd) == b'0\n'
        with open(testfile, 'wb') as fh:
            fh.write(b'foobar')
        assert subprocess.check_output(base_cmd) == b'6\n'
        subprocess.check_call(base_cmd + [ '3' ])
        with open(testfile, 'rb') as fh:
            assert fh.read()== b'foo'
    except:
        cleanup(mnt_dir)
        raise
    else:
        umount(mount_process, mnt_dir)
コード例 #48
0
ファイル: test_ctests.py プロジェクト: everbase/libfuse
def test_notify_file_size(tmpdir, notify):
    mnt_dir = str(tmpdir)
    cmdline = base_cmdline + \
              [ pjoin(basename, 'example', 'invalidate_path'),
                '-f', '--update-interval=1', mnt_dir ]
    if not notify:
        cmdline.append('--no-notify')
    mount_process = subprocess.Popen(cmdline)
    try:
        wait_for_mount(mount_process, mnt_dir)
        filename = pjoin(mnt_dir, 'growing')
        size = os.path.getsize(filename)
        safe_sleep(2)
        new_size = os.path.getsize(filename)
        if notify:
            assert new_size > size
        else:
            assert new_size == size
    except:
        cleanup(mnt_dir)
        raise
    else:
        umount(mount_process, mnt_dir)
コード例 #49
0
ファイル: test_examples.py プロジェクト: everbase/libfuse
def test_null(tmpdir):
    progname = pjoin(basename, 'example', 'null')
    if not os.path.exists(progname):
        pytest.skip('%s not built' % os.path.basename(progname))
    
    mnt_file = str(tmpdir) + '/file'
    with open(mnt_file, 'w') as fh:
        fh.write('dummy')
    cmdline = base_cmdline + [ progname, '-f', mnt_file ]
    mount_process = subprocess.Popen(cmdline)
    def test_fn(name):
        return os.stat(name).st_size > 4000
    try:
        wait_for_mount(mount_process, mnt_file, test_fn)
        with open(mnt_file, 'rb') as fh:
            assert fh.read(382) == b'\0' * 382
        with open(mnt_file, 'wb') as fh:
            fh.write(b'whatever')
    except:
        cleanup(mnt_file)
        raise
    else:
        umount(mount_process, mnt_file)
コード例 #50
0
ファイル: test_examples.py プロジェクト: quobert/libfuse
def test_passthrough(tmpdir, name, debug):
    mnt_dir = str(tmpdir.mkdir('mnt'))
    src_dir = str(tmpdir.mkdir('src'))

    cmdline = base_cmdline + \
              [ pjoin(basename, 'example', name),
                '-f', mnt_dir ]
    if debug:
        cmdline.append('-d')
    mount_process = subprocess.Popen(cmdline)
    try:
        wait_for_mount(mount_process, mnt_dir)
        work_dir = pjoin(mnt_dir, src_dir)

        subprocess.check_call([ os.path.join(basename, 'test', 'test'),
                    work_dir, ':' + src_dir ])

        tst_write(work_dir)
        tst_mkdir(work_dir)
        tst_symlink(work_dir)
        tst_mknod(work_dir)
        if os.getuid() == 0:
            tst_chown(work_dir)
        # Underlying fs may not have full nanosecond resolution
        tst_utimens(work_dir, ns_tol=1000)
        tst_link(work_dir)
        tst_readdir(work_dir)
        tst_statvfs(work_dir)
        tst_truncate_path(work_dir)
        tst_truncate_fd(work_dir)
        tst_unlink(work_dir)
        tst_passthrough(src_dir, work_dir)
    except:
        cleanup(mnt_dir)
        raise
    else:
        umount(mount_process, mnt_dir)
コード例 #51
0
from util import cleanup

cleanup_dir = '/Users/ryanzotti/Documents/repos/Self_Driving_RC_Car/tf_visual_data/runs/'
cleanup(cleanup_dir)
print("Cleanup completed successfully.")
コード例 #52
0
ファイル: wakarimasen.py プロジェクト: dequis/wakarimasen
        return app.error(environ, start_response, e)
    except:
        environ['waka.status'] = '503 Service unavailable'
        traceback.print_exc()
        return app.error(environ, start_response)


def cleanup(*args, **kwargs):
    '''Destroy the thread-local session and environ'''
    session = model.Session()
    session.commit()
    session.transaction = None  # fix for a circular reference
    model.Session.remove()
    local.environ = {}

application = util.cleanup(application, cleanup)

def main():
    try:
        app.init_database()
    except model.OperationalError, e:
        # CGI-friendly error message
        print "Content-Type: text/plain\n"
        print "Error initializing database: %s" % e.args[0]
        return

    if not sys.argv[1:] or sys.argv[1] == 'fcgi':
        fcgi.WSGIServer(application).run()
    else:
        cli.handle_command(sys.argv[1:], application)
        cleanup()
コード例 #53
0
ファイル: test_sshfs.py プロジェクト: coocoky/sshfs
def test_sshfs(tmpdir, debug, cache_timeout, sync_rd,
               writeback, capfd):
    
    # Avoid false positives from debug messages
    #if debug:
    #    capfd.register_output(r'^   unique: [0-9]+, error: -[0-9]+ .+$',
    #                          count=0)

    # Test if we can ssh into localhost without password
    try:
        res = subprocess.call(['ssh', '-o', 'KbdInteractiveAuthentication=no',
                               '-o', 'ChallengeResponseAuthentication=no',
                               '-o', 'PasswordAuthentication=no',
                               'localhost', '--', 'true'], stdin=subprocess.DEVNULL,
                              timeout=10)
    except subprocess.TimeoutExpired:
        res = 1
    if res != 0:
        pytest.fail('Unable to ssh into localhost without password prompt.')

    mnt_dir = str(tmpdir.mkdir('mnt'))
    src_dir = str(tmpdir.mkdir('src'))

    cmdline = base_cmdline + [ pjoin(basename, 'sshfs'),
                               '-f', 'localhost:' + src_dir, mnt_dir ]
    if debug:
        cmdline += [ '-o', 'sshfs_debug' ]

    if sync_rd:
        cmdline += [ '-o', 'sync_readdir' ]

    if writeback:
        cmdline += [ '-o', 'writeback_cache=yes',
                     '-o', 'unreliable_append' ]
    else:
        cmdline += [ '-o', 'writeback_cache=no' ]
    
    # SSHFS Cache
    if cache_timeout == 0:
        cmdline += [ '-o', 'dir_cache=no' ]
    else:
        cmdline += [ '-o', 'dcache_timeout=%d' % cache_timeout,
                     '-o', 'dir_cache=yes' ]

    # FUSE Cache
    cmdline += [ '-o', 'entry_timeout=0',
                 '-o', 'attr_timeout=0' ]

    
    new_env = dict(os.environ) # copy, don't modify

    # Abort on warnings from glib
    new_env['G_DEBUG'] = 'fatal-warnings'
    
    mount_process = subprocess.Popen(cmdline, env=new_env)
    try:
        wait_for_mount(mount_process, mnt_dir)

        tst_statvfs(mnt_dir)
        tst_readdir(src_dir, mnt_dir)
        tst_open_read(src_dir, mnt_dir)
        tst_open_write(src_dir, mnt_dir)
        tst_append(src_dir, mnt_dir)
        tst_seek(src_dir, mnt_dir)
        tst_create(mnt_dir)
        tst_passthrough(src_dir, mnt_dir, cache_timeout)
        tst_mkdir(mnt_dir)
        tst_rmdir(src_dir, mnt_dir, cache_timeout)
        tst_unlink(src_dir, mnt_dir, cache_timeout)
        tst_symlink(mnt_dir)
        if os.getuid() == 0:
            tst_chown(mnt_dir)

        # SSHFS only supports one second resolution when setting
        # file timestamps.
        tst_utimens(mnt_dir, tol=1)

        tst_link(mnt_dir)
        tst_truncate_path(mnt_dir)
        tst_truncate_fd(mnt_dir)
        tst_open_unlink(mnt_dir)
    except:
        cleanup(mnt_dir)
        raise
    else:
        umount(mount_process, mnt_dir)
コード例 #54
0
ファイル: build.py プロジェクト: oremj/app-packr
def cleanup(app_hostroot, build_dir, build_id, keep):
    build_dir = os.path.join(build_dir, build_id)
    run(['rm', '-rf', build_dir])

    util.cleanup(app_hostroot, build_id, keep)