def test_require_directory_in_guest_context_manager(container):
from fabtools.openvz import guest
with guest(container):
require_directory('/tmp/newdir')
with cd('/tmp/newdir'):
run('touch baz')
assert is_file('/tmp/newdir/baz')
def test_require_directory_in_guest_context_manager(container):
from fabtools.openvz import guest
with guest(container):
require_directory('/tmp/newdir')
with cd('/tmp/newdir'):
run('touch baz')
assert is_file('/tmp/newdir/baz')
def installed_from_source(version=VERSION):
"""
Require Redis to be installed from source.
The compiled binaries will be installed in ``/opt/redis-{version}/``.
"""
from fabtools.require import directory as require_directory
from fabtools.require import file as require_file
from fabtools.require import user as require_user
from fabtools.require.deb import packages as require_deb_packages
from fabtools.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 user(name, comment=None, home=None, create_home=None, skeleton_dir=None,
group=None, create_group=True, extra_groups=None, password=None,
system=False, shell=None, uid=None, ssh_public_keys=None,
non_unique=False):
"""
Require a user and its home directory.
See :func:`fabtools.user.create` for a detailed description of
arguments.
::
from fabtools import require
# This will also create a home directory for alice
require.user('alice')
# Sometimes we don't need a home directory
require.user('mydaemon', create_home=False)
# Require a user without shell access
require.user('nologin', shell='/bin/false')
.. note:: This function can be accessed directly from the
``fabtools.require`` module for convenience.
"""
from fabtools.require import directory as require_directory
# Make sure the user exists
if not exists(name):
create(name, comment=comment, home=home, create_home=create_home,
skeleton_dir=skeleton_dir, group=group,
create_group=create_group, extra_groups=extra_groups,
password=password, system=system, shell=shell, uid=uid,
ssh_public_keys=ssh_public_keys, non_unique=non_unique)
else:
modify(name, comment=comment, home=home, group=group,
extra_groups=extra_groups, password=password,
shell=shell, uid=uid, ssh_public_keys=ssh_public_keys,
non_unique=non_unique)
# Make sure the home directory exists and is owned by user
if home:
require_directory(home, owner=name, use_sudo=True)
def installed_from_source(version=VERSION):
"""
Require Redis to be installed from source.
The compiled binaries will be installed in ``/opt/redis-{version}/``.
"""
from fabtools.require import directory as require_directory
from fabtools.require import file as require_file
from fabtools.require import user as require_user
from fabtools.require.deb import packages as require_deb_packages
from fabtools.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 instance(name, version=VERSION, **kwargs):
"""
Require a Redis instance to be running.
The instance will be managed using supervisord, as a process named
``redis_{name}``, running as the ``redis`` user.
::
from fabtools import require
from fabtools.supervisor import process_status
require.redis.installed_from_source()
require.redis.instance('db1', port='6379')
require.redis.instance('db2', port='6380')
print process_status('redis_db1')
print process_status('redis_db2')
.. seealso:: :ref:`supervisor_module` and
:ref:`require_supervisor_module`
"""
from fabtools.require import directory as require_directory
from fabtools.require import file as require_file
from fabtools.require.supervisor import process as require_process
from fabtools.require.system import sysctl as require_sysctl
installed_from_source(version)
require_directory('/etc/redis', use_sudo=True, owner='redis')
require_directory('/var/db/redis', use_sudo=True, owner='redis')
require_directory('/var/log/redis', use_sudo=True, owner='redis')
# Required for background saving
with settings(warn_only=True):
require_sysctl('vm.overcommit_memory', '1')
# Set default parameters
params = {}
params.update(kwargs)
params.setdefault('bind', '127.0.0.1')
params.setdefault('port', '6379')
params.setdefault('logfile', '/var/log/redis/redis-%(name)s.log' % locals())
params.setdefault('loglevel', 'verbose')
params.setdefault('dir', '/var/db/redis')
params.setdefault('dbfilename', 'redis-%(name)s-dump.rdb' % locals())
params.setdefault('save', ['900 1', '300 10', '60 10000'])
# Build config file from parameters
# (keys such as 'save' may result in multiple config lines)
lines = []
for key, value in sorted(params.items()):
if isinstance(value, list):
for elem in value:
lines.append("%s %s" % (key, elem))
else:
lines.append("%s %s" % (key, value))
redis_server = '/opt/redis-%(version)s/redis-server' % locals()
config_filename = '/etc/redis/%(name)s.conf' % locals()
# Upload config file
with watch(config_filename, use_sudo=True) as config:
require_file(config_filename, contents='\n'.join(lines),
use_sudo=True, owner='redis')
# Use supervisord to manage process
process_name = 'redis_%s' % name
require_process(
process_name,
user='******',
directory='/var/run',
command="%(redis_server)s %(config_filename)s" % locals(),
)
# Restart if needed
if config.changed:
fabtools.supervisor.restart_process(process_name)
def user(name,
comment=None,
home=None,
create_home=None,
skeleton_dir=None,
group=None,
create_group=True,
extra_groups=None,
password=None,
system=False,
shell=None,
uid=None):
"""
Require a user and its home directory.
See :func:`fabtools.user.create` for a detailed description of
arguments.
::
from fabtools import require
# This will also create a home directory for alice
require.user('alice')
# Sometimes we don't need a home directory
require.user('mydaemon', create_home=False)
# Require a user without shell access
require.user('nologin', shell='/bin/false')
.. note:: This function can be accessed directly from the
``fabtools.require`` module for convenience.
"""
from fabtools.require import directory as require_directory
# Make sure the user exists
if not exists(name):
create(name,
comment=comment,
home=home,
create_home=create_home,
skeleton_dir=skeleton_dir,
group=group,
create_group=create_group,
extra_groups=extra_groups,
password=password,
system=system,
shell=shell,
uid=uid)
else:
modify(name,
comment=comment,
home=home,
group=group,
extra_groups=extra_groups,
password=password,
shell=shell,
uid=uid)
# Make sure the home directory exists and is owned by user
if home:
require_directory(home, owner=name, use_sudo=True)
def instance(name, version=VERSION, bind='127.0.0.1', port=6379, **kwargs):
"""
Require a Redis instance to be running.
The required Redis version will be automatically installed using
:py:func:`fabtools.require.redis.installed_from_source` if needed.
You can specify the IP address and port on which to listen to using the
*bind* and *port* parameters.
.. warning::
Redis is designed to be accessed by trusted clients inside trusted
environments. It is usually not a good idea to expose the Redis
instance directly to the internet. Therefore, with the default
settings, the Redis instance will only listen to local clients.
If you want to make your Redis instance accessible to other servers
over an untrusted network, you should probably add some firewall rules
to restrict access. For example: ::
from fabtools import require
from fabtools.shorewall import Ping, SSH, hosts, rule
# The computers that will need to talk to the Redis server
REDIS_CLIENTS = [
'web1.example.com',
'web2.example.com',
]
# The Redis server port
REDIS_PORT = 6379
# Setup a basic firewall
require.shorewall.firewall(
rules=[
Ping(),
SSH(),
rule(port=REDIS_PORT, source=hosts(REDIS_CLIENTS)),
]
)
# Make the Redis instance listen on all interfaces
require.redis.instance('mydb', bind='0.0.0.0', port=REDIS_PORT)
.. seealso:: `Redis Security <http://redis.io/topics/security>`_
You can also use any valid Redis configuration directives as extra
keyword arguments. For directives that can be repeated on multiple
lines (such as ``save``), you can supply a list of values.
The instance will be managed using supervisord, as a process named
``redis_{name}``, running as the ``redis`` user.
::
from fabtools import require
from fabtools.supervisor import process_status
require.redis.instance('mydb')
print process_status('redis_mydb')
.. seealso:: :ref:`supervisor_module` and
:ref:`require_supervisor_module`
The default settings enable persistence using periodic RDB snapshots
saved in the `/var/db/redis` directory.
You may want to use AOF persistence instead: ::
require.redis.instance('mydb', appendonly='yes', save=[])
In certain situations, you may want to disable persistence completely: ::
require.redis.instance('cache', port=6380, save=[])
.. seealso:: `Redis Persistence <http://redis.io/topics/persistence>`_
"""
from fabtools.require import directory as require_directory
from fabtools.require import file as require_file
from fabtools.require.supervisor import process as require_process
from fabtools.require.system import sysctl as require_sysctl
installed_from_source(version)
require_directory('/etc/redis', use_sudo=True, owner='redis')
require_directory('/var/db/redis', use_sudo=True, owner='redis')
require_directory('/var/log/redis', use_sudo=True, owner='redis')
# Required for background saving
with settings(warn_only=True):
require_sysctl('vm.overcommit_memory', '1')
# Set default parameters
params = {}
params.update(kwargs)
params.setdefault('bind', bind)
params.setdefault('port', port)
params.setdefault('logfile', '/var/log/redis/redis-%(name)s.log' % locals())
params.setdefault('loglevel', 'verbose')
params.setdefault('dir', '/var/db/redis')
params.setdefault('dbfilename', 'redis-%(name)s-dump.rdb' % locals())
params.setdefault('save', ['900 1', '300 10', '60 10000'])
# Build config file from parameters
# (keys such as 'save' may result in multiple config lines)
lines = []
for key, value in sorted(params.items()):
if isinstance(value, list):
for elem in value:
lines.append("%s %s" % (key, elem))
else:
lines.append("%s %s" % (key, value))
redis_server = '/opt/redis-%(version)s/redis-server' % locals()
config_filename = '/etc/redis/%(name)s.conf' % locals()
# Upload config file
with watch(config_filename, use_sudo=True) as config:
require_file(config_filename, contents='\n'.join(lines),
use_sudo=True, owner='redis')
# Use supervisord to manage process
process_name = 'redis_%s' % name
require_process(
process_name,
user='******',
directory='/var/run',
command="%(redis_server)s %(config_filename)s" % locals(),
)
# Restart if needed
if config.changed:
fabtools.supervisor.restart_process(process_name)
def instance(name, version=VERSION, bind='127.0.0.1', port=6379, **kwargs):
"""
Require a Redis instance to be running.
The required Redis version will be automatically installed using
:py:func:`fabtools.require.redis.installed_from_source` if needed.
You can specify the IP address and port on which to listen to using the
*bind* and *port* parameters.
.. warning::
Redis is designed to be accessed by trusted clients inside trusted
environments. It is usually not a good idea to expose the Redis
instance directly to the internet. Therefore, with the default
settings, the Redis instance will only listen to local clients.
If you want to make your Redis instance accessible to other servers
over an untrusted network, you should probably add some firewall rules
to restrict access. For example: ::
from fabtools import require
from fabtools.shorewall import Ping, SSH, hosts, rule
# The computers that will need to talk to the Redis server
REDIS_CLIENTS = [
'web1.example.com',
'web2.example.com',
]
# The Redis server port
REDIS_PORT = 6379
# Setup a basic firewall
require.shorewall.firewall(
rules=[
Ping(),
SSH(),
rule(port=REDIS_PORT, source=hosts(REDIS_CLIENTS)),
]
)
# Make the Redis instance listen on all interfaces
require.redis.instance('mydb', bind='0.0.0.0', port=REDIS_PORT)
.. seealso:: `Redis Security <http://redis.io/topics/security>`_
You can also use any valid Redis configuration directives as extra
keyword arguments. For directives that can be repeated on multiple
lines (such as ``save``), you can supply a list of values.
The instance will be managed using supervisord, as a process named
``redis_{name}``, running as the ``redis`` user.
::
from fabtools import require
from fabtools.supervisor import process_status
require.redis.instance('mydb')
print process_status('redis_mydb')
.. seealso:: :ref:`supervisor_module` and
:ref:`require_supervisor_module`
The default settings enable persistence using periodic RDB snapshots
saved in the `/var/db/redis` directory.
You may want to use AOF persistence instead: ::
require.redis.instance('mydb', appendonly='yes', save=[])
In certain situations, you may want to disable persistence completely: ::
require.redis.instance('cache', port=6380, save=[])
.. seealso:: `Redis Persistence <http://redis.io/topics/persistence>`_
"""
from fabtools.require import directory as require_directory
from fabtools.require import file as require_file
from fabtools.require.supervisor import process as require_process
from fabtools.require.system import sysctl as require_sysctl
installed_from_source(version)
require_directory('/etc/redis', use_sudo=True, owner='redis')
require_directory('/var/db/redis', use_sudo=True, owner='redis')
require_directory('/var/log/redis', use_sudo=True, owner='redis')
# Required for background saving
with settings(warn_only=True):
require_sysctl('vm.overcommit_memory', '1')
# Set default parameters
params = {}
params.update(kwargs)
params.setdefault('bind', bind)
params.setdefault('port', port)
params.setdefault(
'logfile', '/var/log/redis/redis-%(name)s.log' % locals())
params.setdefault('loglevel', 'verbose')
params.setdefault('dir', '/var/db/redis')
params.setdefault('dbfilename', 'redis-%(name)s-dump.rdb' % locals())
params.setdefault('save', ['900 1', '300 10', '60 10000'])
# Build config file from parameters
# (keys such as 'save' may result in multiple config lines)
lines = []
for key, value in sorted(params.items()):
if isinstance(value, list):
for elem in value:
lines.append("%s %s" % (key, elem))
else:
lines.append("%s %s" % (key, value))
redis_server = '/opt/redis-%(version)s/redis-server' % locals()
config_filename = '/etc/redis/%(name)s.conf' % locals()
# Upload config file
with watch(config_filename, use_sudo=True) as config:
require_file(config_filename, contents='\n'.join(lines),
use_sudo=True, owner='redis')
# Use supervisord to manage process
process_name = 'redis_%s' % name
require_process(
process_name,
user='******',
directory='/var/run',
command="%(redis_server)s %(config_filename)s" % locals(),
)
# Restart if needed
if config.changed:
fabtools.supervisor.restart_process(process_name)
def testdir():
require_directory('nodetest')
yield 'nodetest'
run('rm -rf nodetest')
def testdir(request):
require_directory('nodetest')
request.addfinalizer(functools.partial(run, 'rm -rf nodetest'))
return 'nodetest'
def instance(name, version=VERSION, **kwargs):
"""
Require a Redis instance to be running.
The instance will be managed using supervisord, as a process named
``redis_{name}``, running as the ``redis`` user.
::
from fabtools import require
from fabtools.supervisor import process_status
require.redis.installed_from_source()
require.redis.instance('db1', port='6379')
require.redis.instance('db2', port='6380')
print process_status('redis_db1')
print process_status('redis_db2')
.. seealso:: :ref:`supervisor_module` and
:ref:`require_supervisor_module`
"""
from fabtools.require import directory as require_directory
from fabtools.require import file as require_file
from fabtools.require.supervisor import process as require_process
from fabtools.require.system import sysctl as require_sysctl
installed_from_source(version)
require_directory('/etc/redis', use_sudo=True, owner='redis')
require_directory('/var/db/redis', use_sudo=True, owner='redis')
require_directory('/var/log/redis', use_sudo=True, owner='redis')
require_directory('/var/run/redis', use_sudo=True, owner='redis')
# Required for background saving
with settings(warn_only=True):
require_sysctl('vm.overcommit_memory', '1')
# Set default parameters
params = {}
params.update(kwargs)
params.setdefault('bind', '127.0.0.1')
params.setdefault('port', '6379')
params.setdefault('logfile',
'/var/log/redis/redis-%(name)s.log' % locals())
params.setdefault('loglevel', 'verbose')
params.setdefault('dbfilename',
'/var/db/redis/redis-%(name)s-dump.rdb' % locals())
params.setdefault('save', ['900 1', '300 10', '60 10000'])
# Build config file from parameters
# (keys such as 'save' may result in multiple config lines)
lines = []
for key, value in sorted(params.items()):
if isinstance(value, list):
for elem in value:
lines.append("%s %s" % (key, elem))
else:
lines.append("%s %s" % (key, value))
redis_server = '/opt/redis-%(version)s/redis-server' % locals()
config_filename = '/etc/redis/%(name)s.conf' % locals()
# Upload config file
with watch(config_filename, use_sudo=True) as config:
require_file(config_filename,
contents='\n'.join(lines),
use_sudo=True,
owner='redis')
# Use supervisord to manage process
process_name = 'redis_%s' % name
require_process(
process_name,
user='******',
directory='/var/run/redis',
command="%(redis_server)s %(config_filename)s" % locals(),
)
# Restart if needed
if config.changed:
fabtools.supervisor.restart_process(process_name)
def testdir():
require_directory("nodetest")
yield "nodetest"
run("rm -rf nodetest")
