244 lines
6.6 KiB
Python
244 lines
6.6 KiB
Python
from fabric.api import env, task, lcd
|
|
from fabric.api import local
|
|
import os
|
|
import sys
|
|
|
|
from .utils import executize, virtualenv, loggify
|
|
|
|
|
|
def command(program=None, cmd=None, extra_param=None):
|
|
"""
|
|
takes an argument and executes that command for nginx
|
|
|
|
program - name of program to be run, eg. 'nginx', 'supervisor'
|
|
cmd - can be 'start', 'stop' or 'status'
|
|
|
|
will then run the appropriate series of commands to get the job done based
|
|
on what we have in the configuration file
|
|
"""
|
|
|
|
configuration = env.config
|
|
# logger = loggify('maintenance', 'command')
|
|
|
|
if program is None:
|
|
print("Error: You have not given a legitimate program")
|
|
|
|
print("permissable programs : %s" %
|
|
configuration.maintenance.keys())
|
|
|
|
sys.exit()
|
|
|
|
configuration_program = getattr(configuration.maintenance, program)
|
|
|
|
# debugging
|
|
# print("configuration_program: %s" %
|
|
# configuration_program.commands.keys())
|
|
|
|
if cmd is None:
|
|
print("Error: You have not given a legitimate command")
|
|
print("permissable commands : %s" %
|
|
configuration_program.commands.keys())
|
|
|
|
sys.exit()
|
|
|
|
# find out whether we are using sudo, run or local to
|
|
# execute the nginx command
|
|
|
|
_execute = executize(configuration_program.execute)
|
|
|
|
_command = getattr(configuration_program.commands, cmd)
|
|
|
|
# debugging
|
|
# print("_command: %s" % _command)
|
|
|
|
if extra_param is not None:
|
|
_command = "{command} {param}".format(
|
|
command=_command, param=extra_param)
|
|
|
|
if env.debug:
|
|
# logger.debug(
|
|
# "execute type : %s" % configuration_program.execute)
|
|
|
|
# logger.debug(
|
|
# "%s command : %s" % (program, _command))
|
|
|
|
# logger.debug("extra_param : %s" % extra_param)
|
|
|
|
# logger.debug("%s modified command : %s" % (program, _command))
|
|
pass
|
|
|
|
else:
|
|
_execute(_command)
|
|
|
|
|
|
def edit(remote_path, host_string=None):
|
|
"""
|
|
calls up mvim or vim on the file
|
|
|
|
remote_path - path to file we want to edit
|
|
host_string - what machine the file is located on
|
|
|
|
host_string is necessary b/c in the case where I want to edit
|
|
configuration files, it is essential to do so only on the localhost
|
|
|
|
that is, whether I'm editing staging, development or production project
|
|
yml files, the place to do that editing is ALWAYS on localhost, this is
|
|
because all fabric commands are executed from localhost and will check for
|
|
the necessary configuration files on local (I'm not running fabric from an
|
|
ssh command line on the aws server, I'm running it on my laptop)
|
|
"""
|
|
|
|
logger = loggify('maintenance', 'edit')
|
|
|
|
# configuration = env.config
|
|
|
|
if sys.platform == "darwin":
|
|
editor = "mvim"
|
|
else:
|
|
editor = "vim"
|
|
|
|
# if env.key_filename:
|
|
# cmd_edit = "{editor} sftp://{user}@{host_string}/{remote_path}" \
|
|
# " -i {keyfile}".format(
|
|
# editor=editor,
|
|
# user=env.user,
|
|
# host_string=env.host_string,
|
|
# remote_path=remote_path,
|
|
# keyfile=env.key_filename,
|
|
# )
|
|
# else:
|
|
# cmd_edit = "{editor} sftp://{user}@{host_string}/{remote_path}".format(
|
|
# editor=editor,
|
|
# user=env.user,
|
|
# host_string=env.host_string,
|
|
# remote_path=remote_path)
|
|
|
|
cmd_edit = "{editor} sftp://{user}@{host_string}/{remote_path}".format(
|
|
editor=editor,
|
|
user=env.user,
|
|
host_string=env.host_string,
|
|
remote_path=remote_path)
|
|
|
|
if env.debug:
|
|
logger.debug("remote_path : %s" % remote_path)
|
|
logger.debug("env.host_string : %s" % env.host_string)
|
|
logger.debug("sys.platform : %s" % sys.platform)
|
|
pass
|
|
else:
|
|
|
|
if sys.platform == "darwin":
|
|
editor = "mvim"
|
|
else:
|
|
editor = "vim"
|
|
|
|
if not host_string:
|
|
host_string = env.host_string
|
|
|
|
cmd_edit = "{editor} sftp://{user}@{host_string}/{remote_path}".format(
|
|
editor=editor,
|
|
user=env.user,
|
|
host_string=host_string,
|
|
remote_path=remote_path)
|
|
|
|
local(cmd_edit)
|
|
|
|
|
|
@task
|
|
def pyc_delete():
|
|
"""
|
|
Deletes *.pyc files from project source dir
|
|
"""
|
|
configuration = env.config
|
|
|
|
with lcd(configuration.paths.project.root):
|
|
local("find . -name '*.pyc' -delete")
|
|
|
|
|
|
@task
|
|
def pyc_compile(force=False):
|
|
"""
|
|
Compile Python source files in a project source dir
|
|
"""
|
|
params = ['']
|
|
|
|
configuration = env.config
|
|
|
|
if force:
|
|
params.append('-f')
|
|
|
|
with lcd(configuration.paths.project.root):
|
|
with virtualenv():
|
|
local("python -m compileall {0} .".format(" ".join(params)))
|
|
|
|
|
|
@task
|
|
def get_base_dir():
|
|
import os
|
|
BASE_DIR = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
|
|
return BASE_DIR
|
|
|
|
|
|
@task
|
|
def get_project_root():
|
|
#
|
|
# NOTE: the PROJECT_ROOT value is very important. Make sure that
|
|
# if you move around this file, you account for where it is and add
|
|
# or take away "os.pardir" from os.path.join
|
|
|
|
PROJECT_ROOT = os.path.abspath(
|
|
os.path.join(get_base_dir(), os.pardir, os.pardir, os.pardir))
|
|
|
|
return PROJECT_ROOT
|
|
|
|
|
|
def _get_configuration_path(name, branch):
|
|
#
|
|
# the locations of the files we need relative to the PROJECT_ROOT
|
|
|
|
param_list = ['config', 'layout']
|
|
|
|
if name not in param_list:
|
|
print("value %s was not legit. _get_configuration_path requires"
|
|
"value such from %s" % (name, param_list))
|
|
|
|
META_DIR = os.path.join(
|
|
get_project_root(), 'usr', 'meta', 'project')
|
|
|
|
if name == "config":
|
|
|
|
#
|
|
# the configuration we are working with will change
|
|
# depending on what branch is being used. This value
|
|
# is passed in when the function is called
|
|
|
|
configname = "{branch}.yml".format(branch=branch)
|
|
|
|
path_meta = os.path.join(META_DIR, configname)
|
|
|
|
elif name == "layout":
|
|
path_meta = os.path.join(META_DIR, 'layout.yml')
|
|
|
|
return path_meta
|
|
|
|
|
|
def load_configuration(name, branch):
|
|
import yaml
|
|
|
|
#
|
|
# the locations of the files we need relative to the PROJECT_ROOT
|
|
|
|
if name == "config":
|
|
|
|
#
|
|
# the configuration we are working with will change
|
|
# depending on what branch is being used. This value
|
|
# is passed in when the function is called
|
|
|
|
file_path = _get_configuration_path('config', branch)
|
|
|
|
elif name == "layout":
|
|
file_path = _get_configuration_path('layout', branch)
|
|
|
|
configuration_file = yaml.load(
|
|
open(file_path, 'r'), Loader=yaml.FullLoader)
|
|
return configuration_file
|