mirror of https://github.com/axmolengine/axmol.git
636 lines
24 KiB
Python
636 lines
24 KiB
Python
#! /usr/bin/env python
|
|
# coding=utf-8
|
|
|
|
from __future__ import print_function
|
|
from __future__ import unicode_literals
|
|
|
|
__version__ = "1.7"
|
|
|
|
import sys
|
|
import os
|
|
import shutil
|
|
import traceback
|
|
|
|
from os import path, extsep
|
|
from subprocess import Popen, PIPE, CalledProcessError
|
|
|
|
def os_is_win32():
|
|
return sys.platform == 'win32'
|
|
|
|
class UnrecognizedFormat:
|
|
def __init__(self, prompt):
|
|
self._prompt = prompt
|
|
def __str__(self):
|
|
return self._prompt
|
|
|
|
class GitArchiver(object):
|
|
"""
|
|
GitArchiver
|
|
|
|
Scan a git repository and export all tracked files, and submodules.
|
|
Checks for .gitattributes files in each directory and uses 'export-ignore'
|
|
pattern entries for ignore files in the archive.
|
|
|
|
Automatically detects output format extension: zip, tar, bz2, or gz.
|
|
"""
|
|
|
|
def __init__(self, prefix='', verbose=False, exclude=True, force_sub=False, extra=None, main_repo_abspath=None):
|
|
"""
|
|
@type prefix: string
|
|
@param prefix: Prefix used to prepend all paths in the resulting archive.
|
|
|
|
@type verbose: bool
|
|
@param verbose: Determines verbosity of the output (stdout).
|
|
|
|
@type exclude: bool
|
|
@param exclude: Determines whether archiver should follow rules specified in .gitattributes files.
|
|
Defaults to True.
|
|
|
|
@type force_sub: bool
|
|
@param force_sub: Determines whether submodules are initialized and updated before archiving.
|
|
Defaults to False
|
|
|
|
@type extra: list
|
|
@param extra: List of extra paths to include in the resulting archive.
|
|
|
|
@type main_repo_abspath: string
|
|
@param main_repo_abspath: Absolute path to the main repository (or one of subdirectories).
|
|
If None, current cwd is used.
|
|
If given path is path to a subdirectory (but not a submodule directory!)
|
|
it will be replaced with abspath to toplevel directory of the repository.
|
|
"""
|
|
if extra is None:
|
|
extra = []
|
|
|
|
if main_repo_abspath is None:
|
|
main_repo_abspath = path.abspath('')
|
|
elif not path.isabs(main_repo_abspath):
|
|
raise ValueError("You MUST pass absolute path to the main git repository.")
|
|
|
|
# Raises an exception if there is no repo under main_repo_abspath.
|
|
try:
|
|
self.run_shell("git rev-parse", main_repo_abspath)
|
|
except Exception as e:
|
|
raise ValueError("Not a git repository (or any of the parent directories).".format(path=main_repo_abspath))
|
|
|
|
# Detect toplevel directory of the repo.
|
|
main_repo_abspath = path.abspath(self.read_git_shell('git rev-parse --show-toplevel', main_repo_abspath).rstrip())
|
|
|
|
self.prefix = prefix
|
|
self.verbose = verbose
|
|
self.exclude = exclude
|
|
self.extra = extra
|
|
self.force_sub = force_sub
|
|
self.main_repo_abspath = main_repo_abspath
|
|
|
|
def load_json_file(self, file_path):
|
|
import json
|
|
if not path.isfile(file_path):
|
|
raise Exception("Could not find (%s)" % (file_path))
|
|
|
|
with open(file_path) as data_file:
|
|
data = json.load(data_file)
|
|
return data
|
|
|
|
def ensure_directory(self, target):
|
|
if not os.path.exists(target):
|
|
os.mkdir(target)
|
|
|
|
def unpack_zipfile(self, zip_file_path, extract_dir):
|
|
"""Unpack zip `filename` to `extract_dir`
|
|
|
|
Raises ``UnrecognizedFormat`` if `filename` is not a zipfile (as determined
|
|
by ``zipfile.is_zipfile()``).
|
|
"""
|
|
|
|
import zipfile
|
|
if not zipfile.is_zipfile(zip_file_path):
|
|
raise UnrecognizedFormat("%s is not a zip file" % zip_file_path)
|
|
|
|
file_paths = []
|
|
print("==> Extracting files, please wait ...")
|
|
z = zipfile.ZipFile(zip_file_path)
|
|
try:
|
|
for info in z.infolist():
|
|
name = info.filename
|
|
|
|
# don't extract absolute paths or ones with .. in them
|
|
if name.startswith('/') or '..' in name:
|
|
continue
|
|
|
|
target = os.path.join(extract_dir, *name.split('/'))
|
|
if not target:
|
|
continue
|
|
if name.endswith('/'):
|
|
# directory
|
|
self.ensure_directory(target)
|
|
else:
|
|
# file
|
|
data = z.read(info.filename)
|
|
file_paths.append(target)
|
|
f = open(target,'wb')
|
|
try:
|
|
f.write(data)
|
|
finally:
|
|
f.close()
|
|
del data
|
|
unix_attributes = info.external_attr >> 16
|
|
if unix_attributes:
|
|
os.chmod(target, unix_attributes)
|
|
finally:
|
|
z.close()
|
|
print("==> Extraction done!")
|
|
return file_paths
|
|
|
|
def create(self, output_path, dry_run=False, output_format=None):
|
|
"""
|
|
Creates the archive, written to the given output_file_path
|
|
|
|
Type of the archive is determined either by extension of output_file_path or by the format argument.
|
|
Supported formats are: gz, zip, bz2, tar, tgz
|
|
|
|
@type output_path: string
|
|
@param output_path: Output file path.
|
|
|
|
@type dry_run: bool
|
|
@param dry_run: Determines whether create should do nothing but print what it would archive.
|
|
|
|
@type output_format: string
|
|
@param output_format: Determines format of the output archive.
|
|
If None, format is determined from extension of output_file_path.
|
|
"""
|
|
if output_format is None:
|
|
file_name, file_ext = path.splitext(output_path)
|
|
output_format = file_ext[len(extsep):].lower()
|
|
|
|
if output_format == 'zip':
|
|
from zipfile import ZipFile, ZIP_DEFLATED
|
|
|
|
if not dry_run:
|
|
archive = ZipFile(path.abspath(output_path), 'w')
|
|
add = lambda file_path, file_name: archive.write(file_path, path.join(self.prefix, file_name), ZIP_DEFLATED)
|
|
elif output_format in ['tar', 'bz2', 'gz', 'tgz']:
|
|
import tarfile
|
|
|
|
if output_format == 'tar':
|
|
t_mode = 'w'
|
|
elif output_format == 'tgz':
|
|
t_mode = 'w:gz'
|
|
else:
|
|
t_mode = 'w:{f}'.format(f=output_format)
|
|
|
|
if not dry_run:
|
|
archive = tarfile.open(path.abspath(output_path), t_mode)
|
|
add = lambda file_path, file_name: archive.add(file_path, path.join(self.prefix, file_name))
|
|
else:
|
|
raise RuntimeError("Unknown format: {f}".format(f=output_format))
|
|
|
|
print("Making archive: (%s) , please wait ..." % output_path)
|
|
for file_path in self.extra:
|
|
if not dry_run:
|
|
if self.verbose:
|
|
print("Compressing {f} => {a}...".format(f=file_path,
|
|
a=path.join(self.prefix, file_path)))
|
|
try:
|
|
add(file_path, file_path)
|
|
except:
|
|
print('add %s failed.' % file_path)
|
|
pass
|
|
else:
|
|
print("{f} => {a}".format(f=file_path,
|
|
a=path.join(self.prefix, file_path)))
|
|
|
|
for file_path in self.list_files():
|
|
if not dry_run:
|
|
if self.verbose:
|
|
print("Compressing {f} => {a}...".format(f=path.join(self.main_repo_abspath, file_path),
|
|
a=path.join(self.prefix, file_path)))
|
|
|
|
try:
|
|
add(path.join(self.main_repo_abspath, file_path), file_path)
|
|
except:
|
|
print('add %s failed.' % file_path)
|
|
pass
|
|
else:
|
|
print("{f} => {a}".format(f=path.join(self.main_repo_abspath, file_path),
|
|
a=path.join(self.prefix, file_path)))
|
|
|
|
|
|
# Execute download-deps.py in root folder
|
|
import subprocess
|
|
subprocess.call("python %s -d -f" % (path.join(self.main_repo_abspath, "download-deps.py")), shell=True, cwd=self.main_repo_abspath)
|
|
|
|
# Execute download-bin.py in console folder
|
|
console_path = path.join(self.main_repo_abspath, "tools", "console")
|
|
subprocess.call("python %s -d -f" % (path.join(console_path, "download-bin.py")), shell=True, cwd=console_path)
|
|
|
|
# Check config.json to insert a zip file content to the final generated zip file
|
|
extra_folders = []
|
|
config_data = self.load_json_file("config.json")
|
|
|
|
for zip_file in config_data["extra_zip_files"]:
|
|
zip_config = self.load_json_file(zip_file["zip_config_path"])
|
|
zip_file_name = zip_config["version"] + '.zip'
|
|
extra_to_zip_file = zip_file["extract_to_zip_path"]
|
|
zip_file_path = os.path.join(zip_file["zip_file_path"], zip_file_name)
|
|
# 'v' letter was swallowed by github, so we need to substring it from the 2nd letter
|
|
if zip_config["version"][0] == 'v':
|
|
extra_folder_name = zip_config["repo_name"] + '-' + zip_config["version"][1:]
|
|
else:
|
|
extra_folder_name = zip_config["repo_name"] + '-' + zip_config["version"]
|
|
extra_folder_path = os.path.join(self.main_repo_abspath, extra_folder_name)
|
|
extra_folders.append(extra_folder_path)
|
|
extra_file_paths = self.unpack_zipfile(zip_file_path, self.main_repo_abspath)
|
|
|
|
key_move_dirs = "move_dirs"
|
|
for file_path in extra_file_paths:
|
|
if file_path.find(extra_folder_path) == -1:
|
|
raise Exception("Couldn't find extra folder path (%s) in (%s)!" % (extra_folder_path, file_path))
|
|
|
|
path_in_zip = extra_to_zip_file + file_path[(len(extra_folder_path)):]
|
|
if key_move_dirs in zip_config:
|
|
move_dirs = zip_config[key_move_dirs]
|
|
related_path = os.path.relpath(file_path, extra_folder_path)
|
|
temp_rel_path = related_path.replace('\\', '/')
|
|
for move_dir in move_dirs:
|
|
if temp_rel_path.startswith(move_dir):
|
|
move_to_dir = move_dirs[move_dir]
|
|
path_in_zip = os.path.join(move_to_dir, related_path)
|
|
break
|
|
|
|
try:
|
|
add(file_path, path_in_zip)
|
|
except:
|
|
print('add %s failed.' % file_path)
|
|
pass
|
|
|
|
key_extra_dirs = "extra_dirs"
|
|
if key_extra_dirs in config_data:
|
|
for extra_dir in config_data[key_extra_dirs]:
|
|
dir_path = path.join(self.main_repo_abspath, extra_dir)
|
|
list_dirs = os.walk(dir_path)
|
|
for root,dirs,files in list_dirs:
|
|
for f in files:
|
|
file_path = path.join(root,f)
|
|
path_in_zip = file_path[(len(self.main_repo_abspath)+1):]
|
|
try:
|
|
add(file_path, path_in_zip)
|
|
except:
|
|
print('add %s failed.' % file_path)
|
|
pass
|
|
|
|
if not dry_run:
|
|
archive.close()
|
|
|
|
for extra_folder in extra_folders:
|
|
if os.path.exists(extra_folder):
|
|
shutil.rmtree(extra_folder)
|
|
|
|
|
|
def get_path_components(self, repo_abspath, abspath):
|
|
"""
|
|
Splits given abspath into components until repo_abspath is reached.
|
|
|
|
E.g. if repo_abspath is '/Documents/Hobby/ParaView/' and abspath is
|
|
'/Documents/Hobby/ParaView/Catalyst/Editions/Base/', function will return:
|
|
['.', 'Catalyst', 'Editions', 'Base']
|
|
|
|
First element is always '.' (concrete symbol depends on OS).
|
|
|
|
@type repo_abspath: string
|
|
@param repo_abspath: Absolute path to the git repository.
|
|
|
|
@type abspath: string
|
|
@param abspath: Absolute path to within repo_abspath.
|
|
|
|
@rtype: list
|
|
@return: List of path components.
|
|
"""
|
|
components = []
|
|
|
|
if os_is_win32():
|
|
abspath = os.path.normpath(abspath)
|
|
repo_abspath = os.path.normpath(repo_abspath)
|
|
while abspath != repo_abspath:
|
|
abspath, tail = path.split(abspath)
|
|
|
|
if len(tail):
|
|
components.insert(0, tail)
|
|
else:
|
|
while not path.samefile(abspath, repo_abspath):
|
|
abspath, tail = path.split(abspath)
|
|
|
|
if len(tail):
|
|
components.insert(0, tail)
|
|
|
|
components.insert(0, path.relpath(repo_abspath, repo_abspath))
|
|
return components
|
|
|
|
def get_exclude_patterns(self, repo_abspath, repo_file_paths):
|
|
"""
|
|
Returns exclude patterns for a given repo. It looks for .gitattributes files in repo_file_paths.
|
|
|
|
Resulting dictionary will contain exclude patterns per path (relative to the repo_abspath).
|
|
E.g. {('.', 'Catalyst', 'Editions', 'Base'), ['Foo*', '*Bar']}
|
|
|
|
@type repo_abspath: string
|
|
@param repo_abspath: Absolute path to the git repository.
|
|
|
|
@type repo_file_paths: list
|
|
@param repo_file_paths: List of paths relative to the repo_abspath that are under git control.
|
|
|
|
@rtype: dict
|
|
@return: Dictionary representing exclude patterns.
|
|
Keys are tuples of strings. Values are lists of strings.
|
|
Returns None if self.exclude is not set.
|
|
"""
|
|
if not self.exclude:
|
|
return None
|
|
|
|
def read_attributes(attributes_abspath):
|
|
patterns = []
|
|
if path.isfile(attributes_abspath):
|
|
attributes = open(attributes_abspath, 'r').readlines()
|
|
patterns = []
|
|
for line in attributes:
|
|
tokens = line.strip().split()
|
|
if "export-ignore" in tokens[1:]:
|
|
patterns.append(tokens[0])
|
|
return patterns
|
|
|
|
exclude_patterns = {(): []}
|
|
|
|
# There may be no gitattributes.
|
|
try:
|
|
global_attributes_abspath = self.read_shell("git config --get core.attributesfile", repo_abspath).rstrip()
|
|
exclude_patterns[()] = read_attributes(global_attributes_abspath)
|
|
except:
|
|
# And valid to not have them.
|
|
pass
|
|
|
|
for attributes_abspath in [path.join(repo_abspath, f) for f in repo_file_paths if f.endswith(".gitattributes")]:
|
|
# Each .gitattributes affects only files within its directory.
|
|
key = tuple(self.get_path_components(repo_abspath, path.dirname(attributes_abspath)))
|
|
exclude_patterns[key] = read_attributes(attributes_abspath)
|
|
|
|
local_attributes_abspath = path.join(repo_abspath, ".git", "info", "attributes")
|
|
key = tuple(self.get_path_components(repo_abspath, repo_abspath))
|
|
|
|
if key in exclude_patterns:
|
|
exclude_patterns[key].extend(read_attributes(local_attributes_abspath))
|
|
else:
|
|
exclude_patterns[key] = read_attributes(local_attributes_abspath)
|
|
|
|
return exclude_patterns
|
|
|
|
def is_file_excluded(self, repo_abspath, repo_file_path, exclude_patterns):
|
|
"""
|
|
Checks whether file at a given path is excluded.
|
|
|
|
@type repo_abspath: string
|
|
@param repo_abspath: Absolute path to the git repository.
|
|
|
|
@type repo_file_path: string
|
|
@param repo_file_path: Path to a file within repo_abspath.
|
|
|
|
@type exclude_patterns: dict
|
|
@param exclude_patterns: Exclude patterns with format specified for get_exclude_patterns.
|
|
|
|
@rtype: bool
|
|
@return: True if file should be excluded. Otherwise False.
|
|
"""
|
|
if exclude_patterns is None or not len(exclude_patterns):
|
|
return False
|
|
|
|
from fnmatch import fnmatch
|
|
|
|
file_name = path.basename(repo_file_path)
|
|
components = self.get_path_components(repo_abspath, path.join(repo_abspath, path.dirname(repo_file_path)))
|
|
|
|
is_excluded = False
|
|
# We should check all patterns specified in intermediate directories to the given file.
|
|
# At the end we should also check for the global patterns (key '()' or empty tuple).
|
|
while not is_excluded:
|
|
key = tuple(components)
|
|
if key in exclude_patterns:
|
|
patterns = exclude_patterns[key]
|
|
for p in patterns:
|
|
if fnmatch(file_name, p) or fnmatch(repo_file_path, p):
|
|
if self.verbose:
|
|
print("Exclude pattern matched {pattern}: {path}".format(pattern=p, path=repo_file_path))
|
|
is_excluded = True
|
|
|
|
if not len(components):
|
|
break
|
|
|
|
components.pop()
|
|
|
|
return is_excluded
|
|
|
|
def list_files(self, repo_path=''):
|
|
"""
|
|
An iterator method that yields a file path relative to main_repo_abspath
|
|
for each file that should be included in the archive.
|
|
Skips those that match the exclusion patterns found in
|
|
any discovered .gitattributes files along the way.
|
|
|
|
Recurs into submodules as well.
|
|
|
|
@type repo_path: string
|
|
@param repo_path: Path to the git submodule repository within the main git repository.
|
|
|
|
@rtype: iterator
|
|
@return: Iterator to traverse files under git control relative to main_repo_abspath.
|
|
"""
|
|
repo_abspath = path.join(self.main_repo_abspath, repo_path)
|
|
repo_file_paths = self.read_git_shell("git ls-files --cached --full-name --no-empty-directory", repo_abspath).splitlines()
|
|
exclude_patterns = self.get_exclude_patterns(repo_abspath, repo_file_paths)
|
|
|
|
for repo_file_path in repo_file_paths:
|
|
# Git puts path in quotes if file path has unicode characters.
|
|
repo_file_path = repo_file_path.strip('"') # file path relative to current repo
|
|
file_name = path.basename(repo_file_path)
|
|
|
|
# The symbolic link propertie is lost after extract the zip file
|
|
# Loop over files in the link dir and add them to file list
|
|
absfilepath = path.join(repo_abspath, repo_file_path)
|
|
if path.islink(absfilepath):
|
|
if path.isdir(absfilepath):
|
|
list_dirs = os.walk(absfilepath)
|
|
for root,dirs,files in list_dirs:
|
|
for file in files:
|
|
main_repo_file_path = os.path.relpath(path.join(root, file), self.main_repo_abspath)
|
|
yield main_repo_file_path
|
|
continue
|
|
# Only list symlinks and files that don't start with git.
|
|
elif path.isdir(repo_file_path):
|
|
continue
|
|
|
|
main_repo_file_path = path.join(repo_path, repo_file_path) # file path relative to the main repo
|
|
|
|
if self.is_file_excluded(repo_abspath, repo_file_path, exclude_patterns):
|
|
continue
|
|
|
|
# Yield both repo_file_path and main_repo_file_path to preserve structure of the repo.
|
|
yield main_repo_file_path
|
|
|
|
if self.force_sub:
|
|
self.run_shell("git submodule init", repo_abspath)
|
|
self.run_shell("git submodule update", repo_abspath)
|
|
|
|
# List files of every submodule.
|
|
for submodule_path in self.read_shell("git submodule --quiet foreach 'pwd'", repo_abspath).splitlines():
|
|
# In order to get output path we need to exclude repository path from submodule_path.
|
|
submodule_path = path.relpath(submodule_path, self.main_repo_abspath)
|
|
for file_path in self.list_files(submodule_path):
|
|
yield file_path
|
|
|
|
@staticmethod
|
|
def run_shell(cmd, cwd=None):
|
|
"""
|
|
Runs shell command.
|
|
|
|
@type cmd: string
|
|
@param cmd: Command to be executed.
|
|
|
|
@type cwd: string
|
|
@param cwd: Working directory.
|
|
|
|
@rtype: int
|
|
@return: Return code of the command.
|
|
|
|
@raise CalledProcessError: Raises exception if return code of the command is non-zero.
|
|
"""
|
|
p = Popen(cmd, shell=True, cwd=cwd)
|
|
p.wait()
|
|
|
|
if p.returncode:
|
|
raise CalledProcessError(returncode=p.returncode, cmd=cmd)
|
|
|
|
return p.returncode
|
|
|
|
@staticmethod
|
|
def read_shell(cmd, cwd=None, encoding='utf-8'):
|
|
"""
|
|
Runs shell command and reads output.
|
|
|
|
@type cmd: string
|
|
@param cmd: Command to be executed.
|
|
|
|
@type cwd: string
|
|
@param cwd: Working directory.
|
|
|
|
@type encoding: string
|
|
@param encoding: Encoding used to decode bytes returned by Popen into string.
|
|
|
|
@rtype: string
|
|
@return: Output of the command.
|
|
|
|
@raise CalledProcessError: Raises exception if return code of the command is non-zero.
|
|
"""
|
|
p = Popen(cmd, shell=True, stdout=PIPE, cwd=cwd)
|
|
output, _ = p.communicate()
|
|
output = output.decode(encoding)
|
|
|
|
if p.returncode:
|
|
raise CalledProcessError(returncode=p.returncode, cmd=cmd, output=output)
|
|
|
|
return output
|
|
|
|
@staticmethod
|
|
def read_git_shell(cmd, cwd=None):
|
|
"""
|
|
Runs git shell command, reads output and decodes it into unicode string
|
|
|
|
@type cmd: string
|
|
@param cmd: Command to be executed.
|
|
|
|
@type cwd: string
|
|
@param cwd: Working directory.
|
|
|
|
@rtype: string
|
|
@return: Output of the command.
|
|
|
|
@raise CalledProcessError: Raises exception if return code of the command is non-zero.
|
|
"""
|
|
p = Popen(cmd, shell=True, stdout=PIPE, cwd=cwd)
|
|
output, _ = p.communicate()
|
|
output = output.decode('unicode_escape').encode('raw_unicode_escape').decode('utf-8')
|
|
|
|
if p.returncode:
|
|
raise CalledProcessError(returncode=p.returncode, cmd=cmd, output=output)
|
|
|
|
return output
|
|
|
|
|
|
if __name__ == '__main__':
|
|
from optparse import OptionParser
|
|
|
|
parser = OptionParser(usage="usage: %prog [-v] [--prefix PREFIX] [--no-exclude] [--force-submodules] [--dry-run] OUTPUT_FILE",
|
|
version="%prog {version}".format(version=__version__))
|
|
|
|
parser.add_option('--prefix',
|
|
type='string',
|
|
dest='prefix',
|
|
default='',
|
|
help="Prepend PREFIX to each filename in the archive. OUTPUT_FILE name is used by default to avoid tarbomb.")
|
|
|
|
parser.add_option('-v', '--verbose',
|
|
action='store_true',
|
|
dest='verbose',
|
|
help='Enable verbose mode.')
|
|
|
|
parser.add_option('--no-exclude',
|
|
action='store_false',
|
|
dest='exclude',
|
|
default=True,
|
|
help="Don't read .gitattributes files for patterns containing export-ignore attrib.")
|
|
|
|
parser.add_option('--force-submodules',
|
|
action='store_true',
|
|
dest='force_sub',
|
|
help="Force a git submodule init && git submodule update at each level before iterating submodules.")
|
|
|
|
parser.add_option('--extra',
|
|
action='append',
|
|
dest='extra',
|
|
default=[],
|
|
help="Any additional files to include in the archive.")
|
|
parser.add_option('--dry-run',
|
|
action='store_true',
|
|
dest='dry_run',
|
|
help="Don't actually archive anything, just show what would be done.")
|
|
|
|
options, args = parser.parse_args()
|
|
|
|
if len(args) != 1:
|
|
parser.error("You must specify exactly one output file")
|
|
|
|
output_file_path = args[0]
|
|
|
|
if path.isdir(output_file_path):
|
|
parser.error("You cannot use directory as output")
|
|
|
|
# avoid tarbomb
|
|
if options.prefix:
|
|
options.prefix = path.join(options.prefix, '')
|
|
else:
|
|
import re
|
|
|
|
output_name = path.basename(output_file_path)
|
|
output_name = re.sub('(\.zip|\.tar|\.tgz|\.gz|\.bz2|\.tar\.gz|\.tar\.bz2)$', '', output_name) or "Archive"
|
|
options.prefix = path.join(output_name, '')
|
|
|
|
try:
|
|
archiver = GitArchiver(options.prefix,
|
|
options.verbose,
|
|
options.exclude,
|
|
options.force_sub,
|
|
options.extra)
|
|
archiver.create(output_file_path, options.dry_run)
|
|
except Exception as e:
|
|
traceback.print_exc()
|
|
parser.exit(2, "{exception}\n".format(exception=e))
|
|
|
|
sys.exit(0)
|