642 lines
17 KiB
Python
642 lines
17 KiB
Python
import os
|
|
import sys
|
|
import errno
|
|
import logging
|
|
|
|
import fabric.contrib.files
|
|
|
|
from contextlib import contextmanager as _contextmanager
|
|
from fabric.api import env, prefix, local
|
|
from fabric.operations import run, sudo
|
|
|
|
|
|
def printvar(name, value, exit=False):
|
|
"""
|
|
debug helper method to print a variable from within a process
|
|
|
|
:parameter name: name of the variable we are printing out
|
|
:type name: str
|
|
|
|
:parameter value: the value of the variable we want to print
|
|
:type value: str
|
|
|
|
:parameter exit: determines whether or not we exit the program at
|
|
this point. defaults to false
|
|
:type exit: bool
|
|
"""
|
|
print("%s : %s" % (name, value))
|
|
if exit:
|
|
sys.exit()
|
|
|
|
|
|
def printerr(message="", errcode=-2, exit=True):
|
|
"""
|
|
debug helper method thats prints error message and error code then exits
|
|
|
|
:parameter message: the error message we want to print out.
|
|
defaults to empty string.
|
|
:type message: str
|
|
|
|
:parameter errcode: the code of the error
|
|
:type errcode: int
|
|
|
|
:parameter exit: determines whether or not we exit the program at
|
|
this point. defaults to True
|
|
:type exit: bool
|
|
"""
|
|
|
|
message = "Error\n\t{message}\n\tExiting with code: {errcode}\n".format(
|
|
message=message, errcode=errcode)
|
|
|
|
print
|
|
print(message)
|
|
print
|
|
sys.exit(errcode)
|
|
|
|
|
|
def loggify(module, func, prefix=""):
|
|
"""
|
|
I'm tired of rewriting this logging code in every single function, so I
|
|
decided to just dump it here, and return a logger that can be used and
|
|
thrown away when it's done
|
|
|
|
:parameter module: name of the module being used, ie 'nginx', 'deploy', etc
|
|
:type module: str
|
|
|
|
:parameter func: the name of the function this logger is going to be used
|
|
in
|
|
:type func: str
|
|
|
|
:parameter prefix: anything you want to add to the front of the logger,
|
|
ie \'\\n\'. defaults to an empty string.
|
|
:type prefix: str
|
|
|
|
:return: a logging object
|
|
:rtype: object
|
|
"""
|
|
|
|
loggername = '{module}.{func}'.format(
|
|
module=module, func=func)
|
|
|
|
str_logging = '{prefix}%(levelname)s: {loggername} %(message)s'.format(
|
|
prefix=prefix,
|
|
loggername=loggername)
|
|
|
|
logging.basicConfig(
|
|
format=str_logging,
|
|
level=logging.DEBUG)
|
|
|
|
return logging.getLogger(loggername)
|
|
|
|
|
|
def print_console(string, prepend="\n\n", append="\n\n", sep="-", numsep=44,
|
|
exit_program=False, exit_code=0):
|
|
"""
|
|
helper function to take a string, and format it so it prints to the console
|
|
in a way that is pleasing to the eye.
|
|
|
|
:parameter string: the string to be printed
|
|
:type string: str
|
|
|
|
:parameter prepend: defaults to two line spaces, can be anything
|
|
:type string: str
|
|
|
|
:parameter append: defaults to two lines spaces after the string is printed
|
|
:type append: str
|
|
|
|
:parameter sep: the character used to print out one line above the string
|
|
and one line after
|
|
:type sep: str
|
|
|
|
:parameter numsep: number of times the separator is printed out on a line
|
|
:type numsep: int
|
|
|
|
:parameter exit_program: whether to exit the program after printing the
|
|
message. defaults to False
|
|
:type exit_program: bool
|
|
|
|
:parameter exit_code: what exit code to use if we exit the program after
|
|
printing the message. defaults to 0
|
|
:type exit_code: int
|
|
"""
|
|
|
|
print(prepend)
|
|
|
|
if sep:
|
|
print(sep * numsep)
|
|
|
|
print(string)
|
|
|
|
if sep:
|
|
print(sep * numsep)
|
|
|
|
print(append)
|
|
|
|
if exit_program:
|
|
import sys
|
|
sys.exit(exit_code)
|
|
|
|
|
|
def print_debug(debugstr, module, function):
|
|
"""
|
|
debug helper method to print out a debug string, the name of the module,
|
|
and the function it is located in.
|
|
|
|
The message will be printed out in the form <debugstr>:<module>:<function>
|
|
|
|
:parameter debugstr: the debugging message we want to print
|
|
:type debugstr: str
|
|
|
|
:parameter module: the name of the module we are in
|
|
:type module: str
|
|
|
|
:parameter function: the name of the function we are in
|
|
:type function:
|
|
"""
|
|
|
|
print("%s:%s:%s" % (module, function, debugstr))
|
|
|
|
|
|
def executize(config_execute='local'):
|
|
"""
|
|
creates an executor to run commands. returns one of the following methods
|
|
fabric.api.local, fabric.operations.run or fabric.operations.sudo
|
|
|
|
:parameter config_execute: values can be either 'sudo', 'run', or 'local'.
|
|
defaults to 'local'.
|
|
:type config_execute: str
|
|
|
|
:return: the fabric command corresponding to the string value
|
|
in config_execute, either a sudo, a run or a local executor
|
|
"""
|
|
|
|
if config_execute == 'sudo':
|
|
_execute = sudo
|
|
elif config_execute == 'run':
|
|
_execute = run
|
|
elif config_execute == 'local':
|
|
_execute = local
|
|
else:
|
|
errmsg = "did not enter a correct value of 'sudo', 'run' or" \
|
|
" 'local' to executize.\nExiting."
|
|
printerr(message=errmsg, errcode=-2)
|
|
|
|
return _execute
|
|
|
|
|
|
def booleanize(value):
|
|
"""
|
|
take the argument and return it as either True or False
|
|
|
|
if the argument is neither, throw a TypeError explaining that the value
|
|
given cannot be booleanized
|
|
|
|
:parameter value: takes values of y, n, yes, no, true, false,
|
|
1 or 0
|
|
:type value: str
|
|
|
|
:return: converts value to True or False. Note 1 is
|
|
considered True and 0 is False
|
|
:rtype: bool
|
|
"""
|
|
|
|
true_values = ("y", "yes", "true", "1")
|
|
false_values = ("n", "no", "false", "0")
|
|
|
|
if isinstance(value, bool):
|
|
return value
|
|
|
|
if value.lower() in true_values:
|
|
return True
|
|
|
|
elif value.lower() in false_values:
|
|
return False
|
|
|
|
raise TypeError("Cannot booleanize ambiguous value '%s'" % value)
|
|
|
|
|
|
def ensure_dir(dirpath):
|
|
"""
|
|
Create a directory if it does not exists.
|
|
|
|
Raises an OSError if there is a problem
|
|
|
|
:parameter dirpath: directory path
|
|
:type dirpath: str
|
|
|
|
"""
|
|
try:
|
|
if not os.path.exists(dirpath):
|
|
print("creating directory: %s" % dirpath)
|
|
os.makedirs(dirpath)
|
|
|
|
except OSError as e:
|
|
if e.errno != errno.EEXIST:
|
|
print("Error occurred while creating directory: %s"
|
|
% dirpath)
|
|
raise
|
|
|
|
|
|
def ensure_file(filepath):
|
|
"""
|
|
Simulates linux 'touch' command
|
|
|
|
:parameter filepath: name of the file we want to create. Note this
|
|
must include the full path and filename
|
|
:type filepath: str
|
|
"""
|
|
if not os.path.exists(filepath):
|
|
open(filepath, 'w').close()
|
|
|
|
|
|
def upload_template(filename, destination, context, use_jinja,
|
|
use_sudo, backup, template_dir, debug=False):
|
|
"""
|
|
helper wrapper method to upload a template
|
|
|
|
it wraps around fabric.contrib.files.upload_template method.
|
|
See https://docs.fabfile.org/en/1.11/api/contrib/files.html
|
|
|
|
:parameter filename: the full path to the filename if we are not
|
|
using jinja, otherwise using template_dir and just the filename
|
|
this file will be interpolated using the given context and
|
|
uploaded to the remote host
|
|
:type filename: str
|
|
|
|
:parameter destination: remote file path to place the file
|
|
(includes filename)
|
|
:type destination: str
|
|
|
|
:parameter context: variable context
|
|
:type context: dict
|
|
|
|
:parameter use_jinja: whether we are using jinja template system or not.
|
|
Templates will be loaded from the invoking users' current working
|
|
directory or by template_dir
|
|
:type use_jinja: bool
|
|
|
|
:parameter use_sudo: whether we are using sudo to place the file.
|
|
By default the file will be copied as the logged in user
|
|
:type use_sudo: bool
|
|
|
|
:parameter backup: if the destination file already exists, create a backup
|
|
of it with the extension .bak
|
|
:type backup: bool
|
|
|
|
:parameter template_dir: path to the template directory that is used if
|
|
jinja is true. directory where the file is located
|
|
:type template_dir: str
|
|
|
|
:parameter debug: if true, just print out the command we are using to
|
|
invoke the fabric upload_template method. defaults to False
|
|
:type debug: bool
|
|
"""
|
|
|
|
if env.debug:
|
|
logging.basicConfig(
|
|
format='\n%(levelname)s: utils.upload_template %(message)s',
|
|
level=logging.DEBUG)
|
|
|
|
command_msg = "\n\tupload_template(" \
|
|
"\n\tfilename={filename}," \
|
|
"\n\tdestination={destination_available}," \
|
|
"\n\tcontext={context}," \
|
|
"\n\tuse_jinja={use_jinja}," \
|
|
"\n\tuse_sudo={use_sudo}," \
|
|
"\n\tbackup={backup}," \
|
|
"\n\ttemplate_dir={template_dir})\n".format(
|
|
filename=filename,
|
|
destination_available=destination,
|
|
context=context,
|
|
use_jinja=use_jinja,
|
|
use_sudo=use_sudo,
|
|
backup=backup,
|
|
template_dir=template_dir)
|
|
|
|
if debug:
|
|
return command_msg
|
|
|
|
else:
|
|
|
|
fabric.contrib.files.upload_template(
|
|
filename=filename,
|
|
destination=destination,
|
|
context=context,
|
|
use_jinja=use_jinja,
|
|
use_sudo=use_sudo,
|
|
backup=backup,
|
|
template_dir=template_dir)
|
|
|
|
|
|
def get_upload_template_msg(filename, destination, context, use_jinja,
|
|
use_sudo, backup, template_dir, debug=False):
|
|
|
|
command_msg = "\n\tupload_template(" \
|
|
"\n\tfilename={filename}," \
|
|
"\n\tdestination={destination_available}," \
|
|
"\n\tcontext={context}," \
|
|
"\n\tuse_jinja={use_jinja}," \
|
|
"\n\tuse_sudo={use_sudo}," \
|
|
"\n\tbackup={backup}," \
|
|
"\n\ttemplate_dir={template_dir})\n".format(
|
|
filename=filename,
|
|
destination_available=destination,
|
|
context=context,
|
|
use_jinja=use_jinja,
|
|
use_sudo=use_sudo,
|
|
backup=backup,
|
|
template_dir=template_dir)
|
|
|
|
return command_msg
|
|
|
|
|
|
@_contextmanager
|
|
def virtualenv_source():
|
|
"""
|
|
helper method that sources the virtualenvwrapper for all following commands
|
|
|
|
uses python yield command
|
|
"""
|
|
configuration = env.config
|
|
venv_bin = configuration.virtualenv.bin
|
|
|
|
if venv_bin:
|
|
venv_activate = f"source {venv_bin}/virtualenvwrapper.sh"
|
|
else:
|
|
venv_activate = "source virtualenvwrapper.sh"
|
|
|
|
with prefix(venv_activate):
|
|
yield
|
|
|
|
|
|
@_contextmanager
|
|
def virtualenv():
|
|
"""
|
|
Context manager for setting the virtual environment for commands.
|
|
|
|
This helper method sets up the virtual environment specified in the
|
|
configuration before executing any commands within its context. It uses
|
|
the Python context manager pattern with the `yield` keyword to
|
|
temporarily modify the environment for the duration of the with-block.
|
|
The virtual environment is specified by the name in
|
|
`configuration.virtualenv.name` and is activated using the `workon`
|
|
command.
|
|
|
|
Note:
|
|
- This method relies on the Fabric library's `prefix` context manager
|
|
and assumes the use of virtualenvwrapper or a similar tool for
|
|
managing virtual environments.
|
|
- The method expects `configuration.virtualenv.name` to be properly
|
|
set in `env.config`.
|
|
|
|
Example Usage:
|
|
with virtualenv():
|
|
run("python manage.py migrate")
|
|
"""
|
|
|
|
configuration = env.config
|
|
with virtualenv_source():
|
|
with prefix("workon %s" % configuration.virtualenv.name):
|
|
yield
|
|
|
|
# with prefix("/bin/bash -c -l 'source %s'" %
|
|
# configuration.virtualenv.activate):
|
|
# yield
|
|
|
|
# with prefix("/bin/bash -c -l 'source /usr/local/bin/' \
|
|
# 'virtualenvwrapper.sh ' \
|
|
# '&& workon %s'" % configuration.virtualenv.name):
|
|
# yield
|
|
|
|
|
|
def generate_template_build_path(section, template_name='conf'):
|
|
"""
|
|
helper function to automate creation of build path
|
|
|
|
:parameter section: the template section we are building off of
|
|
:type section: str
|
|
|
|
:parameter template_name: by default this is "conf", but can be
|
|
different, for example, the 'database' section has 3 different
|
|
template names
|
|
:type template_name: str
|
|
|
|
:return: a path to where the template should be placed
|
|
"""
|
|
import os
|
|
|
|
configuration = env.config
|
|
|
|
conf_section = getattr(configuration.templates, section)
|
|
|
|
conf_section_templatename = getattr(conf_section, template_name)
|
|
|
|
build_path = os.path.join(
|
|
conf_section.path.remote,
|
|
'build',
|
|
conf_section_templatename.dst)
|
|
|
|
return build_path
|
|
|
|
|
|
def generate_template_files_path(section):
|
|
"""
|
|
helper function to automate creation of build path
|
|
|
|
:parameter section: the template section we are building off of
|
|
:type section: str
|
|
|
|
:return: a path to where the template jinja file is located
|
|
:rtype: str
|
|
"""
|
|
import os
|
|
|
|
configuration = env.config
|
|
|
|
conf_section = getattr(configuration.templates, section)
|
|
|
|
files_path = os.path.join(
|
|
conf_section.path.local,
|
|
'files')
|
|
|
|
return files_path
|
|
|
|
|
|
def print_run(command, prefix="\"\n\t", suffix="\n\t\""):
|
|
"""
|
|
helper function to print out what a command will actually look like when
|
|
run
|
|
|
|
:parameter command: a typical bash command that I want to run
|
|
:type command: str
|
|
|
|
:parameter prefix: prefix that is added to the string, typically done
|
|
for clarity of viewing
|
|
:type prefix: str
|
|
|
|
:parameter suffix: suffix that is added to the string, typically done
|
|
for clarity of viewing
|
|
:type suffix: str
|
|
|
|
:returns: an example of how the command will actually look if run
|
|
on the command line
|
|
:rtype: str
|
|
"""
|
|
|
|
return "run ({prefix}{command}{suffix})".format(
|
|
prefix=prefix,
|
|
suffix=suffix,
|
|
command=command)
|
|
|
|
|
|
def handle_flag_message(param, message, values=['-h', '--help']):
|
|
"""
|
|
if a given parameter is in the given values
|
|
then return the given message
|
|
|
|
:parameter param: checks if the given parameter is in
|
|
the values.
|
|
:type param: str
|
|
|
|
:parameter message: the message to print out if true
|
|
:type message: str
|
|
|
|
:parameter values: the values we are checking to see.
|
|
by default this is ['-h', '--help']
|
|
:type values: list
|
|
|
|
:return: whether the given param is in values
|
|
:rtype: bool
|
|
"""
|
|
|
|
if isinstance(param, str):
|
|
if param.lower() in values:
|
|
print(message)
|
|
return True
|
|
|
|
return False
|
|
|
|
|
|
def is_help(key):
|
|
"""
|
|
helper method to determine if the given key is a help key
|
|
|
|
:parameter key: the key we are checking
|
|
:type key: str
|
|
|
|
:return: if key is in -h or --help
|
|
:rtype: bool
|
|
"""
|
|
help_keys = ['-h', '--help']
|
|
|
|
return key in help_keys
|
|
|
|
|
|
def link_create(path_src, path_dst, debug=False):
|
|
"""
|
|
takes a source and destination path, then links it
|
|
if the destination path already exists and is a link,
|
|
then delete it.
|
|
|
|
Otherwise sys.exit with an error message.
|
|
|
|
:parameter path_src: source path
|
|
:type path_src: str
|
|
|
|
:paramter path_dst: destination path
|
|
:type path_dst: str
|
|
|
|
:parameter debug: whether we do nothing and just return a message
|
|
:type debug: bool
|
|
|
|
:return: if debug=True then it returns a msg
|
|
"""
|
|
|
|
from fabric.contrib.files import is_link
|
|
from fabric.contrib.files import exists
|
|
from fabric.operations import run
|
|
|
|
cmd_rm = "rm {path_dst}".format(
|
|
path_dst=path_dst
|
|
)
|
|
|
|
cmd_link = "ln -sf {path_src} {path_dst}".format(
|
|
path_src=path_src,
|
|
path_dst=path_dst
|
|
)
|
|
|
|
msg_debug = ""
|
|
|
|
if exists(path_dst):
|
|
if is_link(path_dst):
|
|
if debug:
|
|
msg_debug += "link already exists at dst, removing\n" \
|
|
"link_create:cmd_rm : %s" % cmd_rm
|
|
else:
|
|
run(cmd_rm)
|
|
else:
|
|
msg_error = "something exists at dst - '%s' " \
|
|
"- and it's not a link\n kicking out"
|
|
|
|
sys.exit(msg_error.format(path_dst))
|
|
|
|
if debug:
|
|
msg_debug += "link_create:cmd_link : %s" % cmd_link
|
|
else:
|
|
run(cmd_link)
|
|
|
|
return msg_debug
|
|
|
|
|
|
def prompt_continue(message="Do you want to continue? Y/n", default="Y",
|
|
exit=True):
|
|
"""
|
|
prompts user if he wants to continue
|
|
|
|
:parameter message: ask if user wants to continue
|
|
:type message: str
|
|
|
|
:parameter default: the default entry that we expect for the user if he
|
|
hits <enter> enter without giving a value
|
|
:type default: str
|
|
|
|
:parameter exit: whether we do a sys.exit if it fails. default True
|
|
:type exit: bool
|
|
"""
|
|
|
|
from fabric.operations import prompt
|
|
|
|
prompt_val = prompt(message)
|
|
|
|
if prompt_val == "":
|
|
prompt_val = default
|
|
|
|
if env.debug:
|
|
printvar(
|
|
"prompt_val", prompt_val,
|
|
not booleanize(prompt_val))
|
|
return True
|
|
else:
|
|
if not booleanize(prompt_val):
|
|
if exit:
|
|
sys.exit()
|
|
else:
|
|
return False
|
|
|
|
|
|
def check_debug(env):
|
|
"""
|
|
helper method to determine if debug was set to True in the fabric
|
|
environment
|
|
|
|
:parameter env: the fabric environment
|
|
:type env: dict
|
|
|
|
:return: True if debug was set
|
|
:rtype: bool
|
|
"""
|
|
|
|
if hasattr(env, 'debug'):
|
|
return env.debug
|
|
else:
|
|
return False
|