passenger 4.0.60 → 5.0.0.beta1

data/packaging/debian/internal/publish/oss-binaries.phusionpassenger.com-fingerprint.txt

@@ -1 +0,0 @@
-8B:9F:2B:10:DA:56:F2:32:3C:E9:B1:92:A3:BC:42:7E:71:88:29:8D:1F:D5:AB:70:B0:EA:29:0B:0A:0F:22:F2

data/packaging/debian/internal/publish/packagecloud_fingerprint.txt

@@ -1 +0,0 @@
-72:19:76:11:9D:26:22:77:B0:19:8D:DF:51:A0:2B:53:56:48:05:0A:1D:A5:B4:40:E8:00:1D:2C:FE:94:27:B6

data/packaging/debian/internal/publish/passenger_website_fingerprint.txt

@@ -1 +0,0 @@
-DB:BC:CD:65:55:6C:98:BE:EB:5B:0C:5D:67:19:B8:22:63:A7:AD:BF:6F:F0:AC:0C:FA:FD:7C:90:57:B2:F8:DF

data/packaging/debian/internal/publish/preinit.sh

@@ -1,7 +0,0 @@
-#!/bin/bash
-set -e
-if [[ ! -e /work ]]; then
-	mkdir /work
-	chown app: /work
-fi
-exec "$@"

data/packaging/debian/internal/publish/rakefile_support.rb

@@ -1,183 +0,0 @@
-require_relative '../lib/distro_info'
-require 'net/http/persistent'
-require 'uri'
-require 'json'
-
-REPOSITORY = ENV['REPOSITORY']
-YANK       = ENV['YANK'] == 'true'
-YANK_ALL   = !YANK && ENV['YANK_ALL'] == 'true'
-SHOW_TASKS = ENV['SHOW_TASKS'] == 'true'
-SHOW_OVERVIEW_PERIODICALLY = ENV['SHOW_OVERVIEW_PERIODICALLY'] == 'true'
-
-def initialize_rakefile!
-  STDOUT.sync = true
-  STDERR.sync = true
-  Dir.chdir("/system/internal/publish")
-  Kernel.const_set(:DISTROS, infer_distros_info)
-  initialize_packagecloud!
-end
-
-def infer_distros_info
-  result = []
-  Dir["/output/*"].each do |path|
-    distro = File.basename(path)
-    if UBUNTU_DISTRIBUTIONS[distro]
-      result << ["ubuntu", distro]
-    elsif DEBIAN_DISTRIBUTIONS[distro]
-      result << ["debian", distro]
-    else
-      abort "Unknown distribution name: #{distro}"
-    end
-  end
-  result
-end
-
-def retry_at_most(task, max)
-  tries = 0
-  begin
-    tries += 1
-    yield
-  rescue TrackingTask::CommandError => e
-    if tries < max
-      task.log(Paint["*** Retrying command: #{tries + 1} of #{max}", :yellow])
-      sleep 0.5 + rand(0.5)
-      retry
-    else
-      raise e
-    end
-  end
-end
-
-def initialize_packagecloud!
-  if SHOW_TASKS
-    Kernel.const_set(:PACKAGECLOUD_YANK_ALL_TASKS, [])
-    Kernel.const_set(:PACKAGECLOUD_PACKAGE_NAMES, [])
-    Kernel.const_set(:PACKAGECLOUD_PACKAGE_URLS, [])
-  else
-    Kernel.const_set(:PACKAGECLOUD_TOKEN, File.read("/package_cloud_token.txt").strip)
-    path = File.expand_path("~/.packagecloud")
-    File.open(path, "w") do |f|
-      f.puts %Q({"url":"https://packagecloud.io", "token": "#{PACKAGECLOUD_TOKEN}"})
-      f.chmod(0600)
-    end
-
-    Kernel.const_set(:PACKAGECLOUD_HTTP, make_packagecloud_http)
-
-    if YANK_ALL
-      names, urls = get_packagecloud_package_urls
-      Kernel.const_set(:PACKAGECLOUD_YANK_ALL_TASKS, generate_yank_all_task_names(names))
-      Kernel.const_set(:PACKAGECLOUD_PACKAGE_NAMES, names)
-      Kernel.const_set(:PACKAGECLOUD_PACKAGE_URLS, urls)
-    else
-      Kernel.const_set(:PACKAGECLOUD_YANK_ALL_TASKS, [])
-      Kernel.const_set(:PACKAGECLOUD_PACKAGE_NAMES, [])
-      Kernel.const_set(:PACKAGECLOUD_PACKAGE_URLS, [])
-    end
-  end
-end
-
-def make_packagecloud_http
-  expected_fingerprint = File.read("/system/internal/publish/packagecloud_fingerprint.txt").strip
-
-  http = Net::HTTP::Persistent.new
-  http.verify_mode = OpenSSL::SSL::VERIFY_PEER
-  http.verify_callback = lambda do |preverify_ok, store_context|
-    if preverify_ok and store_context.error == 0
-      certificate = OpenSSL::X509::Certificate.new(store_context.chain[0])
-      fingerprint = Digest::SHA256.hexdigest(certificate.to_der).upcase.scan(/../).join(":")
-      if fingerprint == expected_fingerprint
-        true
-      else
-        abort "Fingerprint verification for #{host} failed.\n" +
-          "  Expected: #{expected_fingerprint}\n" +
-          "  Actual  : #{fingerprint}"
-        false
-      end
-    else
-      false
-    end
-  end
-
-  http
-end
-
-def get_packagecloud_package_urls
-  items = []
-  current_url = URI.parse("https://packagecloud.io/api/v1/repos/phusion/#{REPOSITORY}/packages.json?per_page=100")
-
-  while current_url
-    puts "Fetching #{current_url}"
-    request = Net::HTTP::Get.new(uri_path_and_query_string(current_url))
-    request.basic_auth(PACKAGECLOUD_TOKEN, "")
-    response = PACKAGECLOUD_HTTP.request(current_url, request)
-    if response.code != "200"
-      abort "Unable to query PackageCloud repository package list:\n" +
-        "URL   : #{current_url}\n" +
-        "Status: #{response.code}\n" +
-        "Body  : #{response.body}"
-    end
-
-    JSON.parse(response.body).each do |package|
-      next if package["type"] != "deb" && package["type"] != "dsc"
-      name = package["package_url"].sub(%r{^/api/v1/repos/phusion/#{REPOSITORY}/package/(deb|dsc)/}, "")
-      name.sub!(/\.el[0-9]+\.json$/, "")
-      name.gsub!("/", "-")
-      items << [name, "https://packagecloud.io#{package["package_url"]}"]
-    end
-
-    current_url = get_next_link_path(response["Link"])
-  end
-
-  items.sort! do |a, b|
-    a[0] <=> b[0]
-  end
-
-  names = []
-  urls  = []
-  items.each do |item|
-    names << item[0]
-    urls  << item[1]
-  end
-  [names, urls]
-end
-
-def generate_yank_all_task_names(names)
-  names.map do |name|
-    "yank:#{name}"
-  end
-end
-
-def get_next_link_path(header)
-  return nil if header.nil?
-
-  header.split(/, */).each do |part|
-    if part =~ /\A<(.+)>; *rel=\"(.+)\"/ && $2 == "next"
-      return URI.parse($1)
-    end
-  end
-
-  nil
-end
-
-def yank_package(task, distro_version, filename)
-  url = URI.parse("https://packagecloud.io/api/v1/repos/phusion/#{REPOSITORY}/#{distro_version}/#{filename}")
-  request = Net::HTTP::Delete.new(uri_path_and_query_string(url))
-  request.basic_auth(PACKAGECLOUD_TOKEN, "")
-  response = PACKAGECLOUD_HTTP.request(url, request)
-  if response.code != "200" && response.code != "404"
-    task.log "Unable to yank package #{filename}:"
-    task.log "URL   : #{url}"
-    task.log "Status: #{response.code}"
-    task.log "Body  : #{response.body}"
-    abort
-  end
-end
-
-def uri_path_and_query_string(uri)
-  result = uri.path
-  if uri.query
-    result += "?"
-    result << uri.query
-  end
-  result
-end

data/packaging/debian/internal/scripts/gpg_noninteractive/gpg

@@ -1,11 +0,0 @@
-#!/bin/bash
-# A wrapper around gpg that makes gpg non-interactive, and makes it
-# read a passphrase from the passphrase configuration file. To use
-# this wrapper, prepend the containing directory to PATH.
-
-set -e
-if [[ "$1" == "--version" ]]; then
-	exec /usr/bin/gpg --version
-else
-	exec /usr/bin/gpg --batch --passphrase-fd 3 "$@" 3</
-fi

data/packaging/debian/internal/scripts/initccache.sh

@@ -1,35 +0,0 @@
-#!/bin/bash
-# Initializes the pbuilder ccache directory with the proper permissions
-# (owned by '1234', which is probably some internal pbuilder user)
-# so that ccache doesn't create them with the wrong permissions (owned by root).
-
-set -e
-ROOTDIR=`dirname "$0"`
-ROOTDIR=`cd "$ROOTDIR/../.." && pwd`
-source "$ROOTDIR/internal/lib/library.sh"
-source "$ROOTDIR/internal/lib/distro_info.sh"
-
-SUBDIRS="0 1 2 3 4 5 6 7 8 9 a b c d e f tmp"
-
-for DISTRO in $DISTRIBUTIONS; do
-	DISTRO=`to_distro_codename "$DISTRO"`
-	for ARCH in $ARCHITECTURES; do
-		dir="/cache/pbuilder/ccache/$DISTRO-$ARCH"
-		verbose_run mkdir -p "$dir"
-		verbose_run chown 1234:1234 "$dir"
-
-		if $VERBOSE; then
-			echo "+ Initializing $CCACHE_DIR"
-		fi
-		pushd "$dir" >/dev/null
-		verbose_run mkdir -p $SUBDIRS
-		verbose_run chown 1234:1234 $SUBDIRS
-		for dir2 in 0 1 2 3 4 5 6 7 8 9 a b c d e f tmp; do
-			pushd "$dir2" >/dev/null
-			verbose_run mkdir -p $SUBDIRS
-			verbose_run chown 1234:1234 $SUBDIRS
-			popd >/dev/null
-		done
-		popd >/dev/null
-	done
-done

data/packaging/debian/internal/scripts/inituidgid.sh

@@ -1,19 +0,0 @@
-#!/bin/bash
-# Changes the 'app' user's UID and GID to the values specified
-# in $APP_UID and $APP_GID.
-set -e
-
-chown -R "$APP_UID:$APP_GID" /home/app
-groupmod -g "$APP_GID" app
-usermod -u "$APP_UID" -g "$APP_GID" app
-
-# There's something strange with either Docker or the kernel, so that
-# the 'app' user cannot access its home directory even after a proper
-# chown/chmod. We work around it like this.
-mv /home/app /home/app2
-cp -dpR /home/app2 /home/app
-rm -rf /home/app2
-
-if [[ $# -gt 0 ]]; then
-	exec "$@"
-fi

data/packaging/debian/internal/scripts/my_init

@@ -1,340 +0,0 @@
-#!/bin/my_init_python -u
-import os, os.path, sys, stat, signal, errno, argparse, time, json, re
-
-KILL_PROCESS_TIMEOUT = 5
-KILL_ALL_PROCESSES_TIMEOUT = 5
-
-LOG_LEVEL_ERROR = 1
-LOG_LEVEL_WARN  = 1
-LOG_LEVEL_INFO  = 2
-LOG_LEVEL_DEBUG = 3
-
-log_level = None
-
-terminated_child_processes = {}
-
-class AlarmException(Exception):
-	pass
-
-def error(message):
-	if log_level >= LOG_LEVEL_ERROR:
-		sys.stderr.write("*** %s\n" % message)
-
-def warn(message):
-	if log_level >= LOG_LEVEL_WARN:
-		sys.stderr.write("*** %s\n" % message)
-
-def info(message):
-	if log_level >= LOG_LEVEL_INFO:
-		sys.stderr.write("*** %s\n" % message)
-
-def debug(message):
-	if log_level >= LOG_LEVEL_DEBUG:
-		sys.stderr.write("*** %s\n" % message)
-
-def ignore_signals_and_raise_keyboard_interrupt(signame):
-	signal.signal(signal.SIGTERM, signal.SIG_IGN)
-	signal.signal(signal.SIGINT, signal.SIG_IGN)
-	raise KeyboardInterrupt(signame)
-
-def raise_alarm_exception():
-	raise AlarmException('Alarm')
-
-def listdir(path):
-	try:
-		result = os.stat(path)
-	except OSError:
-		return []
-	if stat.S_ISDIR(result.st_mode):
-		return sorted(os.listdir(path))
-	else:
-		return []
-
-def is_exe(path):
-	try:
-		return os.path.isfile(path) and os.access(path, os.X_OK)
-	except OSError:
-		return False
-
-def import_envvars(clear_existing_environment = True, override_existing_environment = True):
-	new_env = {}
-	for envfile in listdir("/etc/container_environment"):
-		name = os.path.basename(envfile)
-		with open("/etc/container_environment/" + envfile, "r") as f:
-			# Text files often end with a trailing newline, which we
-			# don't want to include in the env variable value. See
-			# https://github.com/phusion/baseimage-docker/pull/49
-			value = re.sub('\n\Z', '', f.read())
-		new_env[name] = value
-	if clear_existing_environment:
-		os.environ.clear()
-	for name, value in new_env.items():
-		if override_existing_environment or not name in os.environ:
-			os.environ[name] = value
-
-def export_envvars(to_dir = True):
-	shell_dump = ""
-	for name, value in os.environ.items():
-		if name in ['HOME', 'USER', 'GROUP', 'UID', 'GID', 'SHELL']:
-			continue
-		if to_dir:
-			with open("/etc/container_environment/" + name, "w") as f:
-				f.write(value)
-		shell_dump += "export " + shquote(name) + "=" + shquote(value) + "\n"
-	with open("/etc/container_environment.sh", "w") as f:
-		f.write(shell_dump)
-	with open("/etc/container_environment.json", "w") as f:
-		f.write(json.dumps(dict(os.environ)))
-
-_find_unsafe = re.compile(r'[^\w@%+=:,./-]').search
-
-def shquote(s):
-	"""Return a shell-escaped version of the string *s*."""
-	if not s:
-		return "''"
-	if _find_unsafe(s) is None:
-		return s
-
-	# use single quotes, and put single quotes into double quotes
-	# the string $'b is then quoted as '$'"'"'b'
-	return "'" + s.replace("'", "'\"'\"'") + "'"
-
-# Waits for the child process with the given PID, while at the same time
-# reaping any other child processes that have exited (e.g. adopted child
-# processes that have terminated).
-def waitpid_reap_other_children(pid):
-	global terminated_child_processes
-
-	status = terminated_child_processes.get(pid)
-	if status:
-		# A previous call to waitpid_reap_other_children(),
-		# with an argument not equal to the current argument,
-		# already waited for this process. Return the status
-		# that was obtained back then.
-		del terminated_child_processes[pid]
-		return status
-
-	done = False
-	status = None
-	while not done:
-		try:
-			this_pid, status = os.waitpid(-1, 0)
-			if this_pid == pid:
-				done = True
-			else:
-				# Save status for later.
-				terminated_child_processes[this_pid] = status
-		except OSError as e:
-			if e.errno == errno.ECHILD or e.errno == errno.ESRCH:
-				return None
-			else:
-				raise
-	return status
-
-def stop_child_process(name, pid, signo = signal.SIGTERM, time_limit = KILL_PROCESS_TIMEOUT):
-	info("Shutting down %s (PID %d)..." % (name, pid))
-	try:
-		os.kill(pid, signo)
-	except OSError:
-		pass
-	signal.alarm(time_limit)
-	try:
-		try:
-			waitpid_reap_other_children(pid)
-		except OSError:
-			pass
-	except AlarmException:
-		warn("%s (PID %d) did not shut down in time. Forcing it to exit." % (name, pid))
-		try:
-			os.kill(pid, signal.SIGKILL)
-		except OSError:
-			pass
-		try:
-			waitpid_reap_other_children(pid)
-		except OSError:
-			pass
-	finally:
-		signal.alarm(0)
-
-def run_command_killable(*argv):
-	filename = argv[0]
-	status = None
-	pid = os.spawnvp(os.P_NOWAIT, filename, argv)
-	try:
-		status = waitpid_reap_other_children(pid)
-	except BaseException as s:
-		warn("An error occurred. Aborting.")
-		stop_child_process(filename, pid)
-		raise
-	if status != 0:
-		if status is None:
-			error("%s exited with unknown status\n" % filename)
-		else:
-			error("%s failed with status %d\n" % (filename, os.WEXITSTATUS(status)))
-		sys.exit(1)
-
-def run_command_killable_and_import_envvars(*argv):
-	run_command_killable(*argv)
-	import_envvars()
-	export_envvars(False)
-
-def kill_all_processes(time_limit):
-	info("Killing all processes...")
-	try:
-		os.kill(-1, signal.SIGTERM)
-	except OSError:
-		pass
-	signal.alarm(time_limit)
-	try:
-		# Wait until no more child processes exist.
-		done = False
-		while not done:
-			try:
-				os.waitpid(-1, 0)
-			except OSError as e:
-				if e.errno == errno.ECHILD:
-					done = True
-				else:
-					raise
-	except AlarmException:
-		warn("Not all processes have exited in time. Forcing them to exit.")
-		try:
-			os.kill(-1, signal.SIGKILL)
-		except OSError:
-			pass
-	finally:
-		signal.alarm(0)
-
-def run_startup_files():
-	# Run /etc/my_init.d/*
-	for name in listdir("/etc/my_init.d"):
-		filename = "/etc/my_init.d/" + name
-		if is_exe(filename):
-			info("Running %s..." % filename)
-			run_command_killable_and_import_envvars(filename)
-
-	# Run /etc/rc.local.
-	if is_exe("/etc/rc.local"):
-		info("Running /etc/rc.local...")
-		run_command_killable_and_import_envvars("/etc/rc.local")
-
-def start_runit():
-	info("Booting runit daemon...")
-	pid = os.spawnl(os.P_NOWAIT, "/usr/bin/runsvdir", "/usr/bin/runsvdir",
-		"-P", "/etc/service")
-	info("Runit started as PID %d" % pid)
-	return pid
-
-def wait_for_runit_or_interrupt(pid):
-	try:
-		status = waitpid_reap_other_children(pid)
-		return (True, status)
-	except KeyboardInterrupt:
-		return (False, None)
-
-def shutdown_runit_services():
-	debug("Begin shutting down runit services...")
-	os.system("/usr/bin/sv down /etc/service/*")
-
-def wait_for_runit_services():
-	debug("Waiting for runit services to exit...")
-	done = False
-	while not done:
-		done = os.system("/usr/bin/sv status /etc/service/* | grep -q '^run:'") != 0
-		if not done:
-			time.sleep(0.1)
-
-def install_insecure_key():
-	info("Installing insecure SSH key for user root")
-	run_command_killable("/usr/sbin/enable_insecure_key")
-
-def main(args):
-	import_envvars(False, False)
-	export_envvars()
-
-	if args.enable_insecure_key:
-		install_insecure_key()
-
-	if not args.skip_startup_files:
-		run_startup_files()
-	
-	runit_exited = False
-	exit_code = None
-
-	if not args.skip_runit:
-		runit_pid = start_runit()
-	try:
-		exit_status = None
-		if len(args.main_command) == 0:
-			runit_exited, exit_code = wait_for_runit_or_interrupt(runit_pid)
-			if runit_exited:
-				if exit_code is None:
-					info("Runit exited with unknown status")
-					exit_status = 1
-				else:
-					exit_status = os.WEXITSTATUS(exit_code)
-					info("Runit exited with status %d" % exit_status)
-		else:
-			info("Running %s..." % " ".join(args.main_command))
-			pid = os.spawnvp(os.P_NOWAIT, args.main_command[0], args.main_command)
-			try:
-				exit_code = waitpid_reap_other_children(pid)
-				if exit_code is None:
-					info("%s exited with unknown status." % args.main_command[0])
-					exit_status = 1
-				else:
-					exit_status = os.WEXITSTATUS(exit_code)
-					info("%s exited with status %d." % (args.main_command[0], exit_status))
-			except KeyboardInterrupt:
-				stop_child_process(args.main_command[0], pid)
-				raise
-			except BaseException as s:
-				warn("An error occurred. Aborting.")
-				stop_child_process(args.main_command[0], pid)
-				raise
-		sys.exit(exit_status)
-	finally:
-		if not args.skip_runit:
-			shutdown_runit_services()
-			if not runit_exited:
-				stop_child_process("runit daemon", runit_pid)
-			wait_for_runit_services()
-
-# Parse options.
-parser = argparse.ArgumentParser(description = 'Initialize the system.')
-parser.add_argument('main_command', metavar = 'MAIN_COMMAND', type = str, nargs = '*',
-	help = 'The main command to run. (default: runit)')
-parser.add_argument('--enable-insecure-key', dest = 'enable_insecure_key',
-	action = 'store_const', const = True, default = False,
-	help = 'Install the insecure SSH key')
-parser.add_argument('--skip-startup-files', dest = 'skip_startup_files',
-	action = 'store_const', const = True, default = False,
-	help = 'Skip running /etc/my_init.d/* and /etc/rc.local')
-parser.add_argument('--skip-runit', dest = 'skip_runit',
-	action = 'store_const', const = True, default = False,
-	help = 'Do not run runit services')
-parser.add_argument('--no-kill-all-on-exit', dest = 'kill_all_on_exit',
-	action = 'store_const', const = False, default = True,
-	help = 'Don\'t kill all processes on the system upon exiting')
-parser.add_argument('--quiet', dest = 'log_level',
-	action = 'store_const', const = LOG_LEVEL_WARN, default = LOG_LEVEL_INFO,
-	help = 'Only print warnings and errors')
-args = parser.parse_args()
-log_level = args.log_level
-
-if args.skip_runit and len(args.main_command) == 0:
-	error("When --skip-runit is given, you must also pass a main command.")
-	sys.exit(1)
-
-# Run main function.
-signal.signal(signal.SIGTERM, lambda signum, frame: ignore_signals_and_raise_keyboard_interrupt('SIGTERM'))
-signal.signal(signal.SIGINT, lambda signum, frame: ignore_signals_and_raise_keyboard_interrupt('SIGINT'))
-signal.signal(signal.SIGALRM, lambda signum, frame: raise_alarm_exception())
-try:
-	main(args)
-except KeyboardInterrupt:
-	warn("Init system aborted.")
-	exit(2)
-finally:
-	if args.kill_all_on_exit:
-		kill_all_processes(KILL_ALL_PROCESSES_TIMEOUT)