def _wsgi_app(environ, start_response):
"""WSGI application to process the incoming Git client request.
This is nearly equivalent to p4gf_auth_server.main() with the exception of
input validation and error handling.
"""
p4gf_version_3.log_version_extended()
p4gf_util.log_environ(LOG, environ, "WSGI")
p4gf_version_3.version_check()
LOG.info("Processing LFS/HTTP request, pid=%s", os.getpid())
result = p4gf_http_common.check_file_encoding(start_response)
if result:
return result
_response = functools.partial(p4gf_http_common.send_error_response,
start_response)
try:
input_file = p4gf_http_common.read_request_data(environ)
server = LargeFileHttpServer(environ, start_response, input_file)
try:
server.process()
except p4gf_server_common.BadRequestException as e:
return _response(http.client.BAD_REQUEST, e)
except p4gf_server_common.PerforceConnectionFailed:
return _response(http.client.INTERNAL_SERVER_ERROR,
_("Perforce connection failed\n"))
except p4gf_server_common.CommandError as ce:
return _response(http.client.FORBIDDEN, ce)
except p4gf_server_common.ReadOnlyInstanceException as roie:
return _response(http.client.FORBIDDEN, roie)
except RuntimeError as rerr:
return _response(http.client.INTERNAL_SERVER_ERROR, rerr)
finally:
p4gf_http_common.rm_file_quietly(input_file)
return []
def main():
"""Create Perforce user and client for Git Fusion."""
p4gf_version_3.log_version_extended(include_checksum=True)
try:
log_l10n()
p4gf_version_3.version_check()
except Exception as e: # pylint: disable=broad-except
sys.stderr.write(e.args[0] + '\n')
sys.exit(1)
# To fetch the object client below we need to ensure there is a server
# ID available on this system, and since we require that anyway, may as
# well check it now, when we need it.
p4gf_util.has_server_id_or_exit()
with p4gf_create_p4.Closer():
p4 = p4gf_create_p4.create_p4_temp_client()
if not p4:
return 2
Verbosity.report(Verbosity.INFO, "P4PORT : {}".format(p4.port))
Verbosity.report(Verbosity.INFO, "P4USER : {}".format(p4.user))
p4gf_util.reset_git_enviro()
p4gf_proc.init()
try:
init(p4)
remove_old_temp_and_repo_clients(p4)
except PermissionError:
LOG.exception("unable to initialize Git Fusion")
sys.stderr.write(_("File permissions error, please check ownership"
" and mode of ~/.git-fusion directory.\n"))
sys.exit(os.EX_NOPERM)
return 0
def run_main():
"""Some initial logging, then run main()."""
# Ensure any errors occurring in the setup are sent to stderr, while the
# code below directs them to stderr once rather than twice.
try:
with p4gf_log.ExceptionLogger(squelch=False, write_to_stderr_=True):
p4gf_version_3.log_version_extended()
log_l10n()
p4gf_version_3.version_check()
except: # pylint: disable=bare-except
# Cannot continue if above code failed.
sys.exit(1)
# main() already writes errors to stderr, so don't let logger do it again
p4gf_log.run_with_exception_logger(main_ignores, write_to_stderr=False)
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."""
# pylint: disable=too-many-statements, too-many-branches
try:
log_l10n()
parse_argv()
global P4PORT, P4USER, P4CLIENT
needs_exit = False
if not P4PORT and "P4PORT" not in os.environ:
Verbosity.report(
Verbosity.INFO,
_('P4PORT is neither set in the environment nor passed as an option.'))
needs_exit = True
if not P4USER and "P4USER" not in os.environ:
Verbosity.report(
Verbosity.INFO,
_('P4USER is neither set in the environment nor passed as an option.'))
needs_exit = True
# Check that a pre-existing P4GF_ENV config file P4PORT conflicts with the --port option
if p4gf_const.P4GF_ENV and not Create_P4GF_CONFIG and P4PORT:
if P4PORT != os.environ['P4PORT']:
Verbosity.report(
Verbosity.INFO,
_("conflicting P4PORT in args: {p4port} and "
"P4GF_ENV {env} : P4PORT = {env_p4port}. Stopping.")
.format(p4port=P4PORT,
env=p4gf_const.P4GF_ENV,
env_p4port=os.environ['P4PORT']))
needs_exit = True
else:
Verbosity.report(
Verbosity.INFO,
_("P4PORT argument is identically configured in {0}. Proceeding.")
.format(p4gf_const.P4GF_ENV))
if needs_exit:
sys.exit(1)
p4gf_version_3.version_check()
# Connect.
global p4
if not P4USER:
P4USER = os.environ['P4USER']
# if needed, set a bogus client name so that the default to hostname will not be used.
if "P4CLIENT" not in os.environ:
P4CLIENT = 'GF-' + str(uuid.uuid4().hex).lower()[-10:]
os.environ['P4CLIENT'] = P4CLIENT
else:
P4CLIENT = os.environ['P4CLIENT']
p4 = p4gf_create_p4.create_p4(port=P4PORT, user=P4USER, client=P4CLIENT)
if not p4:
raise RuntimeError(_("Failed to connect to P4."))
P4PORT = p4.port
P4USER = p4.user
check_and_create_default_p4gf_env_config()
if SHOW_IDS:
show_all_server_ids()
sys.exit(0)
Verbosity.report(Verbosity.INFO, "P4PORT : {}".format(p4.port))
Verbosity.report(Verbosity.INFO, "P4USER : {}".format(p4.user))
# Require that we have super permission.
# Might as well keep the result in case we need to write a new protect
# table later. Saves a 'p4 protect -o' trip to the server
protect_lines = fetch_protect()
if P4_PASSWD and p4_security_level() > 0 and not strong_passwd(P4_PASSWD):
Verbosity.report(
Verbosity.ERROR,
_("This Perforce server requires a strong password: >= 8 characters and"))
Verbosity.report(
Verbosity.ERROR,
_("with mixed case or contain non alphabetic characters."))
sys.exit(1)
ensure_server_id()
ensure_group()
ensure_users()
ensure_depot()
ensure_protect(protect_lines)
ensure_protects_configurable()
set_proxy_protects_key()
check_triggers()
initialize_all_gf_reviews()
except Exception as e: # pylint: disable=broad-except
sys.stderr.write(str(e) + '\n')
p4gf_create_p4.close_all()
sys.exit(1)
def _wsgi_app(environ, start_response):
"""WSGI application to process the incoming Git client request.
This is nearly equivalent to p4gf_auth_server.main() with the exception of
input validation and error handling.
"""
# pylint: disable=too-many-branches
p4gf_version_3.log_version_extended()
p4gf_util.log_environ(LOG, environ, "WSGI")
p4gf_version_3.version_check()
LOG.info("Processing HTTP request, pid=%s", os.getpid())
result = p4gf_http_common.check_file_encoding(start_response)
if result:
return result
try:
input_file = p4gf_http_common.read_request_data(environ)
with OutputSink() as sink:
_response = functools.partial(send_error_response, sink,
start_response)
# pylint 1.2.0 complains about http.server due to assignment in GitFusionRequestHandler
# pylint 1.3.0 handles this fine with just the disable in GitFusionRequestHandler
# pylint:disable=attribute-defined-outside-init
server = GitHttpServer(environ, input_file)
try:
server.process()
except p4gf_http_common.HttpException as e:
return _response(e.code, e.msg)
except p4gf_server_common.BadRequestException as e:
return _response(http.client.BAD_REQUEST, e)
except p4gf_server_common.PerforceConnectionFailed:
return _response(http.client.INTERNAL_SERVER_ERROR,
_("Perforce connection failed\n"))
except p4gf_server_common.SpecialCommandException:
user_agent = environ.get('HTTP_USER_AGENT')
if user_agent and not user_agent.startswith('git'):
return _response(http.client.OK, sink.readall())
else:
return _response(http.client.NOT_FOUND, sink.readall())
except p4gf_server_common.CommandError as ce:
return _response(http.client.FORBIDDEN, ce)
except p4gf_server_common.RepoNotFoundException as e:
return _response(http.client.NOT_FOUND, e)
except p4gf_server_common.RepoInitFailedException:
return _response(http.client.INTERNAL_SERVER_ERROR,
_("Repository initialization failed\n"))
except p4gf_server_common.MissingSubmoduleImportUrlException:
msg = _(
'Stream imports require a valid http-url be configured.'
' Contact your administrator.')
return _response(http.client.INTERNAL_SERVER_ERROR, msg)
except p4gf_atomic_lock.LockConflict as lc:
return _response(http.client.INTERNAL_SERVER_ERROR, lc)
except p4gf_server_common.ReadOnlyInstanceException as roie:
return _response(http.client.FORBIDDEN, roie)
except Exception as e: # pylint: disable=broad-except
return _response(http.client.INTERNAL_SERVER_ERROR, e)
return []
finally:
p4gf_http_common.rm_file_quietly(input_file)