def run(self):
# Get the docker client.
docker_client = docker.from_env()
# Determine the app.
app = self.options["<app>"]
clean = self.options["--clean"]
# Ensure it's a built app
if app is not None and App.get_build_dir(app):
# Check if we should clean it.
if clean:
App.clean_images(docker_client, app)
App.build(app)
else:
# Iterate through built apps
for app in App.get_built_apps():
# Check if we should clean it.
if clean:
App.clean_images(docker_client, app)
App.build(app)
def run(self):
# Determine the app.
app = self.options["<app>"]
# Ensure it's a built app
logger.debug("({}) Check for need to initialize".format(app))
if app is not None and App.get_repo_url(app) and App.get_repo_branch(
app):
# Initializer.
logger.debug("({}) Preparing to initialize with branch: {}".format(
app, App.get_repo_branch(app)))
App.init(app)
else:
# Iterate through built apps
for app in App.get_built_apps():
# Ensure it's a built app
if App.get_repo_url(app) and App.get_repo_branch(app):
# Initializer.
logger.debug("({}) Preparing to initialize".format(app))
App.init(app)
def run(self):
# Get the docker client.
docker_client = docker.from_env()
# Determine the app.
app = self.options["<app>"]
if app is not None:
# Check it.
if App.check(docker_client, app):
logger.info("({}) Is valid and ready to go!".format(app))
else:
# Check all apps.
stack_valid = True
apps = App.get_apps()
for app in apps:
# Check the app.
if App.check(docker_client, app):
logger.info("({}) Is valid and ready to go!".format(app))
else:
stack_valid = False
if stack_valid:
logger.info("The Stack is valid and ready to go!")
else:
logger.critical(
"Stack invalid! Ensure all paths and images are "
"correct and try again"
)
def run(self):
# Get the docker client.
docker_client = docker.from_env()
# Determine the app.
app = self.options["<app>"]
# Purge database
App.purge_data(docker_client, app)
def run(self):
# Get the docker client.
docker_client = docker.from_env()
# Get the app.
app = self.options["<app>"]
if app is not None:
# Check run status
logger.info(
"({}) Status: {}".format(app, App.get_status(docker_client, app))
)
else:
# Get all app statuses
for app in App.get_apps():
logger.info(
"({}) Status: {}".format(app, App.get_status(docker_client, app))
)
def update(package):
try:
# Get devpi index details
port = App.get_external_port("devpi", "3141")
index_url = "http://localhost:{}/root/public/".format(port)
# Get the description
config = App.get_packages_stack_config(package)
# Get password
password = App.get_config("devpi", "environment").get("DEVPI_PASSWORD")
# Get the location
path = os.path.abspath(config["path"])
dists = os.path.join(path, "dist", "*")
# Build the package
Stack.run(config.get("build"), cwd=path)
# Upload
cmd = [
"twine",
"upload",
dists,
"--repository-url",
index_url,
"--skip-existing",
"-u",
"root",
"-p",
password,
]
# Run it and make sure it was successful
return Stack.run(cmd) == 0
except Exception as e:
logger.exception("Error updating package: {}".format(e), exc_info=True)
return False
def run(self):
# Check which shell.
shell = "/bin/sh" if self.options["--sh"] else "/bin/bash"
# Get the docker client.
docker_client = docker.from_env()
# Determine the app.
app = self.options["<app>"]
if App.check_running(docker_client, app):
# Execute a shell.
subprocess.call(["docker-compose", "exec", app, shell])
def run(self):
# Get a docker client.
docker_client = docker.from_env()
# Check all the build parameters.
apps = App.get_apps()
for app in apps:
# Check images.
if not App.check_docker_images(docker_client, app):
logger.error("({}) Container image does not exist, build and"
" try again...".format(app))
return
# Ensure it is running.
if not App.check_running(docker_client, app):
logger.error(
"({}) Container is not running, ensure all containers"
" are started...".format(app))
return
# Capture and redirect output.
Stack.run(["nosetests", "-s", "-v"])
def run(self):
# Get the app.
app = self.options["<app>"]
branch = self.options["<branch>"]
# Get the repo URL
repo_url = App.get_repo_url(app)
if repo_url is None:
logger.error("({}) No repository URL specified...".format(app))
return
# Determine the path to the app directory
apps_dir = os.path.relpath(Stack.get_config("apps-directory"))
subdir = os.path.join(apps_dir, app)
# Ensure it exists.
if os.path.exists(subdir):
logger.error(
"({}) A repository already exists, use 'stack checkout' to"
" change branches".format(app)
)
return
# Build the command
command = [
"git",
"subtree",
"add",
"--prefix={}".format(subdir),
repo_url,
branch,
"--squash",
]
# Check for pre-clone hook
Stack.hook("pre-clone", app, [os.path.realpath(subdir)])
# Run the command.
return_code = Stack.run(command)
# Check for post-clone hook
if return_code == 0:
Stack.hook("post-clone", app, [os.path.realpath(subdir)])
def run(self):
# Check for time constraints.
if self.options["--minutes"]:
# Build the command.
command = [
"docker",
"logs",
"-t",
"--since",
"{}m".format(self.options["--minutes"]),
]
# Check for follow
if self.options["--follow"]:
command.append("-f")
# Add the app.
container = App.get_container_name(self.options["<app>"])
command.append(container)
# Capture and redirect output.
Stack.run(command)
else:
# Build the command.
command = ["docker-compose", "logs", "-t"]
# Check for lines.
if self.options["--lines"]:
command.extend(["--tail", self.options["--lines"]])
# Check for follow
if self.options["--follow"]:
command.append("-f")
# Add the app.
command.append(self.options["<app>"])
# Capture and redirect output.
Stack.run(command)
def run(self):
# Get the app.
app = self.options["<app>"]
branch = self.options["<branch>"]
# Get the repo URL
repo_url = App.get_repo_url(app)
if repo_url is None:
logger.error("({}) No repository URL specified...".format(app))
return
# Determine the path to the app directory
apps_dir = os.path.relpath(Stack.get_config("apps-directory"))
subdir = os.path.join(apps_dir, app)
# Ensure it exists.
if not os.path.exists(subdir):
logger.error(
'({}) No repository at {}, run "stack clone" command first'.
format(app))
return
# Build the command
command = [
"git",
"subtree",
"pull",
"--prefix={}".format(subdir),
repo_url,
branch,
]
# Check for a squash.
if self.options.get("--squash"):
command.append("--squash")
# Run the command.
Stack.run(command)
def run(self):
# Get the docker client.
docker_client = docker.from_env()
# Check it.
if not App.check(docker_client):
logger.critical(
"Stack is invalid! Ensure all paths and images are correct"
" and try again")
return
# Check for clean.
if self.options["--clean"]:
App.clean_images(docker_client)
# Iterate through built apps
for app in App.get_built_apps():
App.build(app)
# Build the command.
command = ["docker-compose", "up"]
# Check for the daemon flag.
if self.options["-d"]:
command.append("-d")
# Check for flags
if self.options.get("<flags>"):
# Split them, append the '--' and add them to the command
for flag in self.options.get("<flags>").split(","):
command.append("-{}".format(flag) if len(flag) ==
1 else "--{}".format(flag))
# Run the pre-build hook, if any
Stack.hook("pre-up")
# Capture and redirect output.
logger.debug("(stack) Running docker-compose up...")
Stack.run(command)
# Run the pre-build hook, if any
Stack.hook("post-up")
def run(self):
# Get a docker client.
docker_client = docker.from_env()
# Get options.
clean = self.options["--clean"]
app = self.options["<app>"]
# Check for stack or app
if app:
# Check for clean.
if clean:
# Clean and fetch.
App.clean_images(docker_client, app)
# Build it.
App.build(app)
# Capture and redirect output.
Stack.run(["docker-compose", "kill", app])
Stack.run(["docker-compose", "rm", "-f", "-v", app])
# Run the pre-up hook, if any
Stack.hook("pre-up", app)
# Build the up command
up = ["docker-compose", "up", "--no-start"]
# Check for purge
if self.options["--purge"]:
# Confirm
if self.yes_no("This will remove all app data, continue?"):
logger.warning("({}) Database will be purged!".format(app))
# Process it
App.purge_data(docker_client, app)
else:
logger.info("({}) Database will not be purged".format(app))
# Check for recreate flag
if not self.options.get("--recreate"):
up.append("--no-recreate")
# Check for flags
if self.options.get("--flags"):
# Split them
flags = self.options.get("--flags").split(",")
# Don't add default options twice
for flag in [f for f in flags if f in up]:
flags.remove(flag)
logger.debug(
"(stack) Removing double option: '{}'".format(flag))
# Split them, append the '--' and add them to the command
for flag in flags:
up.append("-{}".format(flag) if len(flag) ==
1 else "--{}".format(flag))
# Add the app
up.append(app)
logger.debug("(stack) Running command: '{}'".format(up))
Stack.run(up)
# Run it
run_cmd = ["docker-compose", "start", app]
logger.debug("(stack) Running command: '{}'".format(run_cmd))
Stack.run(run_cmd)
# Run the post-up hook, if any
Stack.hook("post-up", app)
else:
# Check for clean.
if clean and self.yes_no("Clean: Rebuild all app images?"):
# Clean and fetch.
for app in App.get_apps():
if self.yes_no("({}) Rebuild app image?"):
logger.info("({}) Rebuilding image...".format(app))
# Rebuild images
App.clean_images(docker_client, app)
# Build and run stack down
down_command = ["stack", "down"]
if clean:
down_command.append("--clean")
Stack.run(down_command)
# Run the pre-up hook, if any
Stack.hook("pre-up")
# Build and run stack up
up_command = ["stack", "up"]
if self.options["-d"]:
up_command.append("-d")
Stack.run(up_command)
# Run the pre-up hook, if any
Stack.hook("post-up")
def run(self):
# Create a list of apps to update
apps = App.get_apps()
# Get the app.
app = self.options.get("<app>")
if app:
apps = [app]
# Filter out apps without repository details
apps = [app for app in apps if App.get_repo_branch(app)]
# Ensure no local changes
if Stack.run(
["git", "diff-index", "--name-status", "--exit-code", "HEAD"]):
logger.error(
"Current working copy has changes, cannot update app repositories"
)
exit(1)
logger.info("Will update {}".format(", ".join(apps)))
# Iterate and update
for app in apps:
# Get the repo URL
repo_url = App.get_repo_url(app)
branch = App.get_repo_branch(app)
if repo_url is None or branch is None:
logger.error(
"({}) No repository URL and/or branch specified...".format(
app))
continue
# Determine the path to the app directory
apps_dir = os.path.relpath(Stack.get_config("apps-directory"))
subdir = os.path.join(apps_dir, app)
# Check for pre-checkout hook
Stack.hook("pre-checkout", app, [os.path.realpath(subdir)])
# Build the command
command = [
"git",
"subtree",
"add",
"--prefix={}".format(subdir),
repo_url,
branch,
"--squash",
]
# Remove the current subtree.
Stack.run(["git", "rm", "-rf", subdir])
Stack.run(["rm", "-rf", subdir])
Stack.run([
"git",
"commit",
"-m",
'"Stack op: Removing subtree {} for cloning branch {}"'.format(
app, branch),
])
# Run the command.
Stack.run(command)
# Check for post-checkout hook
Stack.hook("post-checkout", app, [os.path.realpath(subdir)])
def update_apps(package):
# Find all services listing this package
for app, config in Stack.get_config("apps").items():
try:
# Check packages
if config.get("packages") and package in config.get("packages"):
# Get the docker client.
docker_client = docker.from_env()
# Determine the app.
if App.check_running(docker_client, app):
logger.info(
"App '{}' depends on '{}', reinstalling...".format(
app, package
)
)
# Build the uninstall command
uninstall = [
"docker-compose",
"exec",
app,
"pip",
"uninstall",
"-y",
package,
]
# Execute a shell.
code = Stack.run(uninstall)
if code == 0:
logger.info(" ... uninstalled ...")
# Build the install command
install = [
"docker-compose",
"exec",
app,
"pip",
"install",
package,
]
# Execute a shell.
code = Stack.run(install)
if code == 0:
logger.info(" ... reinstall succeeded!")
else:
logger.error(
" .... failed with exit code: {}".format(code)
)
else:
logger.error(
" .... failed with exit code: {}".format(code)
)
else:
logger.error(
" .... App {} is not running, cannot update".format(app)
)
except Exception as e:
logger.exception(
"Error reinstalling package for {}: {}".format(app, e),
exc_info=True,
)
def run(self):
# Get the app.
app = self.options["<app>"]
branch = self.options["<branch>"]
# Get the repo URL
repo_url = App.get_repo_url(app)
if repo_url is None:
logger.error("({}) No repository URL specified...".format(app))
return
# Determine the path to the app directory
apps_dir = os.path.relpath(Stack.get_config("apps-directory"))
subdir = os.path.join(apps_dir, app)
# Ensure no local changes
if Stack.run(["git", "diff-index", "--name-status", "--exit-code", "HEAD"]):
logger.error(
"Current working copy has changes, cannot update app repositories"
)
exit(1)
# Check if new branch.
if self.options["-b"]:
# Ensure it exists.
if not os.path.exists(subdir):
logger.error(
"({}) This repository does not exist yet, run"
" 'stack clone' command first".format(app, subdir)
)
return
# Check for pre-checkout hook
Stack.hook("pre-checkout", app, [os.path.realpath(subdir)])
# Do a split.
command = [
"git",
"subtree",
"split",
"--prefix={}".format(subdir),
"--branch",
branch,
]
Stack.run(command)
else:
# Check for pre-checkout hook
Stack.hook("pre-checkout", app, [os.path.realpath(subdir)])
# Build the command
command = [
"git",
"subtree",
"add",
"--prefix={}".format(subdir),
repo_url,
branch,
"--squash",
]
# Remove the current subtree.
Stack.run(["git", "rm", "-rf", subdir])
Stack.run(["rm", "-rf", subdir])
Stack.run(
[
"git",
"commit",
"-m",
'"Stack op: Removing subtree {} for cloning branch {}"'.format(
app, branch
),
]
)
# Run the command.
Stack.run(command)
# Check for post-checkout hook
Stack.hook("post-checkout", app, [os.path.realpath(subdir)])