bookbindery 4.1.0 → 4.1.1

data/lib/bookbinder/commands/push_to_prod.rb

@@ -1,20 +1,19 @@
-require_relative '../distributor'
-require_relative 'bookbinder_command'
+require_relative '../deploy/archive'
+require_relative '../deploy/deployment'
+require_relative '../deploy/distributor'
 require_relative 'naming'
 
 module Bookbinder
-  class PushToProdValidator
-    MissingRequiredKeyError = Class.new(RuntimeError)
-  end
-
   module Commands
     class PushToProd
       include Commands::Naming
-      CONFIG_REQUIRED_KEYS = %w(cred_repo)
+      MissingRequiredKeyError = Class.new(RuntimeError)
 
-      def initialize(logger, configuration_fetcher)
+      def initialize(streams, logger, configuration_fetcher, app_dir)
+        @streams = streams
         @logger = logger
         @configuration_fetcher = configuration_fetcher
+        @app_dir = app_dir
       end
 
       def usage
@@ -22,49 +21,46 @@ module Bookbinder
          "Push latest or <build_#> from your S3 bucket to the production host specified in credentials.yml"]
       end
 
-      def run(arguments)
+      def run((build_number))
+        streams[:warn].puts "Warning: You are pushing to production."
         validate
-        Distributor.build(@logger, options(arguments)).distribute
+        deployment = Deploy::Deployment.new(
+          app_dir: app_dir,
+          build_number: build_number,
+          aws_credentials: credentials[:aws],
+          cf_credentials: credentials[:cloud_foundry],
+          book_repo: config.book_repo,
+        )
+        archive = Deploy::Archive.new(
+          logger: @logger,
+          key: deployment.aws_access_key,
+          secret: deployment.aws_secret_key
+        )
+        archive.download(download_dir: deployment.app_dir,
+                         bucket: deployment.green_builds_bucket,
+                         build_number: deployment.build_number,
+                         namespace: deployment.namespace)
+        Deploy::Distributor.build(streams, archive, deployment).distribute
         0
       end
 
       private
 
-      attr_reader :configuration_fetcher
-
-      def options(arguments)
-        {
-          app_dir: Dir.mktmpdir,
-          build_number: arguments[0],
-
-          aws_credentials: credentials[:aws],
-          cf_credentials: credentials[:cloud_foundry],
-
-          book_repo: config.book_repo,
-        }
-      end
+      attr_reader :app_dir, :configuration_fetcher, :streams
 
       def credentials
         configuration_fetcher.fetch_credentials('production')
       end
 
       def config
-        @config ||= configuration_fetcher.fetch_config
+        configuration_fetcher.fetch_config
       end
 
       def validate
-        missing_keys = []
-        CONFIG_REQUIRED_KEYS.map do |required_key|
-          unless config.has_option?(required_key)
-            missing_keys.push(required_key)
-          end
-        end
-
-        if missing_keys.length > 0
-          raise PushToProdValidator::MissingRequiredKeyError.new "Your config.yml is missing required key(s). The require keys for this commands are " + missing_keys.join(", ")
+        unless config.has_option?('cred_repo')
+          raise MissingRequiredKeyError.new "Your config.yml is missing required key(s). The require keys for this commands are cred_repo"
         end
       end
-
     end
   end
 end

data/lib/bookbinder/commands/tag.rb

@@ -1,4 +1,3 @@
-require_relative '../deprecated_logger'
 require_relative '../errors/cli_error'
 require_relative 'naming'
 
@@ -7,8 +6,8 @@ module Bookbinder
     class Tag
       include Commands::Naming
 
-      def initialize(logger, configuration_fetcher, version_control_system)
-        @logger = logger
+      def initialize(streams, configuration_fetcher, version_control_system)
+        @streams = streams
         @configuration_fetcher = configuration_fetcher
         @version_control_system = version_control_system
       end
@@ -24,14 +23,14 @@ module Bookbinder
           version_control_system.remote_tag(url, tag, 'HEAD')
         end
 
-        @logger.log 'Success!'.green
-        @logger.log " #{config.book_repo.yellow} and its sections were tagged with #{tag.blue}"
+        streams[:success].puts 'Success!'
+        streams[:out].puts "#{config.book_repo} and its sections were tagged with #{tag}"
         0
       end
 
       private
 
-      attr_reader :configuration_fetcher, :version_control_system
+      attr_reader :streams, :configuration_fetcher, :version_control_system
 
       def urls(config)
         [config.book_repo_url] + config.sections.map(&:repo_url).uniq

data/lib/bookbinder/commands/update_local_doc_repos.rb

@@ -1,4 +1,3 @@
-require_relative '../deprecated_logger'
 require_relative '../ingest/destination_directory'
 require_relative 'naming'
 

data/lib/bookbinder/config/cf_credentials.rb

@@ -22,25 +22,12 @@ module Bookbinder
         ]
       end
 
-      def download_archive_before_push?
-        production?
-      end
-
-      def push_warning
-        if production?
-          'Warning: You are pushing to CF Docs production. Be careful.'
-        end
-      end
-
       def routes
         fetch(host_key) if correctly_formatted_domain_and_routes?(host_key)
       end
 
       def flat_routes
-        routes.reduce([]) do |all_routes, domain_apps|
-          domain, apps = domain_apps
-          all_routes + apps.map { |app| [domain, app] }
-        end
+        routes.flat_map { |(domain, apps)| apps.map { |app| [domain, app] } }
       end
 
       def space

data/lib/bookbinder/deploy/app_fetcher.rb

@@ -0,0 +1,36 @@
+require_relative 'blue_green_app'
+require_relative 'cf_routes'
+
+module Bookbinder
+  module Deploy
+    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
+end

data/lib/bookbinder/deploy/archive.rb

@@ -0,0 +1,102 @@
+require 'fog/aws'
+require 'tmpdir'
+require_relative '../deprecated_logger'
+require_relative 'artifact'
+require_relative 'success'
+
+module Bookbinder
+  module Deploy
+    class Archive
+      class FileDoesNotExist < StandardError; end
+      class NoNamespaceGiven < StandardError; end
+
+      def initialize(logger: nil, key: '', secret: '')
+        @logger = logger
+        @aws_key = key
+        @aws_secret_key = secret
+      end
+
+      def create_and_upload_tarball(
+        app_dir: 'final_app',
+        bucket: '',
+        build_number: nil,
+        namespace: nil
+      )
+        tarball_filename, tarball_path = create_tarball(app_dir, build_number, namespace)
+        upload_file(bucket, tarball_filename, tarball_path)
+        Success.new("Green build ##{build_number} has been uploaded to S3 for #{namespace}")
+      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 = Artifact.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
+
+      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 = Artifact.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
+end

data/lib/bookbinder/deploy/artifact.rb

@@ -0,0 +1,26 @@
+module Bookbinder
+  module Deploy
+    class Artifact
+      attr_reader :namespace
+
+      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 :build_number, :path, :extension
+    end
+  end
+end

data/lib/bookbinder/deploy/blue_green_app.rb

@@ -0,0 +1,29 @@
+module Bookbinder
+  module Deploy
+    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
+end

data/lib/bookbinder/deploy/cf_routes.rb

@@ -0,0 +1,32 @@
+module Bookbinder
+  module Deploy
+    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
+end

data/lib/bookbinder/deploy/deployment.rb

@@ -0,0 +1,55 @@
+module Bookbinder
+  module Deploy
+    class Deployment
+      attr_reader :app_dir, :build_number, :cf_credentials
+
+      def initialize(app_dir: nil,
+                     aws_credentials: nil,
+                     book_repo: nil,
+                     build_number: nil,
+                     cf_credentials: nil)
+        @app_dir = app_dir
+        @aws_credentials = aws_credentials
+        @book_repo = book_repo
+        @build_number = build_number
+        @cf_credentials = cf_credentials
+      end
+
+      def artifact_filename
+        artifact.filename
+      end
+
+      def artifact_full_path
+        artifact.full_path
+      end
+
+      def aws_access_key
+        aws_credentials.access_key
+      end
+
+      def aws_secret_key
+        aws_credentials.secret_key
+      end
+
+      def flat_routes
+        cf_credentials.flat_routes
+      end
+
+      def green_builds_bucket
+        aws_credentials.green_builds_bucket
+      end
+
+      def namespace
+        Ingest::DestinationDirectory.new(book_repo)
+      end
+
+      private
+
+      attr_reader :aws_credentials, :book_repo
+
+      def artifact
+        Artifact.new(namespace, build_number, 'log', '/tmp')
+      end
+    end
+  end
+end