def install_nginx0(*args, **kwargs):
apt_depends("apt-transport-https", "ca-certificates", "curl")
if run("dpkg -s nginx", warn_only=True, quiet=True).succeeded:
return "nginx is already installed"
dist = get_pretty_name()
if run(
"curl -s http://nginx.org/packages/ubuntu/dists/ | grep -sq {dist}"
.format(dist=dist),
warn_only=True,
).failed:
raise NotImplementedError(
"nginx official repostories don't support {dist}".format(
dist=dist))
run("mkdir -p Downloads")
key = "nginx_signing.key"
run("curl https://nginx.org/keys/{key} -o Downloads/{key}".format(key=key))
sudo("apt-key add Downloads/{key}".format(key=key))
append(
"/etc/apt/sources.list.d/nginx.list",
(lambda endl: (
"deb {endl}".format(endl=endl),
"deb-src {endl}".format(endl=endl),
))(endl="http://nginx.org/packages/ubuntu/ {dist} nginx".format(
dist=dist)),
use_sudo=True,
)
apt_depends("nginx")
return "nginx is now installed"
def pull0(destory_cache=True, **kwargs):
apt_depends("git")
run_cmd = partial(_run_command, sudo=kwargs.get("use_sudo"))
cache = not destory_cache and exists(kwargs["GIT_DIR"])
if cache:
dirnam = run_cmd("mktemp -d --suffix '{name}'".format(
name=kwargs["GIT_DIR"][kwargs["GIT_DIR"].rfind("/") + 1:]))
run_cmd(
"""while read -r l; do [ -e "$l" ] && mv "$l" '{dirnam}' & done <'{git_dir}/.gitignore' """
.format(dirnam=dirnam, git_dir=kwargs["GIT_DIR"]))
clone_or_update(
repo=kwargs["GIT_REPO"],
to_dir=kwargs["GIT_DIR"],
use_sudo=kwargs.get("use_sudo", False),
branch=kwargs.get("GIT_BRANCH", "master"),
skip_reset=kwargs.get("skip_reset", False),
cmd_runner=run_cmd,
)
if cache:
run_cmd(
"""while read -r l; do d="{dirnam}/$l"; [ -e "$d" ] && cp -r "$d" '{git_dir}' & done <'{git_dir}/.gitignore' """
.format(dirnam=dirnam, git_dir=kwargs["GIT_DIR"]))
run_cmd("rm -rf {dirnam}".format(dirnam=dirnam))
return "[git] Updated"
def step0(*args, **kwargs):
master = kwargs.pop('master', False)
version = '0.28.1'
if run("dpkg-query --showformat='${Version}' --show mesos", warn_only=True).startswith(version):
local('echo {command} {version} is already installed'.format(command='mesos', version=version))
return 'mesos already installed'
apt_depends('curl', # 'gdebi',
'openjdk-7-jre-headless')
run('mkdir -p $HOME/downloads')
with cd('$HOME/downloads'):
package = 'mesos-{version}-gcc4.8-amd64.deb'.format(version=version)
if not exists(package):
run('curl -OL https://github.com/offscale/packages/raw/master/{package}'.format(package=package))
# sudo('gdebi --non-interactive {package}'.format(package=package))
sudo('dpkg -i {package}'.format(package=package), warn_only=True)
sudo('apt-get --yes --fix-broken install')
apt_depends('python-pip')
with shell_env(HOME=run('echo $HOME')):
sudo('pip install mesos.cli mesos.interface')
_install_conf(master, MASTER_IP='127.0.0.1')
return 'mesos installed'
def install0(*args, **kwargs):
apt_depends("git")
go.install0()
if not cmd_avail("glide"):
run("curl https://glide.sh/get | sh")
gopath = run('echo "$GOPATH"', quiet=True)
to_dir = "{gopath}/src/github.com/bradleyfalzon/gopherci".format(gopath=gopath)
clone_or_update(
"gopherci",
team="SamuelMarks",
branch="master",
to_dir=to_dir,
skip_clean=True,
skip_reset=True,
)
with cd(to_dir):
run("glide i")
run("go build && mv gopherci $GOPATH/bin")
to_dir = "{gopath}/src/github.com/bradleyfalzon/gopherci-web".format(gopath=gopath)
clone_or_update(
"gopherci-web",
team="SamuelMarks",
branch="false-stripes",
to_dir=to_dir,
skip_clean=True,
skip_reset=True,
)
with cd(to_dir):
run("glide i")
run("go build && mv gopherci-web {gopath}/bin".format(gopath=gopath))
return {"installed": ("gopherci", "gopherci-web")}
def install0(**kwargs):
installed = lambda: run(
"dpkg-query --showformat='${Version}' --show rabbitmq-server",
quiet=True)
if sudo("dpkg -s rabbitmq-server", quiet=True, warn_only=True).failed:
apt_depends("apt-transport-https", "curl")
sudo(
"curl -fsSL https://github.com/rabbitmq/signing-keys/releases/download/2.0/rabbitmq-release-signing-key.asc"
" | apt-key add -")
sudo(
'apt-key adv --keyserver "hkps.pool.sks-keyservers.net" --recv-keys "0x6B73A36E6026DFCA"'
)
codename = run("lsb_release -cs", quiet=True)
append(
"/etc/apt/sources.list.d/bintray.erlang.list",
"deb https://dl.bintray.com/rabbitmq-erlang/debian {codename} erlang"
.format(codename=codename),
use_sudo=True,
)
append(
"/etc/apt/sources.list.d/bintray.rabbitmq.list",
"deb https://dl.bintray.com/rabbitmq/debian {codename} main".
format(codename=codename),
use_sudo=True,
)
sudo("apt-get update -qq")
apt_depends("rabbitmq-server")
return "RabbitMQ {} installed".format(installed())
return "[Already] RabbitMQ {} installed".format(installed())
def install_python_taiga_deps(cloned_xor_updated):
remote_home = run('printf $HOME')
apt_depends(
'python3', 'python3-pip', 'python-dev', 'python3-dev', 'python-pip', 'libzmq3-dev',
'virtualenvwrapper', 'libxml2-dev', 'libxslt1-dev', 'gettext', 'libgettextpo-dev'
)
if not run("dpkg-query --showformat='${Version}' --show python3-lxml") == '3.5.0-1':
download_and_install(url_prefix='https://launchpad.net/ubuntu/+source/lxml/3.5.0-1/+build/8393479/+files/',
packages=('python3-lxml_3.5.0-1_amd64.deb',))
with shell_env(WORKON_HOME=run('printf $HOME/.virtualenvs')), prefix(
'source /usr/share/virtualenvwrapper/virtualenvwrapper.sh'):
mkvirtualenv_if_needed_factory('-p /usr/bin/python3.4 --system-site-packages')('taiga')
with prefix('workon taiga'), cd('taiga-back'):
run("sed -i '0,/lxml==3.5.0b1/s//lxml==3.5.0/' requirements.txt")
run('pip install -r requirements.txt')
if cloned_xor_updated == 'cloned':
put(taiga_dir('django.settings.py'), 'settings/local.py')
run('python manage.py migrate --noinput')
run('python manage.py compilemessages')
run('python manage.py collectstatic --noinput')
run('python manage.py loaddata initial_user')
run('python manage.py loaddata initial_project_templates')
run('python manage.py loaddata initial_role')
run('python manage.py sample_data')
install_circus(template_vars={'HOME': remote_home, 'USER': run('printf $USER')},
local_tpl_dir=taiga_dir())
else:
run('python manage.py migrate --noinput')
run('python manage.py compilemessages')
run('python manage.py collectstatic --noinput')
sudo('service circus restart')
def install_plugin(repo_team, repo_name, location=None):
apt_depends('git')
cmd = 'dokku'
if not cmd_avail(cmd):
raise EnvironmentError('Install {cmd} before installing plugins'.format(cmd=cmd))
with cd('/var/lib/dokku/plugins'):
clone_or_update(team=repo_team, repo=repo_name, to_dir=location or repo_name)
run('dokku plugins-install')
def install_0():
apt_depends('apt-transport-https ca-certificates')
sudo('apt-key adv --keyserver hkp://p80.pool.sks-keyservers.net:80'
' --recv-keys 58118E89F3A912897C070ADBF76221572C52609D')
put(StringIO('deb https://apt.dockerproject.org/repo ubuntu-trusty main'),
'/etc/apt/sources.list.d/docker.list')
run('apt-cache policy docker-engine')
apt_depends('linux-image-extra-{uname}'.format(uname=run('uname -r')), 'docker-engine')
def ubuntu_install_flynn(*args, **kwargs):
apt_depends("curl")
command = "flynn"
if cmd_avail(command):
local("echo {command} is already installed".format(command=command))
return
# run('L=/usr/local/bin/flynn && curl -sSL -A "`uname -sp`" https://dl.flynn.io/cli | zcat >$L && chmod +x $L')
run("sudo bash < <(curl -fsSL https://dl.flynn.io/install-flynn)")
def ubuntu_install_flynn(*args, **kwargs):
apt_depends('curl')
command = 'flynn'
if cmd_avail(command):
local('echo {command} is already installed'.format(command=command))
return
# run('L=/usr/local/bin/flynn && curl -sSL -A "`uname -sp`" https://dl.flynn.io/cli | zcat >$L && chmod +x $L')
run('sudo bash < <(curl -fsSL https://dl.flynn.io/install-flynn)')
def install_venv0(python3=False, virtual_env=None, *args, **kwargs):
run_cmd = partial(_run_command, sudo=kwargs.get("use_sudo", False))
ensure_pip_version = lambda: kwargs.get("pip_version") and sudo(
"pip install pip=={}".format(kwargs.get("pip_version")))
home = kwargs.get("HOMEDIR", run("echo $HOME", quiet=True))
virtual_env = virtual_env or "{home}/venvs/tflow".format(home=home)
if python3:
apt_depends("python3-dev", "python3-pip", "python3-wheel",
"python3-venv")
else:
apt_depends("python-dev", "python-pip", "python-wheel", "python2.7",
"python2.7-dev") # 'python-apt'
sudo("pip install virtualenv")
virtual_env_bin = "{virtual_env}/bin".format(virtual_env=virtual_env)
if not exists(virtual_env_bin):
sudo(
'mkdir -p "{virtual_env_dir}"'.format(
virtual_env_dir=virtual_env[:virtual_env.rfind("/")]),
shell_escape=False,
)
if python3:
sudo(
'python3 -m venv "{virtual_env}"'.format(
virtual_env=virtual_env),
shell_escape=False,
)
else:
sudo(
'virtualenv "{virtual_env}"'.format(virtual_env=virtual_env),
shell_escape=False,
)
if not exists(virtual_env_bin):
raise ReferenceError("Virtualenv does not exist")
if not kwargs.get("use_sudo"):
user_group = run("echo $(id -un):$(id -gn)", quiet=True)
sudo("chown -R {user_group} {virtual_env} {home}/.cache".format(
user_group=user_group, virtual_env=virtual_env, home=home))
with shell_env(VIRTUAL_ENV=virtual_env,
PATH="{}/bin:$PATH".format(virtual_env)):
ensure_pip_version()
run_cmd("pip install -U wheel setuptools")
return "Installed: {} {}".format(
run_cmd("pip --version; python --version"),
pip_depends(
"{}/bin/python".format(virtual_env),
kwargs.get("use_sudo", False),
kwargs.get("packages", tuple()),
),
)
def install_plugin(repo_team, repo_name, location=None):
apt_depends("git")
cmd = "dokku"
if not cmd_avail(cmd):
raise EnvironmentError(
"Install {cmd} before installing plugins".format(cmd=cmd))
with cd("/var/lib/dokku/plugins"):
clone_or_update(team=repo_team,
repo=repo_name,
to_dir=location or repo_name)
run("dokku plugins-install")
def configure_riot4(root="/var/www/riot", **kwargs):
apt_depends("jq")
sudo(
"""jq '.default_hs_url = "https://{matrix_server_name}" """
'| .cross_origin_renderer_url = "https://{matrix_server_name}/v1.html" '
"""| .roomDirectory.servers = ["{matrix_server_name}"] + .roomDirectory.servers' """
"{root}/config.sample.json > {root}/config.json".format(
matrix_server_name=kwargs["MATRIX_SERVER_NAME"], root=root
)
)
def dl_install_opencv(branch='2.4', extra_cmake_args=''):
apt_depends('build-essential', 'cmake', 'git', 'libgtk2.0-dev', 'pkg-config', 'libavcodec-dev',
'libavformat-dev', 'libswscale-dev', 'python-dev', 'python-numpy', 'libtbb2',
'libtbb-dev', 'libjpeg-dev', 'libpng-dev', 'libtiff-dev', 'libjasper-dev', 'libdc1394-22-dev')
run("mkdir -p '$HOME/repos'", shell_escape=False)
with cd('$HOME/repos'):
clone_or_update(repo='opencv', team='opencv', branch=branch, skip_reset=True)
run('mkdir -p opencv-build')
with cd('opencv-build'):
run('cmake -D CMAKE_BUILD_TYPE=RELEASE '
'-D CMAKE_INSTALL_PREFIX=/usr/local {} ../opencv'.format(extra_cmake_args))
run('make')
sudo('make install')
def install_hookserve0(*args, **kwargs):
gz = "hookserve.gz"
base = gz.partition(path.extsep)[0]
if not exists("/usr/local/bin/{base}".format(base=base)):
apt_depends("ca-certificates", "curl")
run("mkdir -p Downloads")
run(
"curl -L https://phayes.github.io/bin/current/hookserve/linux/{gz} -o Downloads/{gz}".format(
gz=gz
)
)
sudo("zcat Downloads/{gz} > /usr/local/bin/{base}".format(gz=gz, base=base))
sudo("chmod +x /usr/local/bin/{base}".format(base=base))
def install_backend(database=True, database_uri=None):
if database:
if not exists('$HOME/.setup/postgresql'):
remote_user = run('printf $USER')
run('mkdir -p $HOME/.setup')
run('touch $HOME/.setup/postgresql')
install_postgres(dbs=('taiga', remote_user), users=(remote_user,))
elif not database_uri:
raise ValueError('Must create database or provide database_uri')
apt_depends('git')
with cd(run('printf $HOME')):
install_python_taiga_deps(clone_or_update(team='taigaio', repo='taiga-back'))
def install_deps0(*args, **kwargs):
if not cmd_avail("javac"):
sudo("add-apt-repository -y ppa:webupd8team/java")
sudo(
"echo debconf shared/accepted-oracle-license-v1-1 select true | \
sudo debconf-set-selections"
)
apt_depends("oracle-java8-set-default")
srcs_list = "/etc/apt/sources.list.d/gocd.list"
if not exists(srcs_list):
append(srcs_list, "deb https://download.gocd.org /", use_sudo=True)
sudo("curl https://download.gocd.org/GOCD-GPG-KEY.asc | sudo apt-key add -")
def ubuntu_actually_install_bosh(master, *args, **kwargs):
apt_depends(
"curl",
"build-essential",
"ruby",
"ruby-dev",
"libxml2-dev",
"libsqlite3-dev",
"libxslt1-dev",
"libpq-dev",
"libmysqlclient-dev",
)
sudo("gem install bosh_cli bosh_cli_plugin_micro --no-ri --no-rdoc")
"""sudo(
def push0(c, **kwargs):
apt_depends(c, "git")
clone_or_update(
c,
repo=kwargs["GIT_REPO"],
to_dir=kwargs["GIT_DIR"],
use_sudo=kwargs.get("use_sudo", False),
branch=kwargs.get("GIT_BRANCH", "master"),
skip_reset=kwargs.get("skip_reset", False),
skip_clean=kwargs.get("skip_clean", True),
reset_to_first=kwargs.get("GIT_RESET_TO_FIRST", False),
git_env=kwargs.get("GIT_ENV"),
)
def install_venv0(python3=False, venv=None, *args, **kwargs):
run_cmd = partial(_run_command, sudo=kwargs.get("use_sudo", False))
ensure_pip_version = lambda: kwargs.get("pip_version") and sudo(
"pip install pip ".format("== {}".format(kwargs[
"pip_version"] if "pip_version" in kwargs else "-U")))
venv_dir = kwargs.get("VENV_DIR", run("echo $HOME/venvs", quiet=True))
venv = venv or "{venv_dir}/{venv_name}".format(
venv_dir=venv_dir, venv_name=kwargs.get("VENV_NAME", "venv"))
if exists("{}/bin/python".format(venv)):
return
elif python3:
apt_depends("python3-dev", "python3-pip", "python3-wheel",
"python3-venv")
else:
apt_depends("python-dev", "python-pip", "python-wheel", "python2.7",
"python2.7-dev") # 'python-apt'
sudo("pip install virtualenv")
virtual_env_bin = "{venv}/bin".format(venv=venv)
if not exists(virtual_env_bin):
sudo('mkdir -p "{venv_dir}"'.format(venv_dir=venv_dir),
shell_escape=False)
if python3:
sudo('python3 -m venv "{venv}"'.format(venv=venv),
shell_escape=False)
else:
sudo('virtualenv "{venv}"'.format(venv=venv), shell_escape=False)
if not exists(virtual_env_bin):
raise ReferenceError("Virtualenv does not exist")
if not kwargs.get("use_sudo"):
user_group = run("echo $(id -un):$(id -gn)", quiet=True)
sudo("chown -R {user_group} {venv} $HOME/.cache".format(
user_group=user_group, venv=venv))
with shell_env(VIRTUAL_ENV=venv, PATH="{}/bin:$PATH".format(venv)):
ensure_pip_version()
run_cmd("pip install -U wheel setuptools")
return "Installed: {} {}".format(
run_cmd("pip --version; python --version"),
pip_depends(
"{}/bin/python".format(venv),
kwargs.get("use_sudo", False),
kwargs.get("PACKAGES", tuple()),
),
)
def install(*args, **kwargs):
version = '3.4.5'
apt_depends(Package(name='zookeeper', version=version),
Package(name='zookeeperd', version=version))
# /etc/zookeeper/conf/zoo.cfg
'''$ tree /etc/zookeeper/conf
├── configuration.xsl
├── environment
├── log4j.properties
├── myid
└── zoo.cfg'''
return 'zookeeper installed'
def install0(*args, **kwargs):
apt_depends("libpcre3", "libpcre3-dev")
# ^ Needed for uWSGI
# if not exists("/etc/systemd/system/circusd.service"):
use_sudo = kwargs.get("use_sudo", True)
remote_user = kwargs.get(
"SERVICE_USER", _run_command("echo $USER", quiet=True, sudo=use_sudo))
if remote_user.startswith("$"):
remote_user = _run_command(
"echo {remote_user}".format(remote_user=remote_user),
quiet=True,
sudo=use_sudo,
)
database_uri = kwargs.get("BACKEND_DATABASE_URI", kwargs["RDBMS_URI"])
if not isinstance(database_uri, str):
database_uri = "".join(map(str, database_uri))
name = kwargs["GIT_REPO"][kwargs["GIT_REPO"].rfind("/") + 1:].replace(
"-", "_")
env_vars = "\n{}".format("\n".join("{key}={val}".format(
key=key,
val="".join(map(str, val)) if isinstance(val, (list, tuple)) else val,
) for key, val in kwargs.get("BACKEND_ENV_VARS", {}).items()))
_install_backend(
backend_root=kwargs["BACKEND_ROOT"],
name=name,
remote_user=remote_user,
backend_virtual_env=kwargs["BACKEND_VIRTUAL_ENV"],
team=kwargs["GIT_TEAM"],
repo=kwargs["GIT_REPO"],
database_uri=database_uri,
env_vars="Environment='".join(env_vars),
)
_setup_circus(
home=_run_command("echo $HOME", quiet=True, sudo=use_sudo),
name=name,
remote_user=remote_user,
circus_virtual_env=kwargs.get("CIRCUS_VIRTUALENV",
"/opt/venvs/circus"),
backend_virtual_env=kwargs["BACKEND_VIRTUAL_ENV"],
database_uri=database_uri,
env_vars=env_vars,
backend_root=kwargs["BACKEND_ROOT"],
backend_logs_root=kwargs["BACKEND_LOGS_ROOT"],
port=int(kwargs.get("BACKEND_PORT", "8001")),
)
return restart_systemd("circusd")
def install_bazel(from_ppa=True):
if not from_ppa:
raise NotImplementedError()
elif cmd_avail("bazel"):
return
fname = "/etc/apt/sources.list.d/bazel.list"
sudo("touch {}".format(fname))
append(
filename=fname,
text=
"deb [arch=amd64] http://storage.googleapis.com/bazel-apt stable jdk1.8",
use_sudo=True,
)
sudo("curl https://bazel.build/bazel-release.pub.gpg | apt-key add -")
apt_depends("openjdk-8-jdk", "bazel")
def ubuntu_install_mesos(version="0.27.0", apt_update=True, *args, **kwargs):
apt_depends(
"openjdk-7-jdk",
"build-essential",
"python-dev",
"python-boto",
"curl",
"libcurl4-nss-dev",
"libsasl2-dev",
"maven"
"libapr1-dev",
"libsvn-dev",
)
run("curl -O http://www.apache.org/dist/mesos/{version}/mesos-{version}.tar.gz"
.format(version=version))
run("tar -zxf mesos-{version}.tar.gz".format(version=version))
def ubuntu_install_vb(extensions=False, distribution="trusty"):
apt_depends("curl")
asc = "oracle_vbox.asc"
run("curl -O https://www.virtualbox.org/download/{asc}".format(
asc=asc)) # TODO: verify cert also
sudo("apt-key add {asc}".format(asc=asc))
append(
"/etc/apt/sources.list",
"deb http://download.virtualbox.org/virtualbox/debian {distribution} contrib"
.format(distribution=distribution),
use_sudo=True,
)
apt_depends("virtualbox-5.0" "dkms")
if extensions:
raise NotImplementedError()
def ubuntu_install_vb(extensions=False, distribution='trusty'):
apt_depends('curl')
asc = 'oracle_vbox.asc'
run('curl -O https://www.virtualbox.org/download/{asc}'.format(asc=asc)) # TODO: verify cert also
sudo('apt-key add {asc}'.format(asc=asc))
append(
'/etc/apt/sources.list',
'deb http://download.virtualbox.org/virtualbox/debian {distribution} contrib'.format(
distribution=distribution
),
use_sudo=True
)
apt_depends('virtualbox-5.0' 'dkms')
if extensions:
raise NotImplementedError()
def install0(**kwargs):
installed = lambda: run(
"dpkg-query --showformat='${Version}' --show mongodb-org", quiet=True
)
def mongodb_apt_init():
if kwargs["VERSION"] == "3.4":
sudo(
"apt-key adv --keyserver hkp://keyserver.ubuntu.com:80 --recv 0C49F3730359A14518585931BC711F9BA15703C6"
)
sudo("rm /etc/apt/sources.list.d/mongodb-org*")
append(
"/etc/apt/sources.list.d/mongodb-org-3.4.list",
"deb [ arch=amd64,arm64 ] http://repo.mongodb.org/apt/ubuntu xenial/mongodb-org/3.4 multiverse",
use_sudo=True,
)
elif kwargs["VERSION"] == "3.6":
sudo(
"apt-key adv --keyserver hkp://keyserver.ubuntu.com:80 --recv 2930ADAE8CAF5059EE73BB4B58712A2291FA4AD5"
)
sudo("rm /etc/apt/sources.list.d/mongodb-org*")
append(
"/etc/apt/sources.list.d/mongodb-org-3.6.list",
"deb [ arch=amd64,arm64 ] https://repo.mongodb.org/apt/ubuntu xenial/mongodb-org/3.6 multiverse",
use_sudo=True,
)
else:
raise NotImplementedError(
"MongoDB version {}; update the package, or use '3.4' | '3.6'".format(
kwargs["VERSION"]
)
)
if sudo("dpkg -s mongodb-org", quiet=True, warn_only=True).failed:
mongodb_apt_init()
apt_depends("mongodb-org")
restart_systemd("mongod")
return "MongoDB {} installed".format(installed())
version = installed()
if not version.startswith(kwargs["VERSION"]):
mongodb_apt_init()
apt_depends("mongodb-org")
restart_systemd("mongod")
return "MongoDB {} installed".format(installed())
return "[Already] MongoDB {} installed".format(installed())
def install0(*args, **kwargs):
if len(is_installed("odoo")) == 0:
return "already installed odoo"
if not exists("/etc/apt/sources.list.d/odoo.list"):
sudo("wget -O - https://nightly.odoo.com/odoo.key | apt-key add -")
append(
"/etc/apt/sources.list.d/odoo.list",
"deb http://nightly.odoo.com/11.0/nightly/deb/ ./",
use_sudo=True,
)
apt_depends("postgresql", "odoo", "libldap2-dev", "libsasl2-dev")
sudo("pip3 install pip==9.0.3")
sudo("pip3 install vobject qrcode pyldap num2words")
return "installed odoo"
def cluster_with_pgpool2(conf_location, template_vars=None):
# conf_location should have pgpool.conf, relative to python package dir
apt_depends('pgpool2')
default_tpl_vars = {'PORT': '5433'}
if not template_vars:
template_vars = default_tpl_vars
else:
for k, v in default_tpl_vars.iteritems():
if k not in template_vars:
template_vars[k] = v
upload_template(conf_location, '/etc/pgpool2/pgpool.conf',
mode=640, context=template_vars, use_sudo=True)
sudo('chown root:postgres /etc/pgpool2/pgpool.conf')
upload_template(conf_location, '/usr/share/pgpool2/pgpool.conf',
mode=644, context=template_vars, use_sudo=True)
sudo('chown root:root /usr/share/pgpool2/pgpool.conf')
def install(local_conf_path, service_cmd='restart', name=None, template_vars=None):
apt_depends('nginx-full')
remote_conf_name = name or path.basename(local_conf_path).partition(path.extsep)[0]
remote_path = '/etc/nginx/sites-available/{remote_conf_name}'.format(remote_conf_name=remote_conf_name)
sudo('rm -f /etc/nginx/sites-enabled/{remote_conf_name}'.format(remote_conf_name=remote_conf_name))
sudo('rm -f /etc/nginx/sites-enabled/default')
sudo('rm -f /etc/nginx/sites-available/default')
if template_vars:
upload_template(local_conf_path, remote_path, context=template_vars, use_sudo=True)
else:
put(local_conf_path, remote_path=remote_path, use_sudo=True)
# put(default_conf_path, '/etc/nginx/sites-enabled/default', use_sudo=True)
sudo('ln -s /etc/nginx/sites-available/{remote_conf_name} /etc/nginx/sites-enabled/{remote_conf_name}'.format(
remote_conf_name=remote_conf_name
))
sudo('service nginx {service_cmd}'.format(service_cmd=service_cmd))
def install_frontend(skip_apt_update=False):
apt_depends('git')
remote_home = run('printf $HOME', quiet=True)
with cd(remote_home):
repo = 'taiga-front'
clone_or_update(team='taigaio', repo=repo)
# Compile it here if you prefer
if not exists('taiga-front/dist'):
clone_or_update(team='taigaio', repo='taiga-front-dist')
run('ln -s $HOME/taiga-front-dist/dist $HOME/taiga-front/dist')
js_conf_dir = '/'.join((repo, 'dist', 'js'))
if not exists('/'.join((js_conf_dir, 'conf.json'))):
run('mkdir -p {conf_dir}'.format(conf_dir=js_conf_dir))
put(taiga_dir('conf.json'), js_conf_dir)
run('mkdir -p $HOME/logs')
install_nginx(taiga_dir('taiga.nginx.conf'), name='taiga',
service_cmd='status', template_vars={'HOME': remote_home})
def set_hostname0(c, cache, *args, **kwargs):
"""
Set the hostname to original hostname sans everything following first `.`
:param c: Connection
:type c: ```fabric.connection.Connection```
:param cache: Cache dict var, persisted throughout all tasks, to share state
:type cache: ```dict```
:return: {"os_version": os_version}
:rtype: ```dict```
"""
apt_depends(c, "base-files")
hostname = c.run("hostname", hide=True)
first_dot = hostname.stdout.find(".")
if first_dot != -1:
apt_depends(c, "systemd")
c.sudo("hostnamectl set-hostname {}".format(hostname[:first_dot]))
return {"os_version": cache["os_version"]}
def install0(*args, **kwargs):
if run("dpkg -s matrix-synapse", quiet=True, warn_only=True).failed:
sudo("add-apt-repository https://matrix.org/packages/debian/")
sudo(
"wget -qO - https://matrix.org/packages/debian/repo-key.asc | sudo apt-key add -"
)
with shell_env(DEBIAN_FRONTEND="noninteractive"):
sudo(
"echo matrix-synapse matrix-synapse/server-name string {matrix_server_name} | debconf-set-selections".format(
matrix_server_name=kwargs["MATRIX_SERVER_NAME"]
)
)
sudo(
"echo matrix-synapse matrix-synapse/report-stats boolean {report_stats} | debconf-set-selections".format(
report_stats=("false", "true")[kwargs.get("REPORT_STATS", False)]
)
)
apt_depends("matrix-synapse")
sudo("systemctl enable matrix-synapse")
return "installed"
return "already installed"
def install(c):
"""
:param c: Connection
:type c: ```fabric.connection.Connection```
"""
if cmd_avail(c, "certbot"):
return "certbot already installed"
uname = c.run("uname -v").stdout
dist_version = float(c.run("lsb_release -rs", hide=True).stdout)
is_debian = "Debian" in uname
is_ubuntu = "Ubuntu" in uname
if is_debian or is_ubuntu:
apt_depends(
c,
"certbot",
"python{}-certbot-nginx".format(
"3" if is_ubuntu and dist_version >= 20.04
or is_debian and dist_version >= 10 else ""),
)
else:
raise NotImplementedError()
def install0(**kwargs):
installed = lambda: run(
'mysqld --version | while read _ _ ver _; do echo "$ver"; done',
quiet=True)
if sudo("dpkg -s mysql-server", quiet=True, warn_only=True).failed:
with shell_env(DEBIAN_FRONTEND="noninteractive"):
# TODO: Better password handling; I think this can get leaked, even with `quiet=True`?
sudo(
"""
debconf-set-selections <<< 'mysql-server mysql-server/root_password password {password}';
debconf-set-selections <<< 'mysql-server mysql-server/root_password_again password {password}';
""".format(password=kwargs["MYSQL_PASSWORD"]),
quiet=True,
)
apt_depends("mysql-server", "mysql-client", "libmysqlclient-dev")
sudo("systemctl unmask mysql")
restart_systemd("mysql")
return "MySQL {} installed".format(installed())
return "[Already] MySQL {} installed".format(installed())
def deploy_riot3(riot_version="0.16.5", root="/var/www/riot", *args, **kwargs):
if kwargs.get("clean_riot"):
sudo("rm -rf {root}".format(root=root))
elif exists("{root}/home.html".format(root=root)):
return "already deployed"
apt_depends("curl")
run("mkdir -p ~/Downloads")
sudo("mkdir -p {root}".format(root=root))
p = "riot-v{version}.tar.gz".format(version=riot_version)
run(
"curl -L https://github.com/vector-im/riot-web/releases/download/v{version}/{p} -o ~/Downloads/{p}".format(
version=riot_version, p=p
)
)
sudo(
"tar -C {root} -xzf ~/Downloads/{p} --strip-components=1".format(root=root, p=p)
)
return "deployed"
def _build_and_upload_deb(version):
sudo('apt-get update -qq')
sudo('apt-get upgrade -y')
sudo('apt-get dist-upgrade -y')
apt_depends('openjdk-7-jdk', 'build-essential', 'python-dev', 'python-boto', 'curl',
'libcurl4-nss-dev', 'libsasl2-dev', 'maven', 'libapr1-dev', 'libsvn-dev',
'git', 'autoconf')
install_ruby()
from offregister_fab_utils.apt import is_installed, Package
print '----------------------------------------------------------------------'
print "is_installed(Package('ruby', '2.3')) =", is_installed(Package('ruby', '2.3'))
apt_depends('software-properties-common')
sudo('apt-add-repository -y ppa:brightbox/ruby-ng')
apt_depends('ruby{version}'.format(version='2.3'), 'ruby{version}-dev'.format(version='2.3'))
print '----------------------------------------------------------------------'
clone_or_update(team='deric', repo='mesos-deb-packaging',
branch='master', skip_checkout=True, skip_reset=True)
pkg = 'mesos-{version}-gcc4.8-amd64.deb'.format(version=version)
with cd('mesos-deb-packaging'):
run('bash build_mesos --ref {version} --build-version p1'.format(version=version))
run('mv pkg.deb {pkg}'.format(pkg=pkg))
clone_or_update(team='offscale', repo='packages',
branch='master', skip_checkout=True, skip_reset=True)
with cd('packages'):
run('git add {pkg}'.format(pkg=pkg))
run('git commit -am "Built {pkg}"'.format(pkg=pkg))
run('git push -u origin master')
def ubuntu_install_dokku(domain, *args, **kwargs):
apt_depends('curl')
run('curl -sL https://get.docker.io/gpg 2> /dev/null | sudo apt-key add - 2>&1 >/dev/null')
run('curl -sL https://packagecloud.io/gpg.key 2> /dev/null | sudo apt-key add - 2>&1 >/dev/null')
sudo('echo "deb http://get.docker.io/ubuntu docker main" > /etc/apt/sources.list.d/docker.list')
sudo('echo "deb https://packagecloud.io/dokku/dokku/ubuntu/ trusty main" > /etc/apt/sources.list.d/dokku.list')
uname_r = run('uname -r')
apt_depends('linux-image-extra-{uname_r}'.format(uname_r=uname_r), 'apt-transport-https')
sudo('echo "dokku dokku/web_config boolean false" | debconf-set-selections')
sudo('echo "dokku dokku/vhost_enable boolean true" | debconf-set-selections')
sudo('echo "dokku dokku/hostname string {domain}" | debconf-set-selections'.format(domain=domain))
# TODO: Something better than this:
pub_key_path = '/root/.ssh/id_rsa.pub'
put(environ['PUBLIC_KEY_PATH'], pub_key_path, use_sudo=True, mode=0400)
sudo('echo "dokku dokku/key_file string {pub_key_path}" | debconf-set-selections'.format(pub_key_path=pub_key_path))
apt_depends('dokku')
'''
run('ssh-keygen -b 2048 -t dsa -f ~/.ssh/id_dsa -q -N ""')
run('wget https://raw.github.com/progrium/dokku/v0.3.18/bootstrap.sh')
run('sudo DOKKU_TAG=v0.3.18 bash bootstrap.sh')
'''
'''
run('curl --silent https://get.docker.io/gpg 2> /dev/null | apt-key add - 2>&1 >/dev/null')
run('curl --silent https://packagecloud.io/gpg.key 2> /dev/null | apt-key add - 2>&1 >/dev/null')
run('echo "deb http://get.docker.io/ubuntu docker main" | sudo tee -a /etc/apt/sources.list.d/docker.list')
run('echo "deb https://packagecloud.io/dokku/dokku/ubuntu/ trusty main" | sudo tee -a /etc/apt/sources.list.d/dokku.list')
'''
'''
def install_docker0(*args, **kwargs):
if cmd_avail("docker"):
return "Docker is already installed"
apt_depends(
"apt-transport-https",
"ca-certificates",
"curl",
"gnupg-agent",
"software-properties-common",
)
sudo(
"curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo apt-key add -"
)
sudo("apt-key fingerprint 0EBFCD88")
distro = run("lsb_release -cs")
sudo(
'add-apt-repository "deb [arch=amd64] https://download.docker.com/linux/ubuntu {distro} stable"'
.format(distro=distro))
apt_depends("docker-ce", "docker-ce-cli", "containerd.io")
sudo("systemctl enable docker")
return "Docker is now installed and will run at boot"
def install(version='9.3', username='******', dbs=None, users=None,
extra_deps=tuple(), cluster=False, cluster_conf=None):
apt_depends('postgresql-{version}'.format(version=version),
'postgresql-contrib-{version}'.format(version=version),
'postgresql-server-dev-{version}'.format(version=version),
*extra_deps)
postgres = partial(sudo, user=username)
def require_db(db):
if len(postgres("psql -tAc '\l {db}'".format(db=db))) == 0:
postgres('createdb {db}'.format(db=db))
def require_user(user):
if len(postgres("psql -tAc '\du {user}'".format(user=user))) == 0:
postgres('createuser --superuser {user}'.format(user=user))
if cluster:
if not cluster_conf:
raise ValueError('Cannot cluster without custom conf')
cluster_with_pgpool2(cluster_conf)
return {'dbs': map(require_db, dbs), 'users': map(require_user, users)}
def install_nodejs0(*args, **kwargs):
apt_depends("ca-certificates", "curl")
run("mkdir -p $HOME/Downloads")
if not exists("$HOME/n"):
remote_loc = "$HOME/Downloads/n-install"
run(
"curl -L https://git.io/n-install -o {remote_loc}".format(
remote_loc=remote_loc
)
)
run("bash {remote_loc}".format(remote_loc=remote_loc))
env.shell = "/bin/bash -l -i -c" # Damn, this is global. TODO: find an alternative
if run(
"""
curl -s https://nodejs.org/dist/latest/ \
| sed -n 's:.*<a href=\".*\">node-v\(.*\).pkg</a>.*:\\1:p' \
| grep -- "$(ls $HOME/n/n/versions/node)"
""",
warn_only=True,
).failed:
run("n latest")
run("npm install -g webpack")
def install_nginx0(c, *args, **kwargs):
"""
:param c: Connection
:type c: ```fabric.connection.Connection```
"""
if kwargs["cache"]["os_version"] == "debian":
apt_depends(
c,
"curl",
"gnupg2",
"ca-certificates",
"lsb-release",
"debian-archive-keyring",
)
c.sudo(
"curl https://nginx.org/keys/nginx_signing.key"
" | gpg --dearmor"
" | tee /usr/share/keyrings/nginx-archive-keyring.gpg",
hide=True,
)
c.run(
"gpg --dry-run --quiet --import --import-options import-show"
" /usr/share/keyrings/nginx-archive-keyring.gpg",
warn=True,
)
c.sudo(
'echo "deb [signed-by=/usr/share/keyrings/nginx-archive-keyring.gpg] http://nginx.org/packages/debian'
' `lsb_release -cs` nginx"'
" | tee /etc/apt/sources.list.d/nginx.list")
c.sudo(
'echo -e "Package: *\\nPin: origin nginx.org\\nPin: release o=nginx\\nPin-Priority: 900\\n"'
" | tee /etc/apt/preferences.d/99nginx")
else:
apt_depends(c, "curl", "gnupg2", "ca-certificates", "lsb-release",
"ubuntu-keyring")
c.sudo(
"curl https://nginx.org/keys/nginx_signing.key | gpg --dearmor"
" | tee /usr/share/keyrings/nginx-archive-keyring.gpg",
hide=True,
)
c.run(
"gpg --dry-run --quiet --import --import-options import-show"
" /usr/share/keyrings/nginx-archive-keyring.gpg",
warn=True,
)
c.sudo(
'echo "deb [signed-by=/usr/share/keyrings/nginx-archive-keyring.gpg]'
' http://nginx.org/packages/ubuntu `lsb_release -cs` nginx"'
" | tee /etc/apt/sources.list.d/nginx.list")
c.sudo(
'echo -e "Package: *\\nPin: origin nginx.org\\nPin: release o=nginx\\nPin-Priority: 900\n"'
" | tee /etc/apt/preferences.d/99nginx")
c.sudo("apt-get update -qq")
apt_depends(c, "nginx")
return "Installed nginx"
def install0(SERVER_NAME, *args, **kwargs):
apt_depends("curl", "openssh-server", "ca-certificates")
apt_depends("postfix")
external_url = "{protocol}://{server_name}".format(
protocol=kwargs.get("https") or "http", server_name=SERVER_NAME)
sudo(
"curl https://packages.gitlab.com/install/repositories/gitlab/gitlab-ee/script.deb.sh | bash"
)
with shell_env(EXTERNAL_URL=external_url):
apt_depends("gitlab-ee")
def ubuntu_install_dokku(domain, *args, **kwargs):
apt_depends("curl")
run(
"curl -sL https://get.docker.io/gpg 2> /dev/null | sudo apt-key add - 2>&1 >/dev/null"
)
run(
"curl -sL https://packagecloud.io/gpg.key 2> /dev/null | sudo apt-key add - 2>&1 >/dev/null"
)
sudo(
'echo "deb http://get.docker.io/ubuntu docker main" > /etc/apt/sources.list.d/docker.list'
)
sudo(
'echo "deb https://packagecloud.io/dokku/dokku/ubuntu/ trusty main" > /etc/apt/sources.list.d/dokku.list'
)
uname_r = run("uname -r")
apt_depends(
"linux-image-extra-{uname_r}".format(uname_r=uname_r), "apt-transport-https"
)
sudo('echo "dokku dokku/web_config boolean false" | debconf-set-selections')
sudo('echo "dokku dokku/vhost_enable boolean true" | debconf-set-selections')
sudo(
'echo "dokku dokku/hostname string {domain}" | debconf-set-selections'.format(
domain=domain
)
)
# TODO: Something better than this:
pub_key_path = "/root/.ssh/id_rsa.pub"
put(environ["PUBLIC_KEY_PATH"], pub_key_path, use_sudo=True, mode=0o400)
sudo(
'echo "dokku dokku/key_file string {pub_key_path}" | debconf-set-selections'.format(
pub_key_path=pub_key_path
)
)
apt_depends("dokku")
"""
run('ssh-keygen -b 2048 -t dsa -f ~/.ssh/id_dsa -q -N ""')
run('wget https://raw.github.com/progrium/dokku/v0.3.18/bootstrap.sh')
run('sudo DOKKU_TAG=v0.3.18 bash bootstrap.sh')
"""
"""
run('curl --silent https://get.docker.io/gpg 2> /dev/null | apt-key add - 2>&1 >/dev/null')
run('curl --silent https://packagecloud.io/gpg.key 2> /dev/null | apt-key add - 2>&1 >/dev/null')
run('echo "deb http://get.docker.io/ubuntu docker main" | sudo tee -a /etc/apt/sources.list.d/docker.list')
run('echo "deb https://packagecloud.io/dokku/dokku/ubuntu/ trusty main" | sudo tee -a /etc/apt/sources.list.d/dokku.list')
"""
"""
def install_deps():
# sudo('add-apt-repository ppa:mc3man/trusty-media')
apt_depends(
"curl",
# From Guacamole
"libcairo2-dev", # 'libjpeg62-turbo-dev', 'libjpeg62-dev',
"libpng12-dev",
"libossp-uuid-dev",
"libpango-1.0-0",
"libpango1.0-dev",
"libssh2-1",
"libssh2-1-dev",
"libpulse-dev",
"libssl-dev",
"libvorbis-dev",
"libwebp-dev",
"libfreerdp-dev", # 'ffmpeg'
"openjdk-8-jdk", # <- client
# From FreeRDP
"build-essential",
"git-core",
"cmake",
"xsltproc",
"libssl-dev",
"libx11-dev",
"libxext-dev",
"libxinerama-dev",
"libxcursor-dev",
"libxdamage-dev",
"libxv-dev",
"libxkbfile-dev",
"libasound2-dev",
"libcups2-dev",
"libxml2",
"libxml2-dev",
"libxrandr-dev",
"libgstreamer0.10-dev",
"libgstreamer-plugins-base0.10-dev",
"libxi-dev",
"libgstreamer-plugins-base1.0-dev",
"libavutil-dev",
"libavcodec-dev",
"libdirectfb-dev",
# From libtelnet
"autoconf",
"libtool",
"automake",
# From ffmpeg
"yasm",
)
sudo(
"update-alternatives --install /usr/bin/java java /usr/lib/jvm/java-8-openjdk-amd64/jre/bin/java 1"
)
sudo(
"update-alternatives --install /usr/bin/javac javac /usr/lib/jvm/java-8-openjdk-amd64/bin/javac 1"
)
sudo("mkdir -p ~/Downloads")
curr_ug = run("echo -n $USER:$GROUP", quiet=True)
sudo("chown -R {curr_ug} ~/Downloads".format(curr_ug=curr_ug))
with cd("Downloads"):
libjpeg = "libjpeg-turbo-official_1.5.2_amd64.deb"
if not exists(libjpeg):
run("curl -L 'https://downloads.sourceforge.net/project/libjpeg-turbo/{ver}/{pkg}' -o '{pkg}'"
.format(pkg=libjpeg,
ver=libjpeg.rpartition("_")[0].partition("_")[2]))
sudo("dpkg -i {pkg}".format(pkg=libjpeg))
zlib = "zlib-1.2.11"
if not exists(zlib):
run("curl -OL http://www.zlib.net/{pkg}.tar.gz".format(pkg=zlib))
run("tar xf {pkg}.tar.gz".format(pkg=zlib))
with cd(zlib):
run("./configure")
run("make")
sudo("make install")
libvnc = "LibVNCServer-0.9.11"
if not exists("{pkg}.tar.gz".format(pkg=libvnc)):
run("curl -OL https://github.com/LibVNC/libvncserver/archive/{pkg}.tar.gz"
.format(pkg=libvnc))
run("tar xf {pkg}.tar.gz".format(pkg=libvnc))
with cd("libvncserver-{pkg}".format(pkg=libvnc)):
run("mkdir build")
with cd("build"):
run("cmake ..")
run("cmake --build .")
sudo("make install")
"""freerdp = '2.0.0-rc0'
run('curl -OL https://github.com/FreeRDP/FreeRDP/archive/{pkg}.tar.gz'.format(pkg=freerdp))
run('tar xf {pkg}.tar.gz'.format(pkg=freerdp))
with cd('FreeRDP-{pkg}'.format(pkg=freerdp)):
run('rm -rf build')
run('mkdir build')
with cd('build'):
run('cmake -DCMAKE_BUILD_TYPE=Debug -DWITH_SSE2=ON ..')
run('make')
sudo('make install')
sudo('mkdir -p /etc/ld.so.conf.d')
append('/etc/ld.so.conf.d/freerdp.conf', '/usr/local/lib/freerdp', use_sudo=True)
sudo('ldconfig')"""
libtelnet = "libtelnet-master"
if not exists(libtelnet):
run("curl -L https://github.com/seanmiddleditch/libtelnet/archive/master.tar.gz -o {pkg}.tar.gz"
.format(pkg=libtelnet))
run("tar xf {pkg}.tar.gz".format(pkg=libtelnet))
with cd(libtelnet):
run("autoreconf -fi")
run('zlib_CFLAGS="-DHAVE_ZLIB=1" zlib_LIBS="-lz" ./configure --disable-util'
)
run("make")
sudo("make install")
sudo("ldconfig")
if not cmd_avail("ffmpeg"):
ffmpeg = "ffmpeg-3.3.4"
run("curl -OL http://ffmpeg.org/releases/{pkg}.tar.bz2".format(
pkg=ffmpeg))
run("tar xf {pkg}.tar.bz2".format(pkg=ffmpeg))
with cd(ffmpeg):
run("./configure")
run("make")
sudo("make install")
CATALINA_HOME = "/opt/javalibs/tomcat9"
if not exists(CATALINA_HOME):
sudo(
"mkdir -p {CATALINA_HOME}".format(CATALINA_HOME=CATALINA_HOME))
append(
"/etc/environment",
"export CATALINA_HOME='{CATALINA_HOME}'".format(
CATALINA_HOME=CATALINA_HOME),
use_sudo=True,
)
tomcat = "apache-tomcat-9.0.1"
tomcat_ver = tomcat.rpartition("-")[2]
run("curl -OL http://mirror.intergrid.com.au/apache/tomcat/tomcat-{ver[0]}/v{ver}/bin/{pkg}.tar.gz"
.format(pkg=tomcat, ver=tomcat_ver))
sudo("tar xf {pkg}.tar.gz -C {CATALINA_HOME} --strip-components=1".
format(pkg=tomcat, CATALINA_HOME=CATALINA_HOME))
return "installed dependencies"
def ubuntu_install_tsuru(*args, **kwargs):
apt_depends('curl')
run('curl -sL https://raw.githubusercontent.com/tsuru/now/master/run.bash | bash')
def ubuntu_install_mesos(version='0.27.0', apt_update=True, *args, **kwargs):
apt_depends('openjdk-7-jdk', 'build-essential', 'python-dev', 'python-boto', 'curl',
'libcurl4-nss-dev', 'libsasl2-dev', 'maven' 'libapr1-dev', 'libsvn-dev')
run('curl -O http://www.apache.org/dist/mesos/{version}/mesos-{version}.tar.gz'.format(version=version))
run('tar -zxf mesos-{version}.tar.gz'.format(version=version))
def ubuntu_actually_install_bosh(master, *args, **kwargs):
apt_depends('curl', 'build-essential', 'ruby', 'ruby-dev', 'libxml2-dev',
'libsqlite3-dev', 'libxslt1-dev', 'libpq-dev', 'libmysqlclient-dev')
sudo('gem install bosh_cli bosh_cli_plugin_micro --no-ri --no-rdoc')
'''sudo(
def step0(domain, *args, **kwargs):
key_file = '/root/.ssh/id_rsa.pub'
config = {
'DOKKU_HOSTNAME': ('hostname', domain),
'DOKKU_KEY_FILE': ('key_file', key_file),
'DOKKU_SKIP_KEY_FILE': ('skip_key_file', False),
'DOKKU_VHOST_ENABLE': ('vhost_enable', False),
'DOKKU_WEB_CONFIG': ('web_config', False)
}
create_static = kwargs.get('create_static_page', True)
static_git_url = kwargs.get('static_git', environ.get('DOKKU_STATIC_GIT', environ.get('STATIC_GIT')))
local_pubkey = kwargs.get('PUBLIC_KEY_PATH') or environ.get('DOKKU_PUBLIC_KEY_PATH', environ['PUBLIC_KEY_PATH'])
if not cmd_avail('docker'):
docker.install_0()
# docker.dockeruser_1()
docker.serve_2()
put(StringIO('pZPlHOkV649DCepEwf9G'), '/tmp/passwd')
if not cmd_avail('dokku'): # is_installed('dokku'):
run('wget -qN https://packagecloud.io/gpg.key')
sudo('apt-key add gpg.key')
append('/etc/apt/sources.list.d/dokku.list',
'deb https://packagecloud.io/dokku/dokku/ubuntu/ trusty main', use_sudo=True)
put(StringIO('\n'.join('{com} {com}/{var} {type} {val}'.format(
com='dokku', var=v[0], val=str(v[1]).lower() if type(v[1]) is BooleanType else v[1], type=(
lambda t: {type(True): 'boolean', type(''): 'string', type(unicode): 'string'}.get(t, t))(type(v[1])))
for k, v in config.iteritems() if v[1] is not None)
),
'/tmp/dokku-debconf')
sudo('debconf-set-selections /tmp/dokku-debconf')
if not exists(key_file):
sudo('ssh-keygen -t rsa -b 4096 -f {key_file} -N ""'.format(key_file=key_file))
apt_depends('dokku')
sudo('dokku plugin:install-dependencies --core')
put(local_pubkey, key_file)
sudo('sshcommand acl-add dokku domain {key_file}'.format(key_file=key_file))
return 'installed dokku'
if create_static:
if run('getent passwd static', quiet=True, warn_only=True).failed:
sudo('adduser static --disabled-password')
sudo('mkdir /home/static/sites/', user='******')
upload_template(
path.join(path.dirname(resource_filename('offregister_dokku', '__init__.py')), 'data', 'static_sites.conf'),
'/etc/nginx/conf.d/static_sites.conf', use_sudo=True
)
if sudo('service nginx status').endswith('stop/waiting'):
sudo('service nginx start')
else:
sudo('service nginx reload')
# TODO: Abstract this out into a different module, and allow for multiple domains
if static_git_url:
ipv4 = '/home/static/sites/{public_ipv4}'.format(public_ipv4=kwargs['public_ipv4'])
if exists(ipv4):
sudo('rm -rf {ipv4}'.format(ipv4=ipv4))
sudo('mkdir -p {ipv4}'.format(ipv4=ipv4), user='******')
if domain:
domain = '/home/static/sites/{domain}'.format(domain=domain)
if not exists(domain):
sudo('ln -s {ipv4} {domain}'.format(ipv4=ipv4, domain=domain), user='******')
xip = '{ipv4}.xip.io'.format(ipv4=ipv4)
if not exists(xip):
sudo('ln -s {ipv4} {xip}'.format(ipv4=ipv4, xip=xip), user='******')
if static_git_url:
apt_depends('git')
if isinstance(static_git_url, basestring):
clone_or_update(**url_to_git_dict(static_git_url))
else:
clone_or_update(to_dir=ipv4, **static_git_url)
return 'installed dokku [already]'
def install_bosh_lite():
apt_depends('git')
