def test_git_require_sudo_user(gituser): """ Test working_copy() with sudo as a user """ from burlap.require.git import working_copy username, groupname = gituser with cd('/tmp'): try: working_copy(REMOTE_URL, path='wc_nobody', use_sudo=True, user=username) assert is_dir('wc_nobody') assert is_dir('wc_nobody/.git') with cd('wc_nobody'): remotes = sudo('git remote -v', user=username) assert remotes == \ 'origin\thttps://github.com/chrisspen/burlap.git (fetch)\r\n' \ 'origin\thttps://github.com/chrisspen/burlap.git (push)' assert _current_branch() == 'master' assert owner('wc_nobody') == username assert group('wc_nobody') == groupname finally: run_as_root('rm -rf wc_nobody')
def test_git_require_sudo(): """ Test working_copy() with sudo """ from burlap.require.git import working_copy try: working_copy(REMOTE_URL, path='wc_root', use_sudo=True) assert is_dir('wc_root') assert is_dir('wc_root/.git') with cd('wc_root'): remotes = run('git remote -v') assert remotes == \ 'origin\thttps://github.com/chrisspen/burlap.git (fetch)\r\n' \ 'origin\thttps://github.com/chrisspen/burlap.git (push)' assert _current_branch() == 'master' assert owner('wc_root') == 'root' assert group('wc_root') == 'root' finally: run_as_root('rm -rf wc_root')
def test_git_require_sudo(): """ Test working_copy() with sudo """ from burlap.require.git import working_copy try: working_copy(REMOTE_URL, path='wc_root', use_sudo=True) assert is_dir('wc_root') assert is_dir('wc_root/.git') with cd('wc_root'): remotes = run('git remote -v') assert remotes == \ 'origin\thttps://github.com/chrisspen/burlap.git (fetch)\r\n' \ 'origin\thttps://github.com/chrisspen/burlap.git (push)' assert _current_branch() == 'master' assert owner('wc_root') == 'root' assert group('wc_root') == 'root' finally: run_as_root('rm -rf wc_root')
def test_git_require_sudo_user(gituser): """ Test working_copy() with sudo as a user """ from burlap.require.git import working_copy username, groupname = gituser with cd('/tmp'): try: working_copy(REMOTE_URL, path='wc_nobody', use_sudo=True, user=username) assert is_dir('wc_nobody') assert is_dir('wc_nobody/.git') with cd('wc_nobody'): remotes = sudo('git remote -v', user=username) assert remotes == \ 'origin\thttps://github.com/chrisspen/burlap.git (fetch)\r\n' \ 'origin\thttps://github.com/chrisspen/burlap.git (push)' assert _current_branch() == 'master' assert owner('wc_nobody') == username assert group('wc_nobody') == groupname finally: run_as_root('rm -rf wc_nobody')
def test_temporary_directory_as_context_manager(): from burlap.files import is_dir from burlap.require.files import temporary_directory with temporary_directory() as path: assert is_dir(path) with cd(path): run('touch foo') assert not is_dir(path)
def test_temporary_directory_as_context_manager(): from burlap.files import is_dir from burlap.require.files import temporary_directory with temporary_directory() as path: assert is_dir(path) with cd(path): run('touch foo') assert not is_dir(path)
def test_temporary_directory_as_function(): from burlap.files import is_dir from burlap.require.files import temporary_directory path1 = temporary_directory() path2 = temporary_directory() assert is_dir(path1) assert is_dir(path2) assert path1 != path2 run('rmdir %s' % quote(path1)) run('rmdir %s' % quote(path2))
def test_temporary_directory_as_function(): from burlap.files import is_dir from burlap.require.files import temporary_directory path1 = temporary_directory() path2 = temporary_directory() assert is_dir(path1) assert is_dir(path2) assert path1 != path2 run('rmdir %s' % quote(path1)) run('rmdir %s' % quote(path2))
def directory(path, use_sudo=False, owner='', group='', mode=''): """ Require a directory to exist. :: from burlap import require require.directory('/tmp/mydir', owner='alice', use_sudo=True) .. note:: This function can be accessed directly from the ``burlap.require`` module for convenience. """ func = use_sudo and run_as_root or run if not is_dir(path): func('mkdir -p "%(path)s"' % locals()) # Ensure correct owner if (owner and _owner(path, use_sudo) != owner) or \ (group and _group(path, use_sudo) != group): func('chown %(owner)s:%(group)s "%(path)s"' % locals()) # Ensure correct mode if mode and _mode(path, use_sudo) != mode: func('chmod %(mode)s "%(path)s"' % locals())
def directory(path, use_sudo=False, owner='', group='', mode=''): """ Require a directory to exist. :: from burlap import require require.directory('/tmp/mydir', owner='alice', use_sudo=True) .. note:: This function can be accessed directly from the ``burlap.require`` module for convenience. """ func = use_sudo and run_as_root or run if not is_dir(path): func('mkdir -p "%(path)s"' % locals()) # Ensure correct owner if (owner and _owner(path, use_sudo) != owner) or \ (group and _group(path, use_sudo) != group): func('chown %(owner)s:%(group)s "%(path)s"' % locals()) # Ensure correct mode if mode and _mode(path, use_sudo) != mode: func('chmod %(mode)s "%(path)s"' % locals())
def install_from_oracle_site(version=DEFAULT_VERSION): """ Download tarball from Oracle site and install JDK. :: import burlap # Install Oracle JDK burlap.oracle_jdk.install_from_oracle_site() """ prefix = '/opt' release, build = version.split('-') major, update = release.split('u') if len(update) == 1: update = '0' + update arch = _required_jdk_arch() self_extracting_archive = (major == '6') extension = 'bin' if self_extracting_archive else 'tar.gz' filename = 'jdk-%(release)s-linux-%(arch)s.%(extension)s' % locals() download_path = posixpath.join('/tmp', filename) url = 'http://download.oracle.com/otn-pub/java/jdk/%(version)s/%(filename)s' % locals() _download(url, download_path) # Prepare install dir install_dir = 'jdk1.%(major)s.0_%(update)s' % locals() with cd(prefix): if is_dir(install_dir): run_as_root('rm -rf %s' % quote(install_dir)) # Extract if self_extracting_archive: run('chmod u+x %s' % quote(download_path)) with cd('/tmp'): run_as_root('rm -rf %s' % quote(install_dir)) run_as_root('./%s' % filename) run_as_root('mv %s %s' % (quote(install_dir), quote(prefix))) else: with cd(prefix): run_as_root('tar xzvf %s' % quote(download_path)) # Set up link link_path = posixpath.join(prefix, 'jdk') if is_link(link_path): run_as_root('rm -f %s' % quote(link_path)) run_as_root('ln -s %s %s' % (quote(install_dir), quote(link_path))) # Remove archive run('rm -f %s' % quote(download_path)) _create_profile_d_file(prefix)
def test_create_user(): from burlap.user import create, exists try: create('user1', create_home=False) assert exists('user1') assert not is_dir('/home/user1') finally: sudo_or_dryrun('userdel -r user1')
def test_initial_owner_requirement(users): from burlap.require import directory try: directory('testdir', owner='testuser', use_sudo=True) assert is_dir('testdir') assert owner('testdir') == 'testuser' finally: run_as_root('rmdir testdir')
def test_directory_creation(): from burlap.require import directory try: directory('testdir') assert is_dir('testdir') assert owner('testdir') == env.user finally: run('rmdir testdir')
def test_initial_owner_requirement(users): from burlap.require import directory try: directory('testdir', owner='testuser', use_sudo=True) assert is_dir('testdir') assert owner('testdir') == 'testuser' finally: run_as_root('rmdir testdir')
def test_directory_creation(): from burlap.require import directory try: directory('testdir') assert is_dir('testdir') assert owner('testdir') == env.user finally: run('rmdir testdir')
def test_git_require_remote_url_and_path(): """ Test working_copy() with remote URL and path """ from burlap.require.git import working_copy try: working_copy(REMOTE_URL, path='wc') assert is_dir('wc') assert is_dir('wc/.git') with cd('wc'): remotes = run('git remote -v') assert remotes == \ 'origin\thttps://github.com/chrisspen/burlap.git (fetch)\r\n' \ 'origin\thttps://github.com/chrisspen/burlap.git (push)' assert _current_branch() == 'master' finally: run('rm -rf wc')
def test_git_require_branch(): """ Test checkout of a branch """ from burlap.require.git import working_copy try: working_copy(REMOTE_URL, path='wc', branch='master') assert is_dir('wc') assert is_dir('wc/.git') with cd('wc'): remotes = run('git remote -v') assert remotes == \ 'origin\thttps://github.com/chrisspen/burlap.git (fetch)\r\n' \ 'origin\thttps://github.com/chrisspen/burlap.git (push)' assert _current_branch() == 'master' finally: run('rm -rf wc')
def test_git_require_remote_url(): """ Test with remote URL only """ from burlap.require.git import working_copy try: working_copy(REMOTE_URL) assert is_dir('burlap') assert is_dir('burlap/.git') with cd('burlap'): remotes = run('git remote -v') assert remotes == \ 'origin\thttps://github.com/chrisspen/burlap.git (fetch)\r\n' \ 'origin\thttps://github.com/chrisspen/burlap.git (push)' assert _current_branch() == 'master' finally: run('rm -rf burlap')
def test_require_virtualenv(): """ Test Python virtualenv creation """ from burlap.require.python import virtualenv try: virtualenv('/tmp/venv') assert is_dir('/tmp/venv') assert is_file('/tmp/venv/bin/python') finally: run('rm -rf /tmp/venv')
def test_require_virtualenv(): """ Test Python virtualenv creation """ from burlap.require.python import virtualenv try: virtualenv('/tmp/venv') assert is_dir('/tmp/venv') assert is_file('/tmp/venv/bin/python') finally: run('rm -rf /tmp/venv')
def install_from_source(path=DEFAULT_INSTALLATION_PATH, version=DEFAULT_VERSION, mirror=DEFAULT_MIRROR, overwrite=False): """ Install Tomcat from source. :: import burlap # Install Tomcat burlap.tomcat.install_from_source(version='6.0.36') """ from burlap.require import file as require_file from burlap.require.files import directory as require_directory # Tokenize version into parts version_tokens = version.split('.') version_major = version_tokens[0] # Parse the filename and folder file_name = 'apache-tomcat-%s.tar.gz' % version folder_name = 'apache-tomcat-%s' % version # Build the distribution in /tmp with cd('/tmp'): # Make sure we have the tarball downloaded. if not is_file(os.path.join('/tmp/', file_name)): # Otherwise, download the tarball based on our mirror and version. tomcat_url = '%s/dist/tomcat/tomcat-%s/v%s/bin/%s' % (mirror, version_major, version, file_name) # Ensure the file has been downloaded require_file(url=tomcat_url) # Extract the file run('tar -xzf %s' % file_name) # Handle possibility of existing path if is_dir(path): if overwrite is False: # Raise exception as we don't want to overwrite raise OSError("Path %s already exists and overwrite not set." % path) else: # Otherwise, backup the tomcat path backup_installation_path = path + ".backup" if is_dir(backup_installation_path): run_as_root("rm -rf %s" % backup_installation_path) run_as_root("mv %s %s" % (path, backup_installation_path)) """ After all that, let's ensure we have the installation path setup properly and place the install. """ require_directory(path, mode='755', use_sudo=True) run_as_root('mv %s/* %s' % (folder_name, path)) # Now cleanup temp. run("rm -rf %s*" % file_name) # Finally, configure and start Tomcat configure_tomcat(path, overwrite=overwrite) start_tomcat()
def install_from_source(path=DEFAULT_INSTALLATION_PATH, version=DEFAULT_VERSION, mirror=DEFAULT_MIRROR, overwrite=False): """ Install Tomcat from source. :: import burlap # Install Tomcat burlap.tomcat.install_from_source(version='6.0.36') """ from burlap.require import file as require_file from burlap.require.files import directory as require_directory # Tokenize version into parts version_tokens = version.split('.') version_major = version_tokens[0] # Parse the filename and folder file_name = 'apache-tomcat-%s.tar.gz' % version folder_name = 'apache-tomcat-%s' % version # Build the distribution in /tmp with cd('/tmp'): # Make sure we have the tarball downloaded. if not is_file(os.path.join('/tmp/', file_name)): # Otherwise, download the tarball based on our mirror and version. tomcat_url = '%s/dist/tomcat/tomcat-%s/v%s/bin/%s' % ( mirror, version_major, version, file_name) # Ensure the file has been downloaded require_file(url=tomcat_url) # Extract the file run('tar -xzf %s' % file_name) # Handle possibility of existing path if is_dir(path): if overwrite is False: # Raise exception as we don't want to overwrite raise OSError("Path %s already exists and overwrite not set." % path) else: # Otherwise, backup the tomcat path backup_installation_path = path + ".backup" if is_dir(backup_installation_path): run_as_root("rm -rf %s" % backup_installation_path) run_as_root("mv %s %s" % (path, backup_installation_path)) """ After all that, let's ensure we have the installation path setup properly and place the install. """ require_directory(path, mode='755', use_sudo=True) run_as_root('mv %s/* %s' % (folder_name, path)) # Now cleanup temp. run("rm -rf %s*" % file_name) # Finally, configure and start Tomcat configure_tomcat(path, overwrite=overwrite) start_tomcat()
def working_copy(remote_url, path=None, branch="master", update=True, use_sudo=False, user=None): """ Require a working copy of the repository from the ``remote_url``. The ``path`` is optional, and defaults to the last segment of the remote repository URL, without its ``.git`` suffix. If the ``path`` does not exist, this will clone the remote repository and check out the specified branch. If the ``path`` exists and ``update`` is ``True``, it will fetch changes from the remote repository, check out the specified branch, then merge the remote changes into the working copy. If the ``path`` exists and ``update`` is ``False``, it will only check out the specified branch, without fetching remote changesets. :param remote_url: URL of the remote repository (e.g. https://github.com/ronnix/burlap.git). The given URL will be the ``origin`` remote of the working copy. :type remote_url: str :param path: Absolute or relative path of the working copy on the filesystem. If this directory doesn't exist yet, a new working copy is created through ``git clone``. If the directory does exist *and* ``update == True``, a ``git fetch`` is issued. If ``path is None`` the ``git clone`` is issued in the current working directory and the directory name of the working copy is created by ``git``. :type path: str :param branch: Branch or tag to check out. If the given value is a tag name, update must be ``False`` or consecutive calls will fail. :type branch: str :param update: Whether or not to fetch and merge remote changesets. :type update: bool :param use_sudo: If ``True`` execute ``git`` with :func:`fabric.operations.sudo`, else with :func:`fabric.operations.run`. :type use_sudo: bool :param user: If ``use_sudo is True``, run :func:`fabric.operations.sudo` with the given user. If ``use_sudo is False`` this parameter has no effect. :type user: str """ command() if path is None: path = remote_url.split('/')[-1] if path.endswith('.git'): path = path[:-4] if is_dir(path, use_sudo=use_sudo): # always fetch changesets from remote and checkout branch / tag git.fetch(path=path, use_sudo=use_sudo, user=user) git.checkout(path=path, branch=branch, use_sudo=use_sudo, user=user) if update: # only 'merge' if update is True git.pull(path=path, use_sudo=use_sudo, user=user) elif not is_dir(path, use_sudo=use_sudo): git.clone(remote_url, path=path, use_sudo=use_sudo, user=user) git.checkout(path=path, branch=branch, use_sudo=use_sudo, user=user) else: raise ValueError("Invalid combination of parameters.")
def check_for_openvz_kernel(): if not is_dir('/proc/vz'): pytest.skip("Kernel does not support OpenVZ")
def working_copy(remote_url, path=None, branch="default", update=True, use_sudo=False, user=None): """ Require a working copy of the repository from the ``remote_url``. The ``path`` is optional, and defaults to the last segment of the remote repository URL. If the ``path`` does not exist, this will clone the remote repository and check out the specified branch. If the ``path`` exists and ``update`` is ``True``, it will pull changes from the remote repository, check out the specified branch, then update the working copy. If the ``path`` exists and ``update`` is ``False``, it will only check out the specified branch, without pulling remote changesets. :param remote_url: URL of the remote repository :type remote_url: str :param path: Absolute or relative path of the working copy on the filesystem. If this directory doesn't exist yet, a new working copy is created through ``hg clone``. If the directory does exist *and* ``update == True``, a ``hg pull && hg up`` is issued. If ``path is None`` the ``hg clone`` is issued in the current working directory and the directory name of the working copy is created by ``hg``. :type path: str :param branch: Branch or tag to check out. If the given value is a tag name, update must be ``False`` or consecutive calls will fail. :type branch: str :param update: Whether or not to pull and update remote changesets. :type update: bool :param use_sudo: If ``True`` execute ``hg`` with :func:`fabric.operations.sudo`, else with :func:`fabric.operations.run`. :type use_sudo: bool :param user: If ``use_sudo is True``, run :func:`fabric.operations.sudo` with the given user. If ``use_sudo is False`` this parameter has no effect. :type user: str """ command() if path is None: path = remote_url.split('/')[-1] if is_dir(path, use_sudo=use_sudo): mercurial.pull(path, use_sudo=use_sudo, user=user) if update: mercurial.update(path=path, branch=branch, use_sudo=use_sudo, user=user) elif not is_dir(path, use_sudo=use_sudo): mercurial.clone(remote_url, path=path, use_sudo=use_sudo, user=user) mercurial.update(path=path, branch=branch, use_sudo=use_sudo, user=user) else: raise ValueError("Invalid combination of parameters.")
def working_copy(remote_url, path=None, branch="default", update=True, use_sudo=False, user=None): """ Require a working copy of the repository from the ``remote_url``. The ``path`` is optional, and defaults to the last segment of the remote repository URL. If the ``path`` does not exist, this will clone the remote repository and check out the specified branch. If the ``path`` exists and ``update`` is ``True``, it will pull changes from the remote repository, check out the specified branch, then update the working copy. If the ``path`` exists and ``update`` is ``False``, it will only check out the specified branch, without pulling remote changesets. :param remote_url: URL of the remote repository :type remote_url: str :param path: Absolute or relative path of the working copy on the filesystem. If this directory doesn't exist yet, a new working copy is created through ``hg clone``. If the directory does exist *and* ``update == True``, a ``hg pull && hg up`` is issued. If ``path is None`` the ``hg clone`` is issued in the current working directory and the directory name of the working copy is created by ``hg``. :type path: str :param branch: Branch or tag to check out. If the given value is a tag name, update must be ``False`` or consecutive calls will fail. :type branch: str :param update: Whether or not to pull and update remote changesets. :type update: bool :param use_sudo: If ``True`` execute ``hg`` with :func:`fabric.operations.sudo`, else with :func:`fabric.operations.run`. :type use_sudo: bool :param user: If ``use_sudo is True``, run :func:`fabric.operations.sudo` with the given user. If ``use_sudo is False`` this parameter has no effect. :type user: str """ command() if path is None: path = remote_url.split('/')[-1] if is_dir(path, use_sudo=use_sudo): mercurial.pull(path, use_sudo=use_sudo, user=user) if update: mercurial.update(path=path, branch=branch, use_sudo=use_sudo, user=user) elif not is_dir(path, use_sudo=use_sudo): mercurial.clone(remote_url, path=path, use_sudo=use_sudo, user=user) mercurial.update(path=path, branch=branch, use_sudo=use_sudo, user=user) else: raise ValueError("Invalid combination of parameters.")