def main():
"""Validate the configuration for one or more repositories."""
# pylint:disable=too-many-branches
desc = _("Report on the validity of a repository configuration.")
parser = p4gf_util.create_arg_parser(desc)
parser.add_argument('-a', '--all', action='store_true',
help=_('process all known Git Fusion repositories'))
parser.add_argument(NTR('repos'), metavar=NTR('repo'), nargs='*',
help=_('name of repository or file to be validated'))
args = parser.parse_args()
# Check that either --all, or 'repos' was specified, but not both.
if not args.all and len(args.repos) == 0:
sys.stderr.write(_('Missing repo names; try adding --all option.\n'))
sys.exit(2)
if args.all and len(args.repos) > 0:
sys.stderr.write(_('Ambiguous arguments. Choose --all or a repo name.\n'))
sys.exit(2)
with p4gf_create_p4.Closer():
p4 = p4gf_create_p4.create_p4_temp_client()
if not p4:
sys.exit(2)
# Sanity check the connection (e.g. user logged in?) before proceeding.
try:
p4.fetch_client()
except P4.P4Exception as e:
sys.stderr.write(_('P4 exception occurred: {exception}').format(exception=e))
sys.exit(1)
p4gf_branch.init_case_handling(p4)
if args.all:
repos = p4gf_util.repo_config_list(p4)
if len(repos) == 0:
print(_('No Git Fusion repositories found, nothing to do.'))
sys.exit(0)
else:
repos = args.repos
for repo in repos:
if os.path.exists(repo):
print(_("Processing file {repo_name}...").format(repo_name=repo))
try:
config = p4gf_config.RepoConfig.from_local_file(repo, p4, repo)
except p4gf_config.ConfigLoadError as e:
sys.stderr.write("{}\n", e)
except p4gf_config.ConfigParseError as e:
sys.stderr.write("{}\n", e)
else:
repo_name = p4gf_translate.TranslateReponame.git_to_repo(repo)
print(_("Processing repository {repo_name}...").format(repo_name=repo_name))
try:
config = p4gf_config.RepoConfig.from_depot_file(repo_name, p4)
except p4gf_config.ConfigLoadError as err:
sys.stderr.write("{}\n", err)
if Validator(config, p4).is_valid():
print(_("ok"))
print("")
def create_context(args):
"""Create a p4gf_context for accessing Git Fusion data."""
ctx = p4gf_context.create_context(args.repo)
ctx.connect_cli(LOG)
p4gf_proc.init()
p4gf_branch.init_case_handling(ctx.p4gf)
if DEBUG:
print(_("create_context: ctx.p4.port='{}' ctx.p4.user='******' .").format(
ctx.p4.port, ctx.p4.user))
return (ctx.p4gf, ctx)
def main():
"""Either do the work now or fork a process to do it later."""
for h in ['-?', '-h', '--help']:
if h in sys.argv:
print(_('Git Fusion pre-receive hook.'))
return 2
p4gf_version_3.print_and_exit_if_argv()
p4gf_branch.init_case_handling()
prl = PreReceiveTupleLists.from_stdin(sys.stdin)
# Preflight rejects the push by raising an exception, which is handled
# in the logging code by printing the message to stderr.
with Timer('pre-receive'):
return PreflightHook('pre-receive preflight', prl).do_it()
def forked_execed_main():
"""The main that runs after double-fork + exec."""
LOG.debug('forked_execed_main() beginning copy-to-p4')
try:
p4gf_branch.init_case_handling()
ec = CopyOnlyHook('post-receive').do_it()
LOG.debug('forked_execed_main() returned %s', ec)
p4gf_tempfile.prune_old_files()
return ec
finally:
# The @atexit.register does not seem to fire for double-forked
# Python processes, so call the profiler report explicitly.
Report()
LOG.debug('forked_execed_main() completed')
def main():
"""Set up repo for a view."""
p4gf_util.has_server_id_or_exit()
args = _parse_argv()
p4gf_version_3.log_version_extended(include_checksum=True)
log_l10n()
if args.enablemismatchedrhs:
# Git Fusion should never modify the customer's config file, and
# use of this option resulted in the config file losing all of the
# comments and formatting the customer had put in place.
sys.stderr.write(
_('The --enablemismatchedrhs option is deprecated,'
' please use enable-mismatched-rhs config file'
' option instead.\n'))
sys.exit(1)
repo_name_p4client = None
if args.p4client:
repo_name_p4client = p4gf_util.argv_to_repo_name(args.p4client)
repo_name = _argv_to_repo_name(args.repo_name)
p4gf_util.reset_git_enviro()
p4 = p4gf_create_p4.create_p4_temp_client()
if not p4:
raise RuntimeError(_('error connecting to Perforce'))
LOG.debug("connected to P4 at %s", p4.port)
p4gf_proc.init()
try:
with ExitStack() as stack:
stack.enter_context(p4gf_create_p4.Closer())
p4gf_version_3.version_check()
p4gf_branch.init_case_handling(p4)
repo_lock = p4gf_lock.RepoLock(p4, repo_name)
stack.enter_context(repo_lock)
ctx = p4gf_context.create_context(repo_name)
ctx.p4gf = p4
ctx.repo_lock = repo_lock
initer = InitRepo(p4, repo_lock).set_repo_name(repo_name)
initer.context = ctx
initer.set_config_file_path(args.config)
initer.set_charset(args.charset)
initer.set_noclone(args.noclone)
initer.set_start(args.start)
stack.enter_context(ctx)
initer.full_init(repo_name_p4client)
except P4.P4Exception as e:
_print_stderr(_('Error occurred: {exception}').format(exception=e))
sys.exit(1)
def main():
"""Do the thing."""
args = parse_argv()
ctx = p4gf_context.create_context(args.repo)
ctx.create_config_if_missing(False)
ctx.config.p4user = args.p4user
ctx.config.p4port = args.p4port
ctx.connect_cli(LOG)
p4gf_proc.init()
p4gf_branch.init_case_handling(ctx.p4gf)
rollback = Rollback( ctx = ctx
, change_num = args.change_num
, is_preview = not args.execute
, is_obliterate = args.obliterate )
rollback.rollback()
def create_ctx(self):
"""
Connect to Perforce using environment.
"""
p4 = p4gf_create_p4.create_p4_temp_client(port=self.p4port,
user=self.p4user)
p4gf_branch.init_case_handling(p4)
self.repo_name = 'estimate_repo_size_' + p4gf_util.uuid()
self.repo_config = p4gf_config.RepoConfig.from_local_files(
self.repo_name, p4, self.config_path, None)
ctx = p4gf_context.create_context(self.repo_name)
ctx.p4gf = p4
ctx.repo_config = self.repo_config
ctx.config.p4user = self.p4user
ctx.config.p4port = self.p4port
ctx.connect()
return ctx
def main():
"""Do the thing."""
args = parse_argv()
ctx = p4gf_context.create_context(args.repo_name)
ctx.config.p4user = args.p4user
ctx.config.p4port = args.p4port
ctx.connect_cli(log=LOG)
p4gf_branch.init_case_handling(ctx.p4)
rc = RepoCompareSingle(ctx, args)
for change_num in args.change_num:
rc.compare_change_num(change_num)
rc.report_summary()
if rc.how_ct:
sys.exit(1)
def __init__(self, port, user, *, cont=False,
keep=False, force=False, stdout=False, doreport=False, quiet=False):
self.starttime = time.time()
self.cont = cont
self.keep = keep
self.force = force
self.stdout = stdout
self.doreport = doreport
self.quiet = quiet
self.root_path = os.getcwd()
self.report_file = None
if not self.stdout:
self.report_file = os.path.abspath('p4gf_gc_unreachables')
self.dir_abspath = os.path.abspath(".p4gf_gc")
self.git_dir_abspath = os.path.join(self.dir_abspath, "git")
self.p4_dir_abspath = os.path.join(self.dir_abspath, "p4")
self.git_dir_objects = os.path.join(self.git_dir_abspath, "objects")
self.sql_dir_abspath = os.path.join(self.dir_abspath, "sql")
self.sql_db_abspath = os.path.join(self.dir_abspath, "sql", "db.sqlite")
if self.cont:
self.keep = True # force keep for cont
else:
if self.force:
self.rmdir()
self.create_dir()
self.db = None # pylint:disable=invalid-name
self.seen_trees = set()
p4gf_ensure_dir.ensure_dir(self.p4_dir_abspath)
os.chdir(self.p4_dir_abspath)
os.environ['PWD']=self.p4_dir_abspath
self.p4 = p4gf_create_p4.create_p4_temp_client(port = port,
user=user)
p4gf_branch.init_case_handling(self.p4)
self.report_progress_msg = ''
self._uncommitted_set_ct = 0
self._uncommitted_set_max = 1000
self.git_repo = None
self.max_rows_per_table = 500000
self.sync_counts = { TREES : 0,
COMMITS : 0}
self.table_type_counts = { TREES : 0,
BLOBS : 0,
DELETED_TREES : 0,
DELETED_BLOBS : 0,
DELETED_COMMITS : 0,
TREES_FROM_COMMITS : 0,
MISSING_TREES_FROM_COMMITS : 0 }
self.table_names = { TREES : [],
BLOBS : [],
DELETED_TREES : [],
DELETED_BLOBS : [],
DELETED_COMMITS : [],
TREES_FROM_COMMITS : [],
MISSING_TREES_FROM_COMMITS : [] }
self.fd = None # pylint:disable=invalid-name
self.debug = LOG.isEnabledFor(logging.DEBUG)
self.debug2 = LOG.isEnabledFor(logging.DEBUG2)
self.debug3 = LOG.isEnabledFor(logging.DEBUG3)
self.status = None
self.eta = None
self.tree_recursion_depth = 0
self.git_dir = None
def main():
"""Process command line arguments and call functions to do the real
work of cleaning up the Git mirror and Perforce workspaces.
"""
# pylint:disable=too-many-branches, too-many-statements
log_l10n()
# Set up argument parsing.
desc = _("""Deletes Git Fusion repositories and workspaces. When you
include the -a or --all option, Git Fusion finds and deletes the following
for all repos on the current server disregarding specified views:
1) All git-fusion-view clients. 2) Client git-fusion--p4 workspace files.
3) Objects in //.git-fusion/objects/...
""")
epilog = _("""It is recommended to run 'p4gf_delete_repo.py' without
the '-y' flag to preview changes that will be made to the depot before
using the '-y' flag for permanent removal. Use -a or --all to permanently
delete all repo data for all repos on the Perforce server; be aware that
this may take some time, depending on the number and size of the objects.
Use -N, --no-obliterate to quickly delete most of the repo's data and
continue working. This minimizes the impact to server performance.
""")
parser = p4gf_util.create_arg_parser(desc, epilog=epilog)
parser.add_argument(
'-a',
'--all',
action='store_true',
help=_('remove all known Git mirrors on the current server'))
parser.add_argument('-y',
'--delete',
action='store_true',
help=_('perform the deletion'))
parser.add_argument('-v',
'--verbose',
action='store_true',
help=_('print details of deletion process'))
parser.add_argument(
'-N',
'--no-obliterate',
action='store_true',
help=_('with the --all option, do not obliterate object cache'))
parser.add_argument(NTR('views'),
metavar=NTR('view'),
nargs='*',
help=_('name of view to be deleted'))
args = parser.parse_args()
p4gf_util.has_server_id_or_exit()
# Check that either --all, or 'views' was specified.
if not args.all and len(args.views) == 0:
sys.stderr.write(_('Missing view names; try adding --all option.\n'))
sys.exit(2)
if args.all and len(args.views) > 0:
sys.stderr.write(
_('Ambiguous arguments. Choose --all or a view name.\n'))
sys.exit(2)
# Check that --no-obliterate occurs only with --all
if not args.all and args.no_obliterate:
sys.stderr.write(
_('--no-obliterate permitted only with the --all option.\n'))
sys.exit(2)
with p4gf_create_p4.Closer():
p4 = p4gf_create_p4.create_p4_temp_client()
if not p4:
return 2
# Sanity check the connection (e.g. user logged in?) before proceeding.
p4gf_branch.init_case_handling(p4)
try:
p4.fetch_client()
except P4.P4Exception as e:
sys.stderr.write(
_('P4 exception occurred: {exception}').format(exception=e))
sys.exit(1)
metrics = DeletionMetrics()
if args.all:
try:
if p4gf_const.READ_ONLY:
delete_all_local(args, p4, metrics)
else:
delete_all(args, p4, metrics)
except (p4gf_lock.LockBusy, P4.P4Exception) as e:
sys.stderr.write("{exception}\n".format(exception=e))
sys.exit(1)
else:
# Delete the client(s) for the named view(s).
for git_view in args.views:
repo_name = p4gf_translate.TranslateReponame.git_to_repo(
git_view)
client_name = p4gf_util.repo_to_client_name(repo_name)
try:
if p4gf_const.READ_ONLY:
delete_client_local(args, p4, client_name, metrics)
else:
with p4gf_lock.RepoLock(p4, repo_name, blocking=False):
delete_client(args, p4, client_name, metrics)
except (p4gf_lock.LockBusy, P4.P4Exception) as e:
sys.stderr.write("{exception}\n".format(exception=e))
sys.exit(1)
if not args.delete:
print(_('This was report mode. Use -y to make changes.'))
else:
print(
_('Deleted {num_files:d} files, {num_groups:d} groups, '
'{num_clients:d} clients, and {num_keys:d} p4keys.').format(
num_files=metrics.files,
num_groups=metrics.groups,
num_clients=metrics.clients,
num_keys=metrics.p4keys))
if args.all:
print(_('Successfully deleted all repos\n'))
else:
print(
_('Successfully deleted repos:\n{repos}').format(
repos="\n".join(args.views)))