def locales(names):
"""
Require the list of locales to be available.
Raises UnsupportedLocales if some of the required locales
are not supported.
"""
family = distrib_family()
if family == 'debian':
command = 'dpkg-reconfigure --frontend=noninteractive locales'
if distrib_id() == 'Ubuntu':
config_file = '/var/lib/locales/supported.d/local'
if not is_file(config_file):
run_as_root('touch %s' % config_file)
else:
config_file = '/etc/locale.gen'
_locales_generic(names, config_file=config_file, command=command)
elif family in ['arch', 'gentoo']:
_locales_generic(names,
config_file='/etc/locale.gen',
command='locale-gen')
elif distrib_family() == 'redhat':
_locales_redhat(names)
else:
raise UnsupportedFamily(
supported=['debian', 'arch', 'gentoo', 'redhat'])
def command():
"""
Require the git command-line tool.
Example::
from fabric.api import run
from burlap import require
require.git.command()
run('git --help')
"""
from burlap.require.deb import package as require_deb_package
from burlap.require.pkg import package as require_pkg_package
from burlap.require.rpm import package as require_rpm_package
from burlap.require.portage import package as require_portage_package
res = run('git --version', quiet=True)
if res.failed:
family = distrib_family()
if family == 'debian':
require_deb_package('git-core')
elif family == 'redhat':
require_rpm_package('git')
elif family == 'sun':
require_pkg_package('scmgit-base')
elif family == 'gentoo':
require_portage_package('dev-vcs/git')
else:
raise UnsupportedFamily(supported=['debian', 'redhat', 'sun', 'gentoo'])
def setup_container(name, template, ipadd):
from burlap import require
from burlap.require.openvz import container
from burlap.system import distrib_family
import burlap
if distrib_family() == 'debian':
require.deb.package('vzctl')
require.openvz.template(template)
with container(name, template, hostname=name, ipadd=ipadd) as ct:
# Make sure the container is started
if not ct.running():
ct.start()
# Set up name servers
NAMESERVERS = burlap.network.nameservers()
ct.set(nameserver=NAMESERVERS)
# Wait until we can ping the container from the host
with settings(warn_only=True):
timeout = 0
while True:
if run('ping -c 1 %s' % ipadd).succeeded:
break
time.sleep(1)
timeout += 1
assert timeout < 10, "Timeout trying to ping container"
def setuptools(version=MIN_SETUPTOOLS_VERSION, python_cmd='python'):
"""
Require `setuptools`_ to be installed.
If setuptools is not installed, or if a version older than *version*
is installed, the latest version will be installed.
.. _setuptools: http://pythonhosted.org/setuptools/
"""
from burlap.require.deb import package as require_deb_package
from burlap.require.rpm import package as require_rpm_package
if not is_setuptools_installed(python_cmd=python_cmd):
family = distrib_family()
if family == 'debian':
require_deb_package('python-dev')
elif family == 'redhat':
require_rpm_package('python-devel')
elif family == 'arch':
pass # ArchLinux installs header with base package
else:
raise UnsupportedFamily(supported=['debian', 'redhat', 'arch'])
install_setuptools(python_cmd=python_cmd)
def command():
"""
Require the curl command-line tool.
Example::
from fabric.api import run
from burlap import require
require.curl.command()
run('curl --help')
"""
from burlap.require.deb import package as require_deb_package
from burlap.require.rpm import package as require_rpm_package
family = distrib_family()
if family == 'debian':
require_deb_package('curl')
elif family == 'redhat':
require_rpm_package('curl')
else:
raise UnsupportedFamily(supported=['debian', 'redhat'])
def command():
"""
Require the ``hg`` command-line tool.
Example::
from fabric.api import run
from burlap import require
require.mercurial.command()
run('hg --help')
"""
from burlap.require.deb import package as require_deb_package
from burlap.require.rpm import package as require_rpm_package
from burlap.require.portage import package as require_portage_package
res = run('hg --version', quiet=True)
if res.failed:
family = distrib_family()
if family == 'debian':
require_deb_package('mercurial')
elif family == 'gentoo':
require_portage_package('mercurial')
elif family == 'redhat':
require_rpm_package('mercurial')
else:
raise UnsupportedFamily(supported=['debian', 'redhat', 'gentoo'])
def install_from_upstream(self):
"""
Installs Vagrant from the most recent package available from their homepage.
"""
from burlap.system import get_arch, distrib_family
r = self.local_renderer
content = urlopen(r.env.download_url).read()
print(len(content))
matches = DOWNLOAD_LINK_PATTERN.findall(content)
print(matches)
arch = get_arch() # e.g. 'x86_64'
family = distrib_family()
if family == DEBIAN:
ext = '.deb'
matches = [
match for match in matches
if match.endswith(ext) and arch in match
]
print('matches:', matches)
assert matches, "No matches found."
assert len(matches) == 1, "Too many matches found: %s" % (
', '.join(matches))
r.env.final_download_url = matches[0]
r.env.local_filename = '/tmp/vagrant%s' % ext
r.run('wget -O {local_filename} {final_download_url}')
r.sudo('dpkg -i {local_filename}')
else:
raise NotImplementedError('Unsupported family: %s' % family)
def install(java_version=None):
"""
Install dependencies (curl and unzip) and Install GVM
::
import burlap
# Install GVM
burlap.gvm.install()
"""
res = run('gvm help', quiet=True)
if res.failed:
family = distrib_family()
packages = ['curl', 'unzip']
if family == 'debian':
require_deb_packages(packages)
elif family == 'redhat':
require_rpm_packages(packages)
elif family == 'sun':
require_pkg_packages(packages)
else:
raise UnsupportedFamily(supported=['debian', 'redhat', 'sun'])
if java_version is None:
java()
else:
java(version=java_version)
run('curl -s get.gvmtool.net | bash')
user = run('whoami')
run('source "/home/%s/.gvm/bin/gvm-init.sh"' % user)
configFile = "/home/%s/.gvm/etc/config" % user
sed(configFile, 'gvm_auto_answer=false', 'gvm_auto_answer=true')
def setuptools(version=MIN_SETUPTOOLS_VERSION, python_cmd='python'):
"""
Require `setuptools`_ to be installed.
If setuptools is not installed, or if a version older than *version*
is installed, the latest version will be installed.
.. _setuptools: http://pythonhosted.org/setuptools/
"""
from burlap.require.deb import package as require_deb_package
from burlap.require.rpm import package as require_rpm_package
if not is_setuptools_installed(python_cmd=python_cmd):
family = distrib_family()
if family == 'debian':
require_deb_package('python-dev')
elif family == 'redhat':
require_rpm_package('python-devel')
elif family == 'arch':
pass # ArchLinux installs header with base package
else:
raise UnsupportedFamily(supported=['debian', 'redhat', 'arch'])
install_setuptools(python_cmd=python_cmd)
def command():
"""
Require the ``hg`` command-line tool.
Example::
from fabric.api import run
from burlap import require
require.mercurial.command()
run('hg --help')
"""
from burlap.require.deb import package as require_deb_package
from burlap.require.rpm import package as require_rpm_package
from burlap.require.portage import package as require_portage_package
res = run('hg --version', quiet=True)
if res.failed:
family = distrib_family()
if family == 'debian':
require_deb_package('mercurial')
elif family == 'gentoo':
require_portage_package('mercurial')
elif family == 'redhat':
require_rpm_package('mercurial')
else:
raise UnsupportedFamily(supported=['debian', 'redhat', 'gentoo'])
def _choose(old_style, new_style):
family = distrib_family()
if family == 'debian':
distrib = distrib_id()
at_least_trusty = (distrib == 'Ubuntu' and V(distrib_release()) >= V('14.04'))
at_least_jessie = (distrib == 'Debian' and V(distrib_release()) >= V('8.0'))
if at_least_trusty or at_least_jessie:
return new_style
else:
return old_style
else:
raise UnsupportedFamily(supported=['debian'])
def _run_service(service, action):
"""
Compatibility layer for distros that use ``service`` and those that don't.
"""
if distrib_family() != "gentoo":
status = run_as_root('service %(service)s %(action)s' % locals(),
pty=False)
else:
# gentoo
status = run_as_root('/etc/init.d/%(service)s %(action)s' % locals(),
pty=False)
return status
def _choose(old_style, new_style):
family = distrib_family()
if family == 'debian':
distrib = distrib_id()
at_least_trusty = (distrib == 'Ubuntu'
and V(distrib_release()) >= V('14.04'))
at_least_jessie = (distrib == 'Debian'
and V(distrib_release()) >= V('8.0'))
if at_least_trusty or at_least_jessie:
return new_style
else:
return old_style
else:
raise UnsupportedFamily(supported=['debian'])
def installed_from_source(version=VERSION):
"""
Require Redis to be installed from source.
The compiled binaries will be installed in ``/opt/redis-{version}/``.
"""
from burlap.require import directory as require_directory
from burlap.require import file as require_file
from burlap.require import user as require_user
from burlap.require.deb import packages as require_deb_packages
from burlap.require.rpm import packages as require_rpm_packages
family = distrib_family()
if family == 'debian':
require_deb_packages([
'build-essential',
])
elif family == 'redhat':
require_rpm_packages([
'gcc',
'make',
])
require_user('redis', home='/var/lib/redis', system=True)
require_directory('/var/lib/redis', owner='redis', use_sudo=True)
dest_dir = '/opt/redis-%(version)s' % locals()
require_directory(dest_dir, use_sudo=True, owner='redis')
if not is_file('%(dest_dir)s/redis-server' % locals()):
with cd('/tmp'):
# Download and unpack the tarball
tarball = 'redis-%(version)s.tar.gz' % locals()
url = _download_url(version) + tarball
require_file(tarball, url=url)
run('tar xzf %(tarball)s' % locals())
# Compile and install binaries
with cd('redis-%(version)s' % locals()):
run('make')
for filename in BINARIES:
run_as_root('cp -pf src/%(filename)s %(dest_dir)s/' %
locals())
run_as_root('chown redis: %(dest_dir)s/%(filename)s' %
locals())
def firewall(zones=None,
interfaces=None,
policy=None,
rules=None,
routestopped=None,
masq=None):
"""
Ensure that a firewall is configured.
Example::
from burlap.shorewall import *
from burlap import require
# We need a firewall with some custom rules
require.shorewall.firewall(
rules=[
Ping(),
SSH(),
HTTP(),
HTTPS(),
SMTP(),
rule(port=1234, source=hosts(['example.com'])),
]
)
"""
family = distrib_family()
if family != 'debian':
raise UnsupportedFamily(supported=['debian'])
require_deb_package('shorewall')
with watch(CONFIG_FILES) as config:
_zone_config(zones)
_interfaces_config(interfaces)
_policy_config(policy)
_rules_config(rules)
_routestopped_config(routestopped)
_masq_config(masq)
if config.changed:
puts("Shorewall configuration changed")
if is_started():
restart('shorewall')
with settings(hide('running'), shell_env()):
sed('/etc/default/shorewall', 'startup=0', 'startup=1', use_sudo=True)
def locales(names):
"""
Require the list of locales to be available.
Raises UnsupportedLocales if some of the required locales
are not supported.
"""
family = distrib_family()
if family == 'debian':
command = 'dpkg-reconfigure --frontend=noninteractive locales'
if distrib_id() == 'Ubuntu':
config_file = '/var/lib/locales/supported.d/local'
if not is_file(config_file):
run_as_root('touch %s' % config_file)
else:
config_file = '/etc/locale.gen'
_locales_generic(names, config_file=config_file, command=command)
elif family in ['arch', 'gentoo']:
_locales_generic(names, config_file='/etc/locale.gen', command='locale-gen')
elif distrib_family() == 'redhat':
_locales_redhat(names)
else:
raise UnsupportedFamily(supported=['debian', 'arch', 'gentoo', 'redhat'])
def uninstall_blacklisted(self):
"""
Uninstalls all blacklisted packages.
"""
from burlap.system import distrib_family
blacklisted_packages = self.env.blacklisted_packages
if not blacklisted_packages:
print('No blacklisted packages.')
return
else:
family = distrib_family()
if family == DEBIAN:
self.sudo('DEBIAN_FRONTEND=noninteractive apt-get -yq purge %s' % ' '.join(blacklisted_packages))
else:
raise NotImplementedError('Unknown family: %s' % family)
def installed_from_source(version=VERSION):
"""
Require Redis to be installed from source.
The compiled binaries will be installed in ``/opt/redis-{version}/``.
"""
from burlap.require import directory as require_directory
from burlap.require import file as require_file
from burlap.require import user as require_user
from burlap.require.deb import packages as require_deb_packages
from burlap.require.rpm import packages as require_rpm_packages
family = distrib_family()
if family == 'debian':
require_deb_packages([
'build-essential',
])
elif family == 'redhat':
require_rpm_packages([
'gcc',
'make',
])
require_user('redis', home='/var/lib/redis', system=True)
require_directory('/var/lib/redis', owner='redis', use_sudo=True)
dest_dir = '/opt/redis-%(version)s' % locals()
require_directory(dest_dir, use_sudo=True, owner='redis')
if not is_file('%(dest_dir)s/redis-server' % locals()):
with cd('/tmp'):
# Download and unpack the tarball
tarball = 'redis-%(version)s.tar.gz' % locals()
url = _download_url(version) + tarball
require_file(tarball, url=url)
run('tar xzf %(tarball)s' % locals())
# Compile and install binaries
with cd('redis-%(version)s' % locals()):
run('make')
for filename in BINARIES:
run_as_root('cp -pf src/%(filename)s %(dest_dir)s/' % locals())
run_as_root('chown redis: %(dest_dir)s/%(filename)s' % locals())
def default_locale(name):
"""
Require the locale to be the default.
"""
from burlap.require import file as require_file
# Ensure the locale is available
locale(name)
# Make it the default
contents = 'LANG="%s"\n' % name
if distrib_family() == 'arch':
config_file = '/etc/locale.conf'
else:
config_file = '/etc/default/locale'
require_file(config_file, contents, use_sudo=True)
def server(version=None):
"""
Require a PostgreSQL server to be installed and running.
::
from burlap import require
require.postgres.server()
"""
family = distrib_family()
if family == 'debian':
_server_debian(version)
else:
raise UnsupportedFamily(supported=['debian'])
def server(version=None):
"""
Require a PostgreSQL server to be installed and running.
::
from burlap import require
require.postgres.server()
"""
family = distrib_family()
if family == 'debian':
_server_debian(version)
else:
raise UnsupportedFamily(supported=['debian'])
def server():
"""
Require the Apache HTTP server to be installed and running.
::
from burlap import require
require.apache.server()
"""
family = distrib_family()
if family == 'debian':
_server_debian()
else:
raise UnsupportedFamily(supported=['debian'])
def default_locale(name):
"""
Require the locale to be the default.
"""
from burlap.require import file as require_file
# Ensure the locale is available
locale(name)
# Make it the default
contents = 'LANG="%s"\n' % name
if distrib_family() == 'arch':
config_file = '/etc/locale.conf'
else:
config_file = '/etc/default/locale'
require_file(config_file, contents, use_sudo=True)
def server():
"""
Require the Apache HTTP server to be installed and running.
::
from burlap import require
require.apache.server()
"""
family = distrib_family()
if family == 'debian':
_server_debian()
else:
raise UnsupportedFamily(supported=['debian'])
def uninstall_blacklisted(self):
"""
Uninstalls all blacklisted packages.
"""
from burlap.system import distrib_family
blacklisted_packages = self.env.blacklisted_packages
if not blacklisted_packages:
print('No blacklisted packages.')
return
else:
family = distrib_family()
if family == DEBIAN:
self.sudo(
'DEBIAN_FRONTEND=noninteractive apt-get -yq purge %s' %
' '.join(blacklisted_packages))
else:
raise NotImplementedError('Unknown family: %s' % family)
def firewall(zones=None, interfaces=None, policy=None, rules=None,
routestopped=None, masq=None):
"""
Ensure that a firewall is configured.
Example::
from burlap.shorewall import *
from burlap import require
# We need a firewall with some custom rules
require.shorewall.firewall(
rules=[
Ping(),
SSH(),
HTTP(),
HTTPS(),
SMTP(),
rule(port=1234, source=hosts(['example.com'])),
]
)
"""
family = distrib_family()
if family != 'debian':
raise UnsupportedFamily(supported=['debian'])
require_deb_package('shorewall')
with watch(CONFIG_FILES) as config:
_zone_config(zones)
_interfaces_config(interfaces)
_policy_config(policy)
_rules_config(rules)
_routestopped_config(routestopped)
_masq_config(masq)
if config.changed:
puts("Shorewall configuration changed")
if is_started():
restart('shorewall')
with settings(hide('running'), shell_env()):
sed('/etc/default/shorewall', 'startup=0', 'startup=1', use_sudo=True)
def server(version=None, password=None):
"""
Require a MySQL server to be installed and running.
Example::
from burlap import require
require.mysql.server(password='******')
"""
family = distrib_family()
if family == 'debian':
_server_debian(version, password)
elif family == 'redhat':
_server_redhat(version, password)
else:
raise UnsupportedFamily(supported=['debian', 'redhat'])
def server(package_name='nginx'):
"""
Require the nginx web server to be installed and running.
You can override the system package name, if you need to install
a specific variant such as `nginx-extras` or `nginx-light`.
::
from burlap import require
require.nginx.server()
"""
family = distrib_family()
if family == 'debian':
_server_debian(package_name)
else:
raise UnsupportedFamily(supported=['debian'])
def server(package_name='nginx'):
"""
Require the nginx web server to be installed and running.
You can override the system package name, if you need to install
a specific variant such as `nginx-extras` or `nginx-light`.
::
from burlap import require
require.nginx.server()
"""
family = distrib_family()
if family == 'debian':
_server_debian(package_name)
else:
raise UnsupportedFamily(supported=['debian'])
def is_running(service):
"""
Check if a service is running.
::
import burlap
if burlap.service.is_running('foo'):
print("Service foo is running!")
"""
#DEPRECATED?
service = service.strip().lower()
_ran = False
for _service in env.services:
_service = _service.strip().upper()
if service and _service.lower() != service:
continue
srv = common.services.get(_service)
if srv:
_ran = True
#print('%s.is_running: %s' % (service, srv.is_running()))
return srv.is_running()
with settings(hide('running', 'stdout', 'stderr', 'warnings'),
warn_only=True):
if using_systemd():
return systemd.is_running(service)
else:
if distrib_family() != "gentoo":
test_upstart = run_as_root('test -f /etc/init/%s.conf' %
service)
status = _run_service(service, 'status')
if test_upstart.succeeded:
return 'running' in status
else:
return status.succeeded
else:
# gentoo
status = _run_service(service, 'status')
return ' started' in status
def sysctl(key, value, persist=True):
"""
Require a kernel parameter to have a specific value.
"""
if get_sysctl(key) != value:
set_sysctl(key, value)
if persist:
from burlap.require import file as require_file
filename = '/etc/sysctl.d/60-%s.conf' % key
with watch(filename, use_sudo=True) as config:
require_file(filename,
contents='%(key)s = %(value)s\n' % locals(),
use_sudo=True)
if config.changed:
if distrib_family() == 'debian':
with settings(warn_only=True):
run_as_root('service procps start')
def sysctl(key, value, persist=True):
"""
Require a kernel parameter to have a specific value.
"""
if get_sysctl(key) != value:
set_sysctl(key, value)
if persist:
from burlap.require import file as require_file
filename = '/etc/sysctl.d/60-%s.conf' % key
with watch(filename, use_sudo=True) as config:
require_file(filename,
contents='%(key)s = %(value)s\n' % locals(),
use_sudo=True)
if config.changed:
if distrib_family() == 'debian':
with settings(warn_only=True):
run_as_root('service procps start')
def install_from_upstream(self):
"""
Installs Vagrant from the most recent package available from their homepage.
"""
from burlap.system import get_arch, distrib_family
r = self.local_renderer
content = urlopen(r.env.download_url).read()
print(len(content))
matches = DOWNLOAD_LINK_PATTERN.findall(content)
print(matches)
arch = get_arch() # e.g. 'x86_64'
family = distrib_family()
if family == DEBIAN:
ext = '.deb'
matches = [match for match in matches if match.endswith(ext) and arch in match]
print('matches:', matches)
assert matches, "No matches found."
assert len(matches) == 1, "Too many matches found: %s" % (', '.join(matches))
r.env.final_download_url = matches[0]
r.env.local_filename = '/tmp/vagrant%s' % ext
r.run('wget -O {local_filename} {final_download_url}')
r.sudo('dpkg -i {local_filename}')
else:
raise NotImplementedError('Unsupported family: %s' % family)
def process(name, **kwargs):
"""
Require a supervisor process to be running.
Keyword arguments will be used to build the program configuration
file. Some useful arguments are:
- ``command``: complete command including arguments (**required**)
- ``directory``: absolute path to the working directory
- ``user``: run the process as this user
- ``stdout_logfile``: absolute path to the log file
You should refer to the `supervisor documentation`_ for the
complete list of allowed arguments.
.. note:: the default values for the following arguments differs from
the ``supervisor`` defaults:
- ``autorestart``: defaults to ``true``
- ``redirect_stderr``: defaults to ``true``
Example::
from burlap import require
require.supervisor.process('myapp',
command='/path/to/venv/bin/myapp --config production.ini --someflag',
directory='/path/to/working/dir',
user='******',
stdout_logfile='/path/to/logs/myapp.log',
)
.. _supervisor documentation: http://supervisord.org/configuration.html#program-x-section-values
"""
from burlap.require import file as require_file
from burlap.require.deb import package as require_deb_package
from burlap.require.rpm import package as require_rpm_package
from burlap.require.arch import package as require_arch_package
from burlap.require.service import started as require_started
family = distrib_family()
if family == 'debian':
require_deb_package('supervisor')
require_started('supervisor')
elif family == 'redhat':
require_rpm_package('supervisord')
require_started('supervisord')
elif family == 'arch':
require_arch_package('supervisor')
require_started('supervisord')
else:
raise UnsupportedFamily(supported=['debian', 'redhat', 'arch'])
# Set default parameters
params = {}
params.update(kwargs)
params.setdefault('autorestart', 'true')
params.setdefault('redirect_stderr', 'true')
# Build config file from parameters
lines = []
lines.append('[program:%(name)s]' % locals())
for key, value in sorted(params.items()):
lines.append("%s=%s" % (key, value))
# Upload config file
if family == 'debian':
filename = '/etc/supervisor/conf.d/%(name)s.conf' % locals()
elif family == 'redhat':
filename = '/etc/supervisord.d/%(name)s.ini' % locals()
elif family == 'arch':
filename = '/etc/supervisor.d/%(name)s.ini' % locals()
with watch(filename, callback=update_config, use_sudo=True):
require_file(filename, contents='\n'.join(lines), use_sudo=True)
# Start the process if needed
if process_status(name) == 'STOPPED':
start_process(name)
def _update_package_index():
from burlap.system import distrib_family
family = distrib_family()
if family == 'debian':
from burlap.require.deb import uptodate_index
uptodate_index()
def _uninstall_nginx():
family = distrib_family()
if family == 'debian':
from burlap.require.deb import nopackage
nopackage('nginx')
def check_for_debian_family():
from burlap.system import distrib_family
if distrib_family() != 'debian':
pytest.skip("Skipping Apache test on non-Debian distrib")
def _uninstall_apache():
family = distrib_family()
if family == 'debian':
from burlap.require.deb import nopackage
with quiet():
nopackage('apache2')
def process(name, **kwargs):
"""
Require a supervisor process to be running.
Keyword arguments will be used to build the program configuration
file. Some useful arguments are:
- ``command``: complete command including arguments (**required**)
- ``directory``: absolute path to the working directory
- ``user``: run the process as this user
- ``stdout_logfile``: absolute path to the log file
You should refer to the `supervisor documentation`_ for the
complete list of allowed arguments.
.. note:: the default values for the following arguments differs from
the ``supervisor`` defaults:
- ``autorestart``: defaults to ``true``
- ``redirect_stderr``: defaults to ``true``
Example::
from burlap import require
require.supervisor.process('myapp',
command='/path/to/venv/bin/myapp --config production.ini --someflag',
directory='/path/to/working/dir',
user='******',
stdout_logfile='/path/to/logs/myapp.log',
)
.. _supervisor documentation: http://supervisord.org/configuration.html#program-x-section-values
"""
from burlap.require import file as require_file
from burlap.require.deb import package as require_deb_package
from burlap.require.rpm import package as require_rpm_package
from burlap.require.arch import package as require_arch_package
from burlap.require.service import started as require_started
family = distrib_family()
if family == 'debian':
require_deb_package('supervisor')
require_started('supervisor')
elif family == 'redhat':
require_rpm_package('supervisord')
require_started('supervisord')
elif family == 'arch':
require_arch_package('supervisor')
require_started('supervisord')
else:
raise UnsupportedFamily(supported=['debian', 'redhat', 'arch'])
# Set default parameters
params = {}
params.update(kwargs)
params.setdefault('autorestart', 'true')
params.setdefault('redirect_stderr', 'true')
# Build config file from parameters
lines = []
lines.append('[program:%(name)s]' % locals())
for key, value in sorted(params.items()):
lines.append("%s=%s" % (key, value))
# Upload config file
if family == 'debian':
filename = '/etc/supervisor/conf.d/%(name)s.conf' % locals()
elif family == 'redhat':
filename = '/etc/supervisord.d/%(name)s.ini' % locals()
elif family == 'arch':
filename = '/etc/supervisor.d/%(name)s.ini' % locals()
with watch(filename, callback=update_config, use_sudo=True):
require_file(filename, contents='\n'.join(lines), use_sudo=True)
# Start the process if needed
if process_status(name) == 'STOPPED':
start_process(name)
def check_for_debian_family():
from burlap.system import distrib_family
if distrib_family() != 'debian':
pytest.skip("Skipping Apache test on non-Debian distrib")
def _uninstall_apache():
family = distrib_family()
if family == 'debian':
from burlap.require.deb import nopackage
with quiet():
nopackage('apache2')
def _uninstall_nginx():
family = distrib_family()
if family == 'debian':
from burlap.require.deb import nopackage
nopackage('nginx')
def install_from_source(version=DEFAULT_VERSION, checkinstall=False):
"""
Install Node JS from source.
If *checkinstall* is ``True``, a distribution package will be built.
::
import burlap
# Install Node.js
burlap.nodejs.install_nodejs()
.. note:: This function may not work for old versions of Node.js.
"""
from burlap.require.deb import packages as require_deb_packages
from burlap.require.rpm import packages as require_rpm_packages
from burlap.require import file as require_file
family = distrib_family()
if family == 'debian':
packages = [
'build-essential',
'libssl-dev',
'python',
]
if checkinstall:
packages.append('checkinstall')
require_deb_packages(packages)
elif family == 'redhat':
packages = [
'gcc',
'gcc-c++',
'make',
'openssl-devel',
'python',
]
if checkinstall:
packages.append('checkinstall')
require_rpm_packages(packages)
filename = 'node-v%s.tar.gz' % version
foldername = filename[0:-7]
require_file(url='http://nodejs.org/dist/v%(version)s/%(filename)s' % {
'version': version,
'filename': filename,
})
run('tar -xzf %s' % filename)
with cd(foldername):
run('./configure')
run('make -j%d' % (cpus() + 1))
if checkinstall:
run_as_root('checkinstall -y --pkgname=nodejs --pkgversion=%(version) '
'--showinstall=no make install' % locals())
else:
run_as_root('make install')
run('rm -rf %(filename)s %(foldername)s' % locals())
def install_from_source(version=DEFAULT_VERSION, checkinstall=False):
"""
Install Node JS from source.
If *checkinstall* is ``True``, a distribution package will be built.
::
import burlap
# Install Node.js
burlap.nodejs.install_nodejs()
.. note:: This function may not work for old versions of Node.js.
"""
from burlap.require.deb import packages as require_deb_packages
from burlap.require.rpm import packages as require_rpm_packages
from burlap.require import file as require_file
family = distrib_family()
if family == 'debian':
packages = [
'build-essential',
'libssl-dev',
'python',
]
if checkinstall:
packages.append('checkinstall')
require_deb_packages(packages)
elif family == 'redhat':
packages = [
'gcc',
'gcc-c++',
'make',
'openssl-devel',
'python',
]
if checkinstall:
packages.append('checkinstall')
require_rpm_packages(packages)
filename = 'node-v%s.tar.gz' % version
foldername = filename[0:-7]
require_file(url='http://nodejs.org/dist/v%(version)s/%(filename)s' % {
'version': version,
'filename': filename,
})
run('tar -xzf %s' % filename)
with cd(foldername):
run('./configure')
run('make -j%d' % (cpus() + 1))
if checkinstall:
run_as_root(
'checkinstall -y --pkgname=nodejs --pkgversion=%(version) '
'--showinstall=no make install' % locals())
else:
run_as_root('make install')
run('rm -rf %(filename)s %(foldername)s' % locals())
def _update_package_index():
from burlap.system import distrib_family
family = distrib_family()
if family == 'debian':
from burlap.require.deb import uptodate_index
uptodate_index()
