passenger 5.0.4 → 5.0.5

data/packaging/rpm/internal/python27

@@ -1,3 +0,0 @@
-#!/bin/sh
-export LD_LIBRARY_PATH=/opt/rh/python27/root/usr/lib64:/opt/rh/python27/root/usr/lib
-exec /opt/rh/python27/root/usr/bin/python2.7 "$@"

data/packaging/rpm/internal/repo_update

@@ -1,46 +0,0 @@
-#!/bin/bash
-set -e
-
-/system/internal/inituidgid
-
-### Import signing key.
-/system/internal/setuser app /tools/silence-unless-failed \
-  gpg --batch --trust-model always --import /params/signing_key
-
-### Make GPG non-interactive.
-mv /usr/bin/gpg2 /usr/bin/gpg2.real
-rm /usr/bin/gpg
-cp /system/internal/dummygpg /usr/bin/gpg
-
-### Sign packages.
-echo " --> Signing packages"
-/system/internal/setuser app \
-  rpm --resign --define '%_signature gpg' --define "%_gpg_name $SIGNING_KEY" \
-  /packages/*/*.rpm
-
-### Import into repo.
-cd /packages
-PACKAGES=(*/*.rpm)
-DIRS=()
-echo " --> Importing ${#PACKAGES[*]} packages"
-
-for F in "${PACKAGES[@]}"; do
-  DIR=`dirname "$F"`
-  DIRS+=("$DIR")
-
-  mkdir -p "/repo/$DIR"
-  echo "     $F"
-  cp "$F" "/repo/$DIR/"
-done
-
-# $DIRS is now an array of distro-architecture directory names.
-# We remove duplicates.
-OUTPUT=`ruby -e 'puts ARGV.uniq.join("\n")' "${DIRS[@]}"`
-IFS=$'\n'
-DIRS=("$OUTPUT")
-
-# Create a repo for each distro-architecture directory.
-for DIR in ${DIRS[@]}; do
-  echo " --> Updating $DIR"
-  (cd "/repo/$DIR" && createrepo .)
-done

data/packaging/rpm/internal/setuser

@@ -1,26 +0,0 @@
-#!/system/internal/python27
-import sys, os, pwd
-
-if len(sys.argv) < 3:
-	sys.stderr.write("Usage: /sbin/setuser USERNAME COMMAND [args..]\n")
-	sys.exit(1)
-
-def abort(message):
-	sys.stderr.write("setuser: %s\n" % message)
-	sys.exit(1)
-
-username = sys.argv[1]
-try:
-	user = pwd.getpwnam(username)
-except KeyError:
-	abort("user %s not found" % username)
-os.initgroups(username, user.pw_gid)
-os.setgid(user.pw_gid)
-os.setuid(user.pw_uid)
-os.environ['USER'] = username
-os.environ['HOME'] = user.pw_dir
-os.environ['UID']  = str(user.pw_uid)
-try:
-	os.execvp(sys.argv[2], sys.argv[2:])
-except OSError as e:
-	abort("cannot execute %s: %s" % (sys.argv[2], str(e)))

data/packaging/rpm/internal/tracking_helper

@@ -1,40 +0,0 @@
-#!/bin/bash
-# Adds timestamps to all lines on stdin, and prints them to stdout as well as a log file.
-# The version printed to stdout has the specified prefix on each line.
-
-set -e
-set -o pipefail
-
-PREFIX="$1"
-LOGFILE="$2"
-shift
-shift
-
-function cleanup()
-{
-  local pids=`jobs -p`
-  set +e
-  if [[ "$pids" != "" ]]; then
-    kill $pids >/dev/null 2>/dev/null
-  fi
-  if [[ "$TEMPDIR" != "" ]]; then
-    rm -rf "$TEMPDIR"
-  fi
-}
-
-function add_timestamps()
-{
-  gawk '{ print strftime("%Y-%m-%d %H:%M:%S --"), $0; fflush(); }'
-}
-
-function forward_multiple()
-{
-  while read LINE; do
-    echo "$LINE" >&3
-    echo "${PREFIX}: ${LINE}"
-  done
-}
-
-trap cleanup EXIT
-exec 3>>"$LOGFILE"
-"$@" 2>&1 | add_timestamps | forward_multiple

data/packaging/rpm/jenkins_release

@@ -1,99 +0,0 @@
-#!/bin/bash
-set -e
-
-SELFROOT=`dirname "$0"`
-SELFROOT=`cd "$SELFROOT" && pwd`
-
-PROJECT_DIR=
-PASSENGER_DIR=
-CONCURRENCY=1
-EXTRA_ARGS=
-
-function run()
-{
-  echo "$ $@"
-  "$@"
-}
-
-function cleanup()
-{
-  set +e
-  local pids=`jobs -p`
-  if [[ "$pids" != "" ]]; then
-    kill $pids >/dev/null 2>/dev/null
-  fi
-}
-
-function usage()
-{
-  echo "Usage: ./jenkins_release [OPTIONS]"
-  echo "Build RPMs and YUM repository. To be invoked from Jenkins."
-  echo
-  echo "Required options:"
-  echo "  -p PATH         Path to a project"
-  echo
-  echo "Optional options:"
-  echo "  -P PATH         Path to Phusion Passenger source directory"
-  echo "  -j CONCURRENCY  Build concurrency (default: $CONCURRENCY)"
-  echo "  -O ARG          Extra arguments to pass to build script"
-}
-
-function parse_options()
-{
-  local OPTIND=1
-  local opt
-  while getopts "p:P:j:O:h" opt; do
-    case "$opt" in
-    p)
-      PROJECT_DIR="$OPTARG"
-      ;;
-    P)
-      PASSENGER_DIR="$OPTARG"
-      ;;
-    j)
-      CONCURRENCY="$OPTARG"
-      ;;
-    O)
-      EXTRA_ARGS="$OPTARG"
-      ;;
-    h)
-      usage
-      exit
-      ;;
-    *)
-      return 1
-      ;;
-    esac
-  done
-
-  if [[ "$PROJECT_DIR" = "" ]]; then
-    echo "Please specify a project using -p."
-    exit 1
-  fi
-}
-
-parse_options "$@"
-
-if [[ `whoami` != jenkins ]]; then
-  echo "This script may only be run from Jenkins."
-  exit 1
-fi
-
-echo "$ cd $SELFROOT"
-cd "$SELFROOT"
-
-BUILD_ARGS=(
-  -p "$PROJECT_DIR"
-  -j "$CONCURRENCY"
-  -l
-  $EXTRA_ARGS
-)
-if [[ "$PASSENGER_DIR" != "" ]]; then
-  BUILD_ARGS+=(-P "$PASSENGER_DIR")
-fi
-
-run ./build "${BUILD_ARGS[@]}"
-run ./repo_update \
-  -p "$PROJECT_DIR" \
-  -s auto-software-signing@phusion.nl \
-  -x /etc/passenger_rpm_automation/signing_passphrase

data/packaging/rpm/lib/build_tasks_support.rb

@@ -1,402 +0,0 @@
-require 'fileutils'
-require 'thread'
-require 'stringio'
-require 'singleton'
-require File.expand_path(File.dirname(__FILE__) + '/preprocessor')
-
-MUTEX = Mutex.new
-SUPPORTED_ARCHS = ['i386', 'x86_64']
-
-class TrackingDatabase
-  include Singleton
-
-  attr_accessor :thread
-  attr_accessor :category_list
-  attr_reader :start_time
-
-  def initialize
-    @category_list = []
-    @categories = {}
-    @start_time = Time.now
-    @finished = false
-  end
-
-  def register_category(name, description)
-    category = TrackingCategory.new(name, description)
-    @category_list << category
-    @categories[name] = category
-  end
-
-  def [](name)
-    @categories[name]
-  end
-
-  def each_category
-    @category_list.each do |category|
-      yield category
-    end
-  end
-
-  def set_finished!
-    @finished = true
-  end
-
-  def finished?
-    @finished
-  end
-
-  def has_errors?
-    each_category do |category|
-      category.each_task do |task|
-        if task.state == :error
-          return true
-        end
-      end
-    end
-    false
-  end
-
-  #### Thread-safe methods ####
-
-  def duration_description
-    distance_of_time_in_hours_and_minutes(@start_time, Time.now)
-  end
-end
-
-class TrackingCategory
-  attr_reader :name, :description
-
-  def initialize(name, description)
-    @name = name
-    @description = description
-    @task_list = []
-    @tasks = {}
-  end
-
-  def register_task(name)
-    task = TrackingTask.new(name, self)
-    @task_list << task
-    @tasks[name] = task
-  end
-
-  def [](name)
-    @tasks[name]
-  end
-
-  def each_task
-    @task_list.each do |task|
-      yield task
-    end
-  end
-end
-
-class TrackingTask
-  attr_accessor :state
-  attr_accessor :start_time
-
-  def initialize(name, category)
-    @name = name
-    @category = category
-    @state = :not_started
-  end
-
-  def set_running!
-    @state = :running
-    @start_time = Time.now
-  end
-
-  def set_done!
-    @state = :done
-    @end_time = Time.now
-  end
-
-  def set_error!
-    @state = :error
-    @end_time = Time.now
-  end
-
-  def state_name
-    state.to_s.gsub('_', ' ')
-  end
-
-  def elapsed
-    if @start_time
-      (@end_time || Time.now) - @start_time
-    else
-      nil
-    end
-  end
-
-  def duration_description
-    if @start_time
-      distance_of_time_in_hours_and_minutes(@start_time, @end_time || Time.now)
-    else
-      nil
-    end
-  end
-
-  #### Thread-safe methods ####
-
-  attr_reader :name, :category
-
-  def display_name
-    name.to_s.gsub(/[:\.]/, ' ')
-  end
-
-  def sh(command)
-    sh_with_tracking("#{category.name}:#{name}", command)
-  end
-
-  def log(message)
-    track_log("#{category.name}:#{name}", message)
-  end
-end
-
-def recursive_copy_files(files, destination_dir, preprocess = false, variables = {})
-  if !STDOUT.tty?
-    puts "Copying files..."
-  end
-  files.each_with_index do |filename, i|
-    dir = File.dirname(filename)
-    if !File.exist?("#{destination_dir}/#{dir}")
-      FileUtils.mkdir_p("#{destination_dir}/#{dir}")
-    end
-    if !File.directory?(filename)
-      if preprocess && filename =~ /\.template$/
-        real_filename = filename.sub(/\.template$/, '')
-        FileUtils.install(filename, "#{destination_dir}/#{real_filename}", :preserve => true)
-        Preprocessor.new.start(filename, "#{destination_dir}/#{real_filename}",
-          variables)
-      else
-        FileUtils.install(filename, "#{destination_dir}/#{filename}", :preserve => true)
-      end
-    end
-    if STDOUT.tty?
-      printf "\r[%5d/%5d] [%3.0f%%] Copying files...", i + 1, files.size, i * 100.0 / files.size
-      STDOUT.flush
-    end
-  end
-  if STDOUT.tty?
-    printf "\r[%5d/%5d] [%3.0f%%] Copying files...\n", files.size, files.size, 100
-  end
-end
-
-def string_option(name, default_value = nil)
-  value = ENV[name]
-  if value.nil? || value.empty?
-    default_value
-  else
-    value
-  end
-end
-
-def boolean_option(name, default_value = false)
-  value = ENV[name]
-  if value.nil? || value.empty?
-    default_value
-  else
-    value == "yes" || value == "on" || value == "true" || value == "1"
-  end
-end
-
-def get_distros_option
-  if distros = string_option('DISTROS')
-    distros.split(/[, ]/)
-  else
-    abort("Please set the DISTROS option.")
-  end
-end
-
-def get_archs_option
-  if archs = string_option('ARCHS')
-    archs.split(/[, ]/)
-  else
-    abort("Please set the ARCHS option.")
-  end
-end
-
-def load_passenger
-  if !defined?(PhusionPassenger)
-    require "/passenger/lib/phusion_passenger"
-    PhusionPassenger.locate_directories
-    PhusionPassenger.require_passenger_lib "constants"
-  end
-end
-
-def detect_passenger_version
-  load_passenger
-  PhusionPassenger::VERSION_STRING
-end
-
-def detect_nginx_version
-  load_passenger
-  PhusionPassenger::PREFERRED_NGINX_VERSION
-end
-
-def enterprise?
-  load_passenger
-  defined?(PhusionPassenger::PASSENGER_IS_ENTERPRISE) &&
-    PhusionPassenger::PASSENGER_IS_ENTERPRISE
-end
-
-def initialize_tracking_database!
-  TrackingDatabase.instance
-  TrackingDatabase.instance.thread = Thread.new do
-    Thread.current.abort_on_exception = true
-    while true
-      sleep 5
-      MUTEX.synchronize do
-        dump_tracking_database(false)
-      end
-    end
-  end
-end
-
-def check_distros_supported!
-  DISTROS.each do |distro_id|
-    if !SUPPORTED_DISTROS[distro_id]
-      abort("Unsupported distribution: #{distro_id}. Supported distributions are: #{SUPPORTED_DISTROS.keys.join(' ')}")
-    end
-  end
-end
-
-def check_archs_supported!
-  ARCHS.each do |arch|
-    if !SUPPORTED_ARCHS.include?(arch)
-      abort("Unsupported architecture: #{arch}. Supported architectures are: #{SUPPORTED_ARCHS.keys.join(' ')}")
-    end
-  end
-end
-
-def clean_bundler_env!
-  clean_env = nil
-  Bundler.with_clean_env do
-    clean_env = ENV.to_hash
-  end
-  ENV.replace(clean_env)
-end
-
-def register_tracking_category(name, description)
-  TrackingDatabase.instance.register_category(name, description)
-end
-
-def register_tracking_task(category_name, task_name)
-  TrackingDatabase.instance[category_name].register_task(task_name)
-end
-
-def track_task(category_name, task_name)
-  succeeded = false
-  task = nil
-  MUTEX.synchronize do
-    category = TrackingDatabase.instance[category_name]
-    task = category[task_name]
-    task.set_running!
-    puts "----- Task started: #{category.description} -> #{task_name} -----"
-    dump_tracking_database
-  end
-  begin
-    yield(task)
-    succeeded = true
-    puts
-  ensure
-    if succeeded
-      task.set_done!
-      puts "----- Task done: #{task.category.description} -> #{task_name} -----"
-    else
-      task.set_error!
-      puts "----- Task errored: #{task.category.description} -> #{task_name} -----"
-    end
-    dump_tracking_database
-  end
-end
-
-def dump_tracking_database(print_to_stdout = true)
-  io = StringIO.new
-  io.puts "Current time: #{format_time(Time.now)}"
-  io.puts "Start time  : #{format_time(TrackingDatabase.instance.start_time)}"
-  io.puts "Duration    : #{TrackingDatabase.instance.duration_description}"
-  if TrackingDatabase.instance.finished?
-    io.puts "*** FINISHED ***"
-  end
-  if TrackingDatabase.instance.has_errors?
-    io.puts "*** THERE WERE ERRORS ***"
-  end
-
-  io.puts
-  TrackingDatabase.instance.each_category do |category|
-    io.puts "#{category.description}:"
-    category.each_task do |task|
-      io.printf "  * %-25s: %-12s\n",
-        task.display_name,
-        task.state_name
-      if task.start_time
-        io.printf "    %25s  started %s\n", nil, format_time(task.start_time)
-      end
-      if desc = task.duration_description
-        io.printf "    %25s  duration %s\n", nil, desc
-      end
-    end
-    io.puts
-  end
-
-  if print_to_stdout
-    puts "---------------------------------------------"
-    puts io.string
-    puts "---------------------------------------------"
-  end
-
-  File.open("/output/log/state.log", "w") do |f|
-    f.write(io.string)
-  end
-end
-
-def distance_of_time_in_hours_and_minutes(from_time, to_time)
-  from_time = from_time.to_time if from_time.respond_to?(:to_time)
-  to_time = to_time.to_time if to_time.respond_to?(:to_time)
-  dist = (to_time - from_time).to_i
-  minutes = (dist.abs / 60).round
-  hours = minutes / 60
-  minutes = minutes - (hours * 60)
-  seconds = dist - (hours * 3600) - (minutes * 60)
-
-  words = ''
-  words << "#{hours} #{hours > 1 ? 'hours' : 'hour' } " if hours > 0
-  words << "#{minutes} min " if minutes > 0
-  words << "#{seconds} sec"
-  words
-end
-
-def passenger_srpm_name(distro_id)
-  "#{PASSENGER_RPM_NAME}-#{PASSENGER_RPM_VERSION}-#{PASSENGER_RPM_RELEASE}.#{distro_id}.src.rpm"
-end
-
-def nginx_srpm_name(distro_id)
-  "#{NGINX_RPM_NAME}-#{NGINX_RPM_VERSION}-#{NGINX_RPM_RELEASE}.#{distro_id}.src.rpm"
-end
-
-def format_time(time)
-  time.strftime("%Y-%m-%d %H:%M:%S")
-end
-
-def logfile_path_for_tracking_name(name)
-  name = name.gsub(/[: ]/, '.')
-  "/output/log/#{name}.log"
-end
-
-def sh_with_tracking(name, command)
-  logfile = logfile_path_for_tracking_name(name)
-  time = format_time(Time.now)
-  puts "#{name}: #{time} -- #{command}"
-  if !system("/system/internal/tracking_helper", name, logfile, "/bin/bash", "-c", command)
-    abort "*** Command failed: #{command}"
-  end
-end
-
-def track_log(name, message)
-  time = format_time(Time.now)
-  message = "#{name}: #{time} -- #{message}"
-  puts message
-  File.open(logfile_path_for_tracking_name(name), "a") do |f|
-    f.puts(message)
-  end
-end