bookbindery 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 19c1ec695ede30996441a72bccd9617f0802d6d1
+  data.tar.gz: e711b4cfe5f5af59d1e4ec68d0c98975295eab60
+SHA512:
+  metadata.gz: 1ab45230d391a2aac4d84ff67015bd48d44e82fbfb55188bbf03db798efada981a635a6d7d15e71e763eff98b45e1798850f85f0e41f1ffc346785782f683abb
+  data.tar.gz: 04f5b2b527d2c90a99b47942e6b440054d47e4e6ac74712cdb4c4fd8b80d0efb67a5a263fd7ea6cc615e6262554f0cb3824f9783259eeee5fc4025809a26a78b

data/bin/bookbinder

@@ -0,0 +1,6 @@
+#!/usr/bin/env ruby
+
+require 'bookbinder'
+
+return_code = Bookbinder::Cli.new.run ARGV
+exit return_code.to_i

data/lib/bookbinder.rb

@@ -0,0 +1,59 @@
+require 'fog'
+require 'tmpdir'
+require 'ansi'
+require 'faraday'
+require 'faraday_middleware'
+require 'octokit'
+require 'padrino-contrib'
+require 'middleman-syntax'
+require 'middleman-core/cli'
+require 'middleman-core/profiling'
+require 'anemone'
+require 'css_parser'
+require 'vienna'
+require 'popen4'
+require 'puma'
+
+#require_relative 'bookbinder/shell_out'
+require_relative 'bookbinder/bookbinder_logger'
+require_relative 'bookbinder/git_client'
+#require_relative 'bookbinder/repository'
+require_relative 'bookbinder/section'
+require_relative 'bookbinder/book'
+require_relative 'bookbinder/code_example'
+require_relative 'bookbinder/remote_yaml_credential_provider'
+require_relative 'bookbinder/configuration'
+require_relative 'bookbinder/configuration_fetcher'
+require_relative 'bookbinder/configuration_validator'
+require_relative 'bookbinder/css_link_checker'
+require_relative 'bookbinder/sitemap_generator'
+require_relative 'bookbinder/sieve'
+require_relative 'bookbinder/stabilimentum'
+require_relative 'bookbinder/server_director'
+require_relative 'bookbinder/spider'
+
+require_relative 'bookbinder/archive'
+require_relative 'bookbinder/pdf_generator'
+require_relative 'bookbinder/middleman_runner'
+require_relative 'bookbinder/publisher'
+require_relative 'bookbinder/cf_command_runner'
+require_relative 'bookbinder/pusher'
+require_relative 'bookbinder/artifact_namer'
+require_relative 'bookbinder/distributor'
+
+require_relative 'bookbinder/commands/bookbinder_command'
+require_relative 'bookbinder/commands/build_and_push_tarball'
+require_relative 'bookbinder/commands/publish'
+require_relative 'bookbinder/commands/push_local_to_staging'
+require_relative 'bookbinder/commands/push_to_prod'
+require_relative 'bookbinder/commands/run_publish_ci'
+require_relative 'bookbinder/commands/update_local_doc_repos'
+require_relative 'bookbinder/commands/tag'
+require_relative 'bookbinder/commands/generate_pdf'
+
+require_relative 'bookbinder/usage_messenger'
+
+require_relative 'bookbinder/cli'
+
+# Finds the project root for both spec & production
+GEM_ROOT = File.expand_path(File.join(File.dirname(__FILE__), '..'))

data/lib/bookbinder/app_fetcher.rb

@@ -0,0 +1,40 @@
+require_relative "blue_green_app"
+require_relative "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
+
+      app_groups =
+          if existing_hosts.any?
+            existing_hosts.map { |domain, host| apps_for_host(cf_routes, domain, host) }
+          else
+            raise "cannot find currently deployed app."
+          end
+      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

@@ -0,0 +1,95 @@
+require 'fog'
+require 'tmpdir'
+require_relative 'bookbinder_logger'
+require_relative 'artifact_namer'
+
+module Bookbinder
+  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(build_number: nil, app_dir: 'final_app', bucket: '', namespace: nil)
+      raise 'You must provide a build_number to push an identifiable build.' unless build_number
+      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
+
+    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 = 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
+        matches = /^#{namespace}-([\d]+)\.tgz/.match(filename)
+        file if matches
+      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_build_number = /^#{namespace}-([\d]+)\.tgz/.match(most_recent_filename)[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

@@ -0,0 +1,22 @@
+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/blue_green_app.rb

@@ -0,0 +1,27 @@
+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/book.rb

@@ -0,0 +1,54 @@
+require_relative 'git_hub_repository'
+require_relative 'directory_helpers'
+
+module Bookbinder
+  class Book
+    include DirectoryHelperMethods
+    attr_reader :sections
+
+    def self.from_remote(logger: nil, full_name: nil, destination_dir: nil, ref: nil, git_accessor: Git)
+      book = new(logger: logger, full_name: full_name, target_ref: ref, git_accessor: git_accessor)
+      book.copy_from_remote(destination_dir) if destination_dir
+      book
+    end
+
+    def initialize(logger: nil, full_name: nil, target_ref: nil, github_token: nil, sections: [], git_accessor: Git)
+      @sections = sections.map do |section|
+        GitHubRepository.new logger: logger, full_name: section['repository']['name']
+      end
+
+      @repository = GitHubRepository.new(logger: logger, full_name: full_name, target_ref: target_ref, github_token: github_token)
+      @git_accessor = git_accessor
+    end
+
+    def full_name
+      @repository.full_name
+    end
+
+    def head_sha
+      @repository.head_sha
+    end
+
+    def directory
+      @repository.directory
+    end
+
+    def get_modification_date_for(file: nil, full_path: nil)
+      git_directory, file_relative_path = full_path.split(output_dir_name+'/')
+      begin
+        git_base_object = Git.open(git_directory)
+      rescue => e
+        raise "Invalid git repository! #{git_directory} is not a .git directory"
+      end
+      @repository.get_modification_date_for(file: file_relative_path, git: git_base_object)
+    end
+
+    def copy_from_remote(destination_dir)
+      @repository.copy_from_remote(destination_dir, @git_accessor)
+    end
+
+    def tag_self_and_sections_with(tag)
+      (@sections + [@repository]).each { |repo| repo.tag_with tag }
+    end
+  end
+end

data/lib/bookbinder/bookbinder_logger.rb

@@ -0,0 +1,33 @@
+require 'ansi'
+
+class String
+  include ANSI::Mixin
+end
+
+module Bookbinder
+  class BookbinderLogger
+    def log(message)
+      puts message
+    end
+
+    def log_print(message)
+      print message
+    end
+
+    def error(message)
+      puts message.red
+    end
+
+    def success(message)
+      puts message.green
+    end
+
+    def warn(message)
+      puts message.yellow
+    end
+
+    def notify(message)
+      puts message.blue
+    end
+  end
+end

data/lib/bookbinder/cf_command_runner.rb

@@ -0,0 +1,114 @@
+require 'open3'
+require_relative 'blue_green_app'
+
+module Bookbinder
+  class CfCommandRunner
+    def initialize(logger, cf_credentials, trace_file)
+      @logger = logger
+      @creds = cf_credentials
+      @trace_file = trace_file
+    end
+
+    def login
+      username = creds.username
+      password = creds.password
+      api_endpoint = creds.api_endpoint
+      organization = creds.organization
+      space = creds.space
+      creds_string = (username && password) ? "-u '#{username}' -p '#{password}'" : ''
+
+      success = Kernel.system("#{cf_binary_path} login #{creds_string} -a '#{api_endpoint}' -o '#{organization}' -s '#{space}'")
+      raise "Could not log in to #{creds.api_endpoint}" unless success
+    end
+
+    def cf_routes_output
+      output, status = Open3.capture2("CF_COLOR=false #{cf_binary_path} routes")
+      raise 'failure executing cf routes' unless status.success?
+      output
+    end
+
+    def new_app
+      BlueGreenApp.new([creds.app_name, 'blue'].join('-'))
+    end
+
+    def start(deploy_target_app)
+      # Theoretically we shouldn't need this (and corresponding "stop" below), but we've seen CF pull files from both
+      # green and blue when a DNS redirect points to HOST.cfapps.io
+      # Also, shutting down the unused app saves $$
+      Kernel.system("#{cf_binary_path} start #{deploy_target_app} ")
+    end
+
+    def push(deploy_target_app)
+      # Currently --no-routes is used to blow away all existing routes from a newly deployed app.
+      # The routes will then be recreated from the creds repo.
+      success = Kernel.system(environment_variables, "#{cf_binary_path} push #{deploy_target_app} --no-route -m 256M -i 3")
+      raise "Could not deploy app to #{deploy_target_app}" unless success
+    end
+
+    def unmap_routes(app)
+      creds.flat_routes.each do |domain, host|
+        unmap_route(app, domain, host)
+      end
+    end
+
+    def map_routes(app)
+      succeeded = []
+
+      creds.flat_routes.each do |domain, name|
+        begin
+          map_route(app, domain, name)
+          succeeded << [app, domain, name]
+        rescue RuntimeError
+          succeeded.each { |app, domain, host| unmap_route(app, domain, host) }
+          raise
+        end
+      end
+    end
+
+    def takedown_old_target_app(app)
+      # Routers flush every 10 seconds (but not guaranteed), so wait a bit longer than that.
+      @logger.log "waiting 15 seconds for routes to remap...\n\n"
+      (1..15).to_a.reverse.each do |seconds|
+        @logger.log_print "\r\r#{seconds}...    "
+        Kernel.sleep 1
+      end
+      stop(app)
+      unmap_routes(app)
+    end
+
+    private
+
+    attr_reader :creds
+
+    def stop(app)
+      success = Kernel.system("#{cf_binary_path} stop #{app}")
+      raise "Failed to stop application #{app}" unless success
+    end
+
+    def map_route(deploy_target_app, domain, host)
+      map_route_command = "#{cf_binary_path} map-route #{deploy_target_app} #{domain}"
+      map_route_command += " -n #{host}" unless host.empty?
+
+      success = Kernel.system(map_route_command)
+      raise "Deployed app to #{deploy_target_app} but failed to map hostname #{host}.#{domain} to it." unless success
+    end
+
+    def unmap_route(deploy_target_app, domain, host)
+      unmap_route_command = "#{cf_binary_path} unmap-route #{deploy_target_app} #{domain}"
+      unmap_route_command += " -n #{host}" unless host.empty?
+
+      success = Kernel.system(unmap_route_command)
+      raise "Failed to unmap route #{host} on #{deploy_target_app}." unless success
+    end
+
+    def cf_binary_path
+      @cf_binary_path ||= `which cf`.chomp!
+      raise "CF CLI could not be found in your PATH. Please make sure cf cli is in your PATH." if @cf_binary_path.nil?
+      @cf_binary_path
+    end
+
+    def environment_variables
+      {'CF_TRACE' => @trace_file}
+    end
+  end
+end