bookbindery 4.1.0 → 4.1.1

data/lib/bookbinder/app_fetcher.rb

@@ -1,36 +0,0 @@
-require_relative 'values/blue_green_app'
-require_relative 'values/cf_routes'
-
-module Bookbinder
-
-  class AppFetcher
-    def initialize(routes_to_search, cf_command_runner)
-      @routes_to_search = routes_to_search
-      @cf_command_runner = cf_command_runner
-    end
-
-    def fetch_current_app
-      raw_cf_routes = cf_command_runner.cf_routes_output
-      cf_routes = CfRoutes.new(raw_cf_routes)
-
-      existing_hosts = routes_to_search.select do |domain, host|
-        cf_routes.apps_by_host_and_domain.has_key?([host, domain])
-      end
-
-      return nil if existing_hosts.empty?
-      app_groups = existing_hosts.map { |domain, host| apps_for_host(cf_routes, domain, host) }
-      apps_for_existing_routes = app_groups.first
-      apps_for_existing_routes.first
-    end
-
-    private
-
-    attr_reader :routes_to_search, :cf_command_runner
-
-    def apps_for_host(routes_from_cf, domain, host)
-      routes_from_cf.apps_by_host_and_domain.fetch([host, domain], []).
-          map &BlueGreenApp.method(:new)
-    end
-  end
-
-end

data/lib/bookbinder/archive.rb

@@ -1,102 +0,0 @@
-require 'fog/aws'
-require 'tmpdir'
-require_relative 'artifact_namer'
-require_relative 'deprecated_logger'
-require_relative 'time_fetcher'
-
-module Bookbinder
-  class Archive
-    class FileDoesNotExist < StandardError; end
-    class NoNamespaceGiven < StandardError; end
-
-    def initialize(logger: nil, time_fetcher: TimeFetcher.new, key: '', secret: '')
-      @logger = logger
-      @time_fetcher = time_fetcher
-      @aws_key = key
-      @aws_secret_key = secret
-    end
-
-    def create_and_upload_tarball(build_number: nil, app_dir: 'final_app', bucket: '', namespace: nil)
-      build_number ||= time_fetcher.current_time
-      raise 'You must provide a namespace to push an identifiable build.' unless namespace
-
-      tarball_filename, tarball_path = create_tarball(app_dir, build_number, namespace)
-
-      upload_file(bucket, tarball_filename, tarball_path)
-      @logger.log "Green build ##{build_number.to_s.green} has been uploaded to S3 for #{namespace.to_s.cyan}"
-    end
-
-    def upload_file(bucket, name, source_path)
-      find_or_create_directory(bucket).
-        files.create(key: name,
-                     body: File.read(source_path),
-                     public: true)
-    end
-
-    def download(download_dir: nil, bucket: nil, build_number: nil, namespace: nil)
-      raise NoNamespaceGiven, 'One must specify a namespace to find files in this bucket' unless namespace
-
-      directory = connection.directories.get bucket
-      build_number ||= latest_build_number_for_namespace(directory, namespace)
-      filename = ArtifactNamer.new(namespace, build_number, 'tgz').filename
-
-      s3_file = directory.files.get(filename)
-      raise FileDoesNotExist, "Unable to find tarball on AWS for book '#{namespace}', build number: #{build_number}" unless s3_file
-
-      downloaded_file = File.join(Dir.mktmpdir, 'downloaded.tgz')
-      File.open(downloaded_file, 'wb') { |f| f.write(s3_file.body) }
-      Dir.chdir(download_dir) { `tar xzf #{downloaded_file}` }
-
-      @logger.log "Green build ##{build_number.to_s.green} has been downloaded from S3 and untarred into #{download_dir.to_s.cyan}"
-    end
-
-    def tarball_name_regex(namespace)
-      /^#{namespace}-(\d+_?\d*)\.tgz/
-    end
-
-    private
-
-    attr_reader :time_fetcher
-
-    def find_or_create_directory(name)
-      connection.directories.create(key: name)
-    rescue Excon::Errors::Conflict
-      connection.directories.get(name)
-    end
-
-    def create_tarball(app_dir, build_number, namespace)
-      tarball_filename = ArtifactNamer.new(namespace, build_number, 'tgz').filename
-      tarball_path = File.join(Dir.mktmpdir, tarball_filename)
-
-      Dir.chdir(app_dir) { `tar czf #{tarball_path} *` }
-      return tarball_filename, tarball_path
-    end
-
-    def latest_build_number_for_namespace(directory, namespace)
-      all_files = all_files_workaround_for_fog_map_limitation(directory.files)
-
-      all_files_with_namespace = all_files.map do |file|
-        filename = file.key
-        file if filename[tarball_name_regex(namespace)]
-      end.compact
-
-      return nil if all_files_with_namespace.empty?
-      most_recent_file = all_files_with_namespace.sort_by { |file| file.last_modified }.last
-
-      most_recent_filename = most_recent_file.key
-      most_recent_filename[tarball_name_regex(namespace), 1]
-    end
-
-    def connection
-      @connection ||= Fog::Storage.new :provider => 'AWS',
-                                       :aws_access_key_id => @aws_key,
-                                       :aws_secret_access_key => @aws_secret_key
-    end
-
-    def all_files_workaround_for_fog_map_limitation(files)
-      all_files = []
-      files.each { |f| all_files << f }
-      all_files
-    end
-  end
-end

data/lib/bookbinder/artifact_namer.rb

@@ -1,22 +0,0 @@
-module Bookbinder
-  class ArtifactNamer
-    def initialize(namespace, build_number, extension, path = '.')
-      @namespace = namespace
-      @build_number = build_number
-      @path = path
-      @extension = extension
-    end
-
-    def full_path
-      File.join(path, filename)
-    end
-
-    def filename
-      "#{namespace}-#{build_number}.#{extension}"
-    end
-
-    private
-
-    attr_reader :namespace, :build_number, :path, :extension
-  end
-end

data/lib/bookbinder/commands/bookbinder_command.rb

@@ -1,18 +0,0 @@
-module Bookbinder
-  module Commands
-    class BookbinderCommand
-      def initialize(logger, configuration_fetcher)
-        @logger = logger
-        @configuration_fetcher = configuration_fetcher
-      end
-
-      private
-
-      def config
-        @config ||= configuration_fetcher.fetch_config
-      end
-
-      attr_reader :configuration_fetcher
-    end
-  end
-end

data/lib/bookbinder/distributor.rb

@@ -1,80 +0,0 @@
-require_relative 'app_fetcher'
-require_relative 'archive'
-require_relative 'artifact_namer'
-require_relative 'cf_command_runner'
-require_relative 'ingest/destination_directory'
-require_relative 'pusher'
-require_relative 'sheller'
-
-module Bookbinder
-  class Distributor
-    EXPIRATION_HOURS = 2
-
-    def self.build(logger, options)
-      namespace = Ingest::DestinationDirectory.new(options[:book_repo])
-      namer = ArtifactNamer.new(namespace, options[:build_number], 'log', '/tmp')
-
-      archive = Archive.new(logger: logger, key: options[:aws_credentials].access_key, secret: options[:aws_credentials].secret_key)
-      cf_command_runner = CfCommandRunner.new(logger, Sheller.new, options[:cf_credentials], namer.full_path)
-      cf_app_fetcher = AppFetcher.new(options[:cf_credentials].flat_routes, cf_command_runner)
-
-      pusher = Pusher.new(cf_command_runner, cf_app_fetcher)
-      new(logger, archive, pusher, namespace, namer, options)
-    end
-
-    def initialize(logger, archive, pusher, namespace, namer, options)
-      @logger = logger
-      @archive = archive
-      @pusher = pusher
-      @namespace = namespace
-      @namer = namer
-      @options = options
-    end
-
-    def distribute
-      download if cf_credentials.download_archive_before_push?
-      push_app
-      nil
-    rescue => e
-      @logger.error(<<-ERROR.chomp)
-[ERROR] #{e.message}
-[DEBUG INFO]
-CF organization: #{cf_credentials.organization}
-CF space: #{cf_credentials.space}
-CF account: #{cf_credentials.username}
-routes: #{cf_credentials.routes}
-      ERROR
-      raise
-    ensure
-      upload_trace
-    end
-
-    private
-
-    attr_reader :options, :archive, :namer, :namespace, :pusher
-
-    def download
-      archive.download(download_dir: options[:app_dir],
-                       bucket: options[:aws_credentials].green_builds_bucket,
-                       build_number: options[:build_number],
-                       namespace: namespace)
-    end
-
-    def push_app
-      @logger.warn(cf_credentials.push_warning) if cf_credentials.push_warning
-      pusher.push(options[:app_dir])
-    end
-
-    def upload_trace
-      uploaded_file = archive.upload_file(options[:aws_credentials].green_builds_bucket, namer.filename, namer.full_path)
-      @logger.log("Your cf trace file is available at: #{uploaded_file.url(Time.now.to_i + EXPIRATION_HOURS*60*60).green}")
-      @logger.log("This URL will expire in #{EXPIRATION_HOURS} hours, so if you need to share it, make sure to save a copy now.")
-    rescue Errno::ENOENT
-      @logger.error "Could not find CF trace file: #{namer.full_path}"
-    end
-
-    def cf_credentials
-      options[:cf_credentials]
-    end
-  end
-end

data/lib/bookbinder/pusher.rb

@@ -1,34 +0,0 @@
-require_relative 'app_fetcher'
-
-module Bookbinder
-  class Pusher
-    def initialize(cf_cli, app_fetcher)
-      @cf_cli = cf_cli
-      @app_fetcher = app_fetcher
-    end
-
-    def push(app_dir)
-      Dir.chdir(app_dir) do
-        cf_cli.login
-
-        old_app = app_fetcher.fetch_current_app
-
-        if old_app
-          new_app = old_app.with_flipped_name
-          cf_cli.start(new_app)
-          cf_cli.push(new_app)
-          cf_cli.map_routes(new_app)
-          cf_cli.takedown_old_target_app(old_app)
-        else
-          new_app = cf_cli.new_app
-          cf_cli.push(new_app)
-          cf_cli.map_routes(new_app)
-        end
-      end
-    end
-
-    private
-
-    attr_reader :cf_cli, :app_fetcher
-  end
-end

data/lib/bookbinder/time_fetcher.rb

@@ -1,7 +0,0 @@
-module Bookbinder
-  class TimeFetcher
-    def current_time
-      Time.now.strftime("%Y%m%d_%H%M")
-    end
-  end
-end

data/lib/bookbinder/values/blue_green_app.rb

@@ -1,27 +0,0 @@
-module Bookbinder
-  class BlueGreenApp
-    def initialize(name)
-      @name = name.strip
-    end
-
-    def ==(other)
-      to_s == other.to_s
-    end
-
-    def to_s
-      name
-    end
-
-    def with_flipped_name
-      if name.match(/green$/)
-        BlueGreenApp.new(name.sub(/green$/, 'blue'))
-      else
-        BlueGreenApp.new(name.sub(/blue$/, 'green'))
-      end
-    end
-
-    private
-
-    attr_reader :name
-  end
-end

data/lib/bookbinder/values/cf_routes.rb

@@ -1,30 +0,0 @@
-module Bookbinder
-  class CfRoutes
-    def initialize(raw_routes)
-      @raw_routes = raw_routes
-    end
-
-    def apps_by_host_and_domain
-      @apps_by_host_and_domain ||= data(raw_routes).reduce({}) {|acc, row|
-        parsed_row = Hash[headers(raw_routes).zip(row)]
-        acc.merge(parsed_row.values_at('host', 'domain') => parse_apps(parsed_row['apps']))
-      }
-    end
-
-    private
-
-    attr_reader :raw_routes
-
-    def parse_apps(apps)
-      apps.split(',').map(&:strip)
-    end
-
-    def headers(raw)
-      raw.lines[2].split(/\s+/)
-    end
-
-    def data(raw)
-      raw.lines[3..-1].map {|line| line.split(/\s+/, headers(raw).size)}
-    end
-  end
-end