#!/usr/bin/python
# -*- python -*-
# -*- coding: utf-8 -*-
# Started 30/06/2011 by Seblu <seblu@seblu.net>
'''
InstallSystems Command line Tool
'''
import os
import time
import datetime
import re
import fnmatch
import warnings
import argparse
import installsystems
import installsystems.printer
import installsystems.tools as istools
from installsystems.printer import *
from installsystems.repository import Repository
from installsystems.repository import RepositoryManager
from installsystems.repository import RepositoryConfig
from installsystems.image import PackageImage, SourceImage
from installsystems.config import MainConfigFile, RepoConfigFile
################################################################################
# Common functions
################################################################################
def load_repositories(args):
'''
Load repositories on a repository manager
'''
# remove cache is asked
if hasattr(args, "no_cache") and args.no_cache:
args.cache = None
# split filter in list
if args.repo_filter is not None:
args.repo_filter = split_repositories(args.repo_filter)
# init repo cache object
repoman = RepositoryManager(args.cache, timeout=args.timeout, filter=args.repo_filter)
# register repositories (order matter)
# load repo configs from command line
if args.repo_path is not None:
repoman.register(RepositoryConfig(istools.smd5sum(args.repo_path)[:8],
path=args.repo_path), temp=True,
nosync=hasattr(args, "no_sync") and args.no_sync,
offline=hasattr(args, "force_offline") and args.force_offline)
# load repo configs from config
for repoconf in RepoConfigFile(args.repo_config).repos:
repoman.register(repoconf,
nosync=hasattr(args, "no_sync") and args.no_sync,
offline=hasattr(args, "force_offline") and args.force_offline)
return repoman
def split_repositories(repos, filter=None):
'''
Return a list of repository from an comma/space separated list of repo
'''
if filter is None:
filter = lambda x: x != ""
return [r for r in re.split("[ ,\n\t\v]+", repos) if filter(r)]
def select_image(name, repoman, best=False):
'''
Select and load a package image from a standard naming type
Allowed type are a direct filename on filesystem
or [repo/]image[:version]
Return the repository as second argument
'''
# image is a local file
if istools.isfile(name) and os.path.isfile(name):
return PackageImage(name), None
# we need to find image in a repository
else:
if len(repoman.onlines) == 0:
raise Exception('No online repository')
(repo, image, version) = istools.split_image_path(name)
debug("Requested image: %s v%s in %s" % (image, version, repo))
# repo is not specified, we need to crawl in path
if repo is None:
# split search path as a list
if args.repo_search is not None:
args.repo_search = split_repositories(args.repo_search,
lambda x: x in repoman.onlines)
else:
args.repo_search = []
# if we have only one repo, search in it
if len(args.repo_search) == 0 and len(repoman.onlines) == 1:
args.repo_search = repoman.onlines
elif len(args.repo_search) == 0 and len(repoman.onlines) > 1:
raise Exception('You must use a full image path or set a valid search path')
return repoman.get(image, version, search=args.repo_search, best=best)
# we can ask directly repository about image
else:
return repoman[repo].get(image, version), repoman[repo]
################################################################################
# Commands functions
################################################################################
def c_add(parser, args):
'''
Add an image package into a repository
'''
repoman = load_repositories(args)
repo = repoman[args.repository]
for image in args.path:
pkg = PackageImage(image)
repo.add(pkg, delete=not args.preserve)
def c_build(parser, args):
'''
Build an image source in current directory
'''
# build start time
t0 = time.time()
# load source image
simg = SourceImage(args.path)
# do the job
simg.build(force=args.force, force_payload=args.payload, check=not args.no_check)
# compute building time
t1 = time.time()
dt = int(t1 - t0)
arrow("Build time: %s" % datetime.timedelta(seconds=dt))
def c_cat(parser, args):
'''
Display image's file
'''
# looks if arguments is a file or image name
repoman = load_repositories(args)
img, repo = select_image(args.image, repoman, args.best)
for filename in args.file:
img.cat(filename)
def c_changelog(parser, args):
'''
Display image's changelog
'''
# looks if arguments is a file or image name
repoman = load_repositories(args)
img, repo = select_image(args.image, repoman, args.best)
img.changelog.show(int(img.version), args.all_version)
def c_check(parser, args):
'''
Sanity checks on repositories
'''
repoman = load_repositories(args)
for reponame in args.repository:
repoman[reponame].check()
def c_chroot(parser, args):
'''
Helper to go cleanly inside a chroot
'''
istools.chroot(args.path, shell=args.shell, mount=not args.no_mount)
def c_clean(parser, args):
'''
Remove unreferenced files from repoistory
'''
repoman = load_repositories(args)
for reponame in args.repository:
repoman[reponame].clean()
def c_copy(parser, args):
'''
Copy an image from a repository to another one
'''
repoman = load_repositories(args)
dstrepo = repoman[args.repository]
for image in args.image:
srcimg, srcrepo = select_image(image, repoman, args.best)
arrow("Copying %s v%s from repository %s to %s" % (srcimg.name,
srcimg.version,
srcrepo.config.name,
dstrepo.config.name))
arrowlevel(1)
dstrepo.add(srcimg)
arrowlevel(-1)
def c_del(parser, args):
'''
Remove an image package from a repository
'''
repoman = load_repositories(args)
for image in args.image:
img, repo = select_image(image, repoman, args.best)
if repo is None:
raise Exception("You cannot delete an image outside a repository")
if not args.force:
warn("The following opereation cannot be reversed!")
out("You will delete %s v%s in repository %s" % (img.name,
img.version,
repo.config.name))
if not confirm():
raise Exception("Aborted!")
repo.delete(img.name, img.version, payloads=not args.preserve)
def c_diff(parser, args):
'''
Show diff between two repositories or images
'''
repoman = load_repositories(args)
if args.object[0] in repoman.onlines and args.object[1] in repoman.onlines:
Repository.diff(repoman[args.object[0]], repoman[args.object[1]])
else:
img1, repo1 = select_image(args.object[0], repoman, args.best)
img2, repo2 = select_image(args.object[1], repoman, args.best)
PackageImage.diff(img1, img2)
def c_extract(parser, args):
'''
Extract an image package inside a directory
'''
repoman = load_repositories(args)
img, repo = select_image(args.image, repoman, args.best)
img.extract(args.path, payload=args.payload, force=args.force,
gendescription=args.gen_description)
def c_get(parser, args):
'''
Download a remote image in current directory
'''
repoman = load_repositories(args)
for image in args.image:
img, repo = select_image(image, repoman, args.best)
img.download(".", image=not args.no_image, payload=args.payload, force=args.force)
def c_help(parser, args):
'''
Show help
'''
if args.command not in args.subparser.choices:
parser.print_help()
else:
args.subparser.choices[args.command].print_help()
def c_info(parser, args):
'''
Get info about an image
'''
repoman = load_repositories(args)
for image in args.image:
img, repo = select_image(image, repoman, args.best)
img.show(verbose=args.verbose, changelog=args.changelog)
def c_init(parser, args):
'''
Create an empty repository
'''
repoman = load_repositories(args)
for reponame in args.repository:
repoman[reponame].init()
def c_install(parser, args):
'''
Install an image
'''
# remove old image args
args.parser._remove_action([d for d in args.parser._actions if d.dest == "image"][0])
# create a subparser for current image to have a sexy display of args
#args.image = "roger"
subparser = args.parser.add_subparsers().add_parser(args.image)
# select image to install
repoman = load_repositories(args)
img = select_image(args.image, repoman, args.best)[0]
# Print setup information
arrow("Installing %s v%s" % (img.name, img.version))
# install start time
t0 = time.time()
# run parser scripts with parser parser argument
img.run_parser(parser=subparser)
# call parser again, with extended attributes
arrow("Parsing arguments")
#parser.print_help()
args = parser.parse_args()
# run setup scripts
img.run_setup(namespace=args)
# compute building time
t1 = time.time()
dt = int(t1 - t0)
arrow("Install time: %s" % datetime.timedelta(seconds=dt))
def c_list(parser, args):
'''
List images in repository or image content
'''
repoman = load_repositories(args)
if args.search is not None:
args.search = split_repositories(args.repo_search, lambda x: x in repoman.onlines)
for pattern in args.image:
repoman.show_images(pattern, all_version=args.all_version, search=args.search,
o_long=args.long, o_json=args.json,
o_md5=args.md5, o_date=args.date, o_author=args.author,
o_size=args.size, o_url=args.url, o_description=args.description)
def c_move(parser, args):
'''
Move an image from a repository to another one
'''
repoman = load_repositories(args)
dstrepo = repoman[args.repository]
for image in args.image:
srcimg, srcrepo = select_image(image, repoman, args.best)
if not args.force:
out("You will move %s v%s from %s to %s" % (srcimg.name,
srcimg.version,
srcrepo.config.name,
dstrepo.config.name))
if not confirm():
raise Exception("Aborted!")
arrow("Moving %s v%s from repository %s to %s" % (srcimg.name,
srcimg.version,
srcrepo.config.name,
dstrepo.config.name))
arrowlevel(1)
dstrepo.add(srcimg)
srcrepo.delete(srcimg.name, srcimg.version)
arrowlevel(-1)
def c_new(parser, args):
'''
Create a new source image
'''
SourceImage.create(args.path, args.force)
def c_prepare_chroot(parser, args):
'''
Prepare a chroot
'''
istools.prepare_chroot(args.path, mount=not args.no_mount)
def c_repo(parser, args):
'''
Get information about repositories
'''
repoman = load_repositories(args)
for pattern in args.repository:
repoman.show_repos(pattern, online=args.online, local=args.local,
url=args.url, state=args.state)
def c_search(parser, args):
'''
Search in repository
'''
repoman = load_repositories(args)
repoman.search(args.pattern)
def c_unprepare_chroot(parser, args):
'''
Remove preparation of a chroot
'''
istools.unprepare_chroot(args.path, mount=not args.no_umount)
def c_version(parser, args):
'''
Print installsystems version
'''
out(installsystems.version)
################################################################################
# Parser definition
################################################################################
# Top level argument parsing
p_main = argparse.ArgumentParser()
p_main.add_argument("-V", "--version", action="version",
version=installsystems.version,
help="show installsystems version")
# exclusive group on debug/quiet
ex_group = p_main.add_mutually_exclusive_group()
ex_group.add_argument("-d", "--debug", action="store_true", default=None,
help="active debug mode")
ex_group.add_argument("-q", "--quiet", action="store_true", default=None,
help="active quiet mode")
# common options
p_main.add_argument("-c", "--config", default="installsystems", metavar="PATH",
help="config file path")
p_main.add_argument("-R", "--repo-config", default="repository", metavar="REPO",
help="repository config file path")
p_main.add_argument("-s", "--repo-search", metavar="REPO,REPO,...",
help="search for images inside those repositories")
p_main.add_argument("-f", "--repo-filter", metavar="REPO,REPO,...",
help="filter repositories by name")
p_main.add_argument("-r", "--repo-path", metavar="PATH",
help="define a temporary repository")
p_main.add_argument("-C", "--cache", metavar="PATH",
help="path of the repository cache")
p_main.add_argument("--no-cache", action="store_true", default=None,
help="not use persistent db caching")
p_main.add_argument("--no-color", action="store_true", default=None,
help="dot not display colored output")
p_main.add_argument("-t", "--timeout", dest="timeout", type=int, default=None,
metavar="SECONDS", help="download timeout (default 3)")
# create a subparsers for each command
subparsers = p_main.add_subparsers()
# add command parser
p_add = subparsers.add_parser("add", help=c_add.__doc__.lower())
p_add.add_argument("-p", "--preserve", action="store_true", default=False,
help="don't remove image after adding to database")
p_add.add_argument("repository", help="repository where images will be added")
p_add.add_argument("path", nargs="+", help="image path")
p_add.set_defaults(func=c_add)
# build command parser
p_build = subparsers.add_parser("build", help=c_build.__doc__.lower())
p_build.add_argument("-c", "--no-check", action="store_true", default=False,
help="do not check compilation before adding scripts")
p_build.add_argument("-f", "--force", action="store_true", default=False,
help="rebuild image if already exists")
p_build.add_argument("-p", "--payload", action="store_true", default=False,
help="rebuild payloads if already exists")
p_build.add_argument("path", nargs="?", default=".")
p_build.set_defaults(func=c_build)
# cat command parser
p_cat = subparsers.add_parser("cat", help=c_cat.__doc__.lower())
p_cat.add_argument("-b", "--best", action="store_true", default=False,
help="take the most recent image in all searchable repositories")
p_cat.add_argument("image", help="<path|[repository/]image[:version]>")
p_cat.add_argument("file", nargs="+",
help="file inside image to cat (globbing allowed)")
p_cat.set_defaults(func=c_cat)
# changelog command parser
p_changelog = subparsers.add_parser("changelog", help=c_changelog.__doc__.lower())
p_changelog.add_argument("-b", "--best", action="store_true", default=False,
help="take the most recent image in all searchable repositories")
p_changelog.add_argument("-v", "--all-version", action="store_true", default=False,
help="display changelog for all versions")
p_changelog.add_argument("image", help="<path|[repository/]image[:version]>")
p_changelog.set_defaults(func=c_changelog)
# check command parser
p_check = subparsers.add_parser("check", help=c_check.__doc__.lower())
p_check.add_argument("repository", nargs="+", help="repositories to check")
p_check.set_defaults(func=c_check)
# chroot command parser
p_chroot = subparsers.add_parser("chroot", help=c_chroot.__doc__.lower())
p_chroot.add_argument("-m", "--no-mount", action="store_true", default=False,
help="disable mouting of /{proc,dev,sys} inside chroot")
p_chroot.add_argument("-s", "--shell", default="/bin/bash",
help="shell to call inside chroot")
p_chroot.add_argument("path")
p_chroot.set_defaults(func=c_chroot)
# clean command parser
p_clean = subparsers.add_parser("clean", help=c_clean.__doc__.lower())
p_clean.add_argument("repository", nargs="+", help="repositories to clean")
p_clean.set_defaults(func=c_clean)
# copy command parser
p_copy = subparsers.add_parser("copy", help=c_copy.__doc__.lower())
p_copy.add_argument("-b", "--best", action="store_true", default=False,
help="take the most recent image in all searchable repositories")
p_copy.add_argument("image", nargs="+",
help="image syntax is <path|[repository/]image[:version]>")
p_copy.add_argument("repository", help="destination repository")
p_copy.set_defaults(func=c_copy)
# del command parser
p_del = subparsers.add_parser("del", help=c_del.__doc__.lower())
p_del.add_argument("image", nargs="+",
help="image syntax is <path|[repository/]image[:version]>")
p_del.add_argument("-b", "--best", action="store_true", default=False,
help="take the most recent image in all searchable repositories")
p_del.add_argument("-f", "--force", action="store_true", default=False,
help="delete image without confirmation")
p_del.add_argument("-p", "--preserve", action="store_true", default=False,
help="preserve payloads. doesn't remove it from repository")
p_del.set_defaults(func=c_del)
# diff command parser
p_diff = subparsers.add_parser("diff", help=c_diff.__doc__.lower())
p_diff.add_argument("object", nargs=2,
help="object syntax is <path|repository|[repository/]image[:version]>")
p_diff.add_argument("-b", "--best", action="store_true", default=False,
help="take the most recent image in all searchable repositories")
p_diff.set_defaults(func=c_diff)
# extract command parser
p_extract = subparsers.add_parser("extract", help=c_extract.__doc__.lower())
p_extract.add_argument("-b", "--best", action="store_true", default=False,
help="take the most recent image in all searchable repositories")
p_extract.add_argument("-f", "--force", action="store_true", default=False,
help="overwrite existing destinations")
p_extract.add_argument("-g", "--gen-description", action="store_true", default=False,
help="generate a description file from metadata")
p_extract.add_argument("-p", "--payload", action="store_true", default=False,
help="extract payloads")
p_extract.add_argument("image",
help="image syntax is <path|[repository/]image[:version]>")
p_extract.add_argument("path", help="image will be extracted in path")
p_extract.set_defaults(func=c_extract)
# get command parser
p_get = subparsers.add_parser("get", help=c_get.__doc__.lower())
p_get.add_argument("-b", "--best", action="store_true", default=False,
help="take the most recent image in all searchable repositories")
p_get.add_argument("-f", "--force", action="store_true", default=False,
help="overwrite existing destinations")
p_get.add_argument("-I", "--no-image", action="store_true", default=False,
help="do not get image")
p_get.add_argument("-p", "--payload", action="store_true", default=False,
help="get payloads")
p_get.add_argument("image", nargs="+",
help="image syntax is <path|[repository/]image[:version]>")
p_get.set_defaults(func=c_get)
# help command parser
p_help = subparsers.add_parser("help", help=c_help.__doc__.lower())
p_help.add_argument("command", nargs="?", help="command name")
p_help.set_defaults(func=c_help, subparser=subparsers)
# info command parser
p_info = subparsers.add_parser("info", help=c_info.__doc__.lower())
p_info.add_argument("-b", "--best", action="store_true", default=False,
help="take the most recent image in all searchable repositories")
p_info.add_argument("-c", "--changelog", action="store_true", default=False,
help="display image changelog")
p_info.add_argument("-v", "--verbose", action="store_true", default=False,
help="verbose output")
p_info.add_argument("image", nargs="+",
help="image syntax is <path|[repository/]image[:version]>")
p_info.set_defaults(func=c_info)
# init command parser
p_init = subparsers.add_parser("init", help=c_init.__doc__.lower())
p_init.add_argument("repository", nargs="+",
help="repository to initialize")
p_init.set_defaults(func=c_init)
# install command parser
p_install = subparsers.add_parser("install", add_help=False,
help=c_install.__doc__.lower())
p_install.add_argument("-b", "--best", action="store_true", default=False,
help="take the most recent image in all searchable repositories")
p_install.add_argument("image",
help="image syntax is <path|[repository/]image[:version]>")
p_install.set_defaults(func=c_install, parser=p_install)
# list command parser
p_list = subparsers.add_parser("list", help=c_list.__doc__.lower())
p_list.add_argument("-a", "--all-version", action="store_true", default=False,
help="list all versions of the same image")
p_list.add_argument("-A", "--author", action="store_true", default=False,
help="display image author")
p_list.add_argument("-d", "--date", action="store_true", default=False,
help="display image date")
p_list.add_argument("-D", "--description", action="store_true", default=False,
help="display image description")
p_list.add_argument("-j", "--json", action="store_true", default=False,
help="long display")
p_list.add_argument("-l", "--long", action="store_true", default=False,
help="long display")
p_list.add_argument("-m", "--md5", action="store_true", default=False,
help="display image md5")
p_list.add_argument("--no-sync", action="store_true", default=False,
help="doesn't sync repository before listing")
p_list.add_argument("-s", "--size", action="store_true", default=False,
help="display image size")
p_list.add_argument("-u", "--url", action="store_true", default=False,
help="display image url")
p_list.add_argument("-S", "--search", action="store_true", default=None,
help="only list image in search path")
p_list.add_argument("image", nargs="*", default=['*'],
help="image syntax is [repository/]image[:version]")
p_list.set_defaults(func=c_list)
# move command parser
p_move = subparsers.add_parser("move", help=c_move.__doc__.lower())
p_move.add_argument("-b", "--best", action="store_true", default=False,
help="take the most recent image in all searchable repositories")
p_move.add_argument("-f", "--force", action="store_true", default=False,
help="move image without confirmation")
p_move.add_argument("image", nargs="+",
help="image syntax is <path|[repository/]image[:version]>")
p_move.add_argument("repository", help="destination repository")
p_move.set_defaults(func=c_move)
# new command parser
p_new = subparsers.add_parser("new", help=c_new.__doc__.lower())
p_new.add_argument("-f", "--force", action="store_true", default=False,
help="overwrite existing source image")
p_new.add_argument("path", help="new image directory path")
p_new.set_defaults(func=c_new)
# prepare_chroot command parser
p_prepare_chroot = subparsers.add_parser("prepare_chroot", help=c_prepare_chroot.__doc__.lower())
p_prepare_chroot.add_argument("-m", "--no-mount", action="store_true", default=False,
help="disable mouting of /{proc,dev,sys}")
p_prepare_chroot.add_argument("path")
p_prepare_chroot.set_defaults(func=c_prepare_chroot)
# repo command parser
p_repo = subparsers.add_parser("repo", help=c_repo.__doc__.lower())
p_repo.add_argument("--force-offline", action="store_true", default=False,
help="force repository to be offline")
p_repo_mgroup = p_repo.add_mutually_exclusive_group()
p_repo_mgroup.add_argument("-l", "--local", action="store_true", default=None,
help="list local repository (filter)")
p_repo_mgroup.add_argument("-r", "--remote", action="store_false", dest="local",
help="list remote repository (filter)")
p_repo_mgroup = p_repo.add_mutually_exclusive_group()
p_repo_mgroup.add_argument("-o", "--online", action="store_true", default=None,
help="list online repository (filter)")
p_repo_mgroup.add_argument("-O", "--offline", action="store_false", dest="online",
help="list offline repository (filter)")
p_repo.add_argument("-s", "--state", action="store_true", default=False,
help="display repository state (online/offline/local/remote)")
p_repo.add_argument("-u", "--url", action="store_true", default=False,
help="display repository url")
p_repo.add_argument("repository", nargs='*', default=["*"], help="repository pattern")
p_repo.set_defaults(func=c_repo)
# search command parser
p_search = subparsers.add_parser("search", help=c_search.__doc__.lower())
p_search.add_argument("pattern", help="pattern to search in repositories")
p_search.set_defaults(func=c_search)
# unprepare_chroot command parser
p_unprepare_chroot = subparsers.add_parser("unprepare_chroot", help=c_unprepare_chroot.__doc__.lower())
p_unprepare_chroot.add_argument("-m", "--no-umount", action="store_true", default=False,
help="disable unmouting of /{proc,dev,sys}")
p_unprepare_chroot.add_argument("path")
p_unprepare_chroot.set_defaults(func=c_unprepare_chroot)
# version command parser
p_version = subparsers.add_parser("version", help=c_version.__doc__.lower())
p_version.set_defaults(func=c_version)
################################################################################
# Main
################################################################################
try:
# first (partial) parsing
args = p_main.parse_known_args()[0]
# set debug and quiet mode before merge
installsystems.debug = args.debug
installsystems.quiet = args.quiet
# load isinstall config
config = MainConfigFile(args.config, "installsystems")
config.merge(args)
# set debug and quiet mode after merge
installsystems.debug = args.debug
installsystems.quiet = args.quiet
# no warning if we are not in debug mode
if not installsystems.debug:
warnings.filterwarnings("ignore")
# disable coloring if asked
if args.no_color:
installsystems.printer.NOCOLOR = True
# except for install command we parse all args!
# install command is responsible of parsing
if args.func is not c_install:
args = p_main.parse_args(namespace=args)
# let's go
args.func(p_main, args)
except Exception as e:
error(e)
except KeyboardInterrupt:
warn("Keyboard Interrupted")
exit(1)