snap_deploy 0.1.3

data/lib/snap_deploy/provider/aws/ops_works.rb

@@ -0,0 +1,98 @@
+require 'timeout'
+require 'json'
+
+class SnapDeploy::Provider::AWS::OpsWorks < Clamp::Command
+
+  option '--app-id', "APP_ID", "The application ID", :required => true
+  option '--instance-ids', "INSTANCE_IDS", "The instance IDs to deploy to", :multivalued => true
+  option '--[no-]wait',    :flag, 'Wait until (or not) deployed and return the deployment status.', :default => true
+  option '--[no-]migrate', :flag, 'If the db should be automatically migrated.', :default => true
+
+  include SnapDeploy::CLI::DefaultOptions
+  include SnapDeploy::Helpers
+
+  def execute
+    require 'aws-sdk'
+    Timeout::timeout(600) do
+      create_deployment
+    end
+  rescue ::Timeout::Error
+    error 'Timeout: Could not finish deployment in 10 minutes.'
+  end
+
+  private
+
+  def create_deployment
+    data = client.create_deployment(
+      {
+        stack_id: ops_works_app[:stack_id],
+        command:  {name: 'deploy'},
+        comment:  deploy_comment,
+        custom_json: custom_json.to_json
+      }.merge(deploy_target)
+    )
+    info "Deployment created: #{data[:deployment_id]}"
+    return unless wait?
+    print "Deploying "
+    deployment = wait_until_deployed(data[:deployment_id])
+    print "\n"
+    if deployment[:status] == 'successful'
+      info "Deployment successful."
+    else
+      error "Deployment failed."
+      raise "Deployment failed."
+    end
+  end
+
+  def deploy_target
+    target = {app_id: app_id}
+    target[:instance_ids] = instance_ids_list if instance_ids_list && !instance_ids_list.empty?
+    return target
+  end
+
+  def custom_json
+    {
+      deploy: {
+        ops_works_app[:shortname] => {
+          migrate: !!migrate?,
+          scm: {
+            revision: snap_commit
+          }
+        }
+      }
+    }
+  end
+
+  def wait_until_deployed(deployment_id)
+    deployment = nil
+    loop do
+      result = client.describe_deployments(deployment_ids: [deployment_id])
+      deployment = result[:deployments].first
+      break unless deployment[:status] == "running"
+      print "."
+      sleep 5
+    end
+    deployment
+  end
+
+  def ops_works_app
+    @ops_works_app ||= fetch_ops_works_app
+  end
+
+  def fetch_ops_works_app
+    data = client.describe_apps(app_ids: [app_id])
+    unless data[:apps] && data[:apps].count == 1
+      raise "App #{app_id} not found."
+    end
+    data[:apps].first
+  end
+
+  def client
+    @client ||= begin
+      AWS.config(access_key_id: access_key_id, secret_access_key: secret_access_key, logger: logger, log_formatter: AWS::Core::LogFormatter.colored)
+      info "Logging in using Access Key ending with : #{access_key_id[-4..-1]}"
+      AWS::OpsWorks.new.client
+    end
+  end
+
+end

data/lib/snap_deploy/provider/aws/s3.rb

@@ -0,0 +1,111 @@
+require 'timeout'
+require 'json'
+
+class SnapDeploy::Provider::AWS::S3 < Clamp::Command
+
+  option '--bucket',
+    'BUCKET_NAME',
+    'S3 Bucket.',
+    :required => true
+
+  option '--region',
+    "REGION",
+    'EC2 Region.',
+    :default => 'us-east-1'
+
+  option '--endpoint',
+    'ENDPOINT',
+    'S3 Endpoint.',
+    :default => 's3.amazonaws.com'
+
+  option '--local-dir',
+    "LOCAL_DIR",
+    'The local directory. e.g. `~/build/s3` (absolute) or `_site` (relative)',
+    :default => Dir.pwd
+
+  option '--remote-dir',
+    'REMOTE_DIR',
+    'The remote s3 directory to upload to.',
+    :default => '/'
+
+  option '--detect-encoding',
+    :flag,
+    'Set HTTP header `Content-Encoding` for files compressed with `gzip` and `compress` utilities.',
+    :default => nil
+
+  option '--cache-control',
+    'CACHE_OPTION',
+    'Set HTTP header `Cache-Control` to suggest that the browser cache the file. Valid options are `no-cache`, `no-store`, `max-age=<seconds>`, `s-maxage=<seconds>`, `no-transform`, `public`, `private`.',
+    :default => 'no-cache'
+
+  option '--expires',
+    'WHEN',
+    'This sets the date and time that the cached object is no longer cacheable. The date must be in the format `YYYY-MM-DD HH:MM:SS -ZONE`',
+    :default => nil
+
+  option '--acl',
+    'ACL',
+    'Sets the access control for the uploaded objects. Valid options are `private`, `public_read`, `public_read_write`, `authenticated_read`, `bucket_owner_read`, `bucket_owner_full_control`.',
+    :default => 'private'
+
+  option '--include-dot-files',
+    :flag,
+    'When set, upload files starting a `.`.'
+
+  option '--index-document',
+    'DOCUMENT_NAME',
+    'Set the index document of a S3 website.'
+
+  include SnapDeploy::CLI::DefaultOptions
+  include SnapDeploy::Helpers
+
+  def execute
+    require 'aws-sdk'
+    require 'mime-types'
+
+    glob_args = ["**/*"]
+    glob_args << File::FNM_DOTMATCH if include_dot_files?
+
+    Dir.chdir(local_dir) do
+      Dir.glob(*glob_args) do |filename|
+        content_type = MIME::Types.type_for(filename).first.to_s
+        opts         = { :content_type => content_type }.merge(encoding_option_for(filename))
+        opts[:cache_control] = cache_control if cache_control
+        opts[:acl]           = acl if acl
+        opts[:expires]       = expires if expires
+        unless File.directory?(filename)
+          client.buckets[bucket].objects.create(upload_path(filename), File.read(filename), opts)
+        end
+      end
+    end
+
+    if index_document
+      client.buckets[bucket].configure_website do |cfg|
+        cfg.index_document_suffix = index_document
+      end
+    end
+  end
+
+  private
+
+  def upload_path(filename)
+    [remote_dir, filename].compact.join("/")
+  end
+
+  def client
+    @client ||= begin
+      AWS.config(access_key_id: access_key_id, secret_access_key: secret_access_key, region: region, logger: logger, log_formatter: AWS::Core::LogFormatter.colored)
+      info "Logging in using Access Key ending with : #{access_key_id[-4..-1]}"
+      AWS::S3.new(endpoint: endpoint)
+    end
+  end
+
+  def encoding_option_for(path)
+    if detect_encoding? && encoding_for(path)
+      {:content_encoding => encoding_for(path)}
+    else
+      {}
+    end
+  end
+
+end

data/lib/snap_deploy/provider/heroku.rb

@@ -0,0 +1,242 @@
+require 'rake'
+require 'rake/file_utils_ext'
+
+class SnapDeploy::Provider::Heroku < Clamp::Command
+
+  SnapDeploy::CLI.subcommand 'heroku', 'deploy to heroku', self
+
+  include SnapDeploy::CLI::DefaultOptions
+  include SnapDeploy::Helpers
+  include Rake::FileUtilsExt
+
+  option '--app-name',
+         'APP_NAME',
+         'The name of the heroku app to deploy',
+         :required => true
+
+  option '--region',
+         'REGION',
+         'The name of the region',
+         :default => 'us'
+
+  option '--config-var',
+         'KEY=VALUE',
+         'The name of the config variables',
+         :multivalued => true
+
+  option '--buildpack-url',
+         'BUILDPACK_URL',
+         'The url of the heroku buildpack' do |url|
+    require 'uri'
+    if url =~ URI::regexp(%w(http https git))
+      url
+    else
+      raise 'The buildpack url does not appear to be a url.'
+    end
+  end
+
+  option '--stack-name',
+         'STACK_NAME',
+         'The name of the heroku stack',
+         :default => 'cedar'
+
+  option '--[no-]db-migrate',
+         :flag,
+         'If the db should be automatically migrated',
+         :default => false
+
+  def initialize(*args)
+    super
+    require 'snap_deploy/provider/heroku/api'
+    require 'netrc'
+    require 'ansi'
+    require 'rendezvous'
+    require 'tempfile'
+  end
+
+  def execute
+    check_auth
+    maybe_create_app
+    setup_configuration
+    git_push
+    maybe_db_migrate
+  end
+
+  private
+  SLEEP_INTERVAL = 0.1
+
+  def maybe_db_migrate
+    return unless db_migrate?
+
+    log ANSI::Code.ansi("Attempting to run `#{migrate_command}`", :cyan)
+    dyno = client.dyno.create(app_name, :command => %Q{#{migrate_command}; echo "Command exited with $?"}, :attach => true)
+
+    reader, writer = IO.pipe
+
+    thread = Thread.new do
+      Rendezvous.start(:input => StringIO.new, :output => writer, :url => dyno['attach_url'])
+    end
+
+    begin
+      exit_code = Timeout.timeout(300) do
+        copy_to_stdout(thread, reader, writer)
+      end
+
+      unless exit_code
+        error ANSI::Code.ansi('The remote command execution may have failed to return an exit code.', :red)
+        exit(-1)
+      end
+
+      if exit_code != 0
+        error ANSI::Code.ansi("The remote command exited with status #{exit_code}", :red)
+        exit(exit_code)
+      end
+    rescue Timeout::Error
+      raise Timeout::Error('There was no output generated in 300 seconds.')
+    end
+
+    thread.join(SLEEP_INTERVAL)
+  end
+
+  def copy_to_stdout(thread, reader, writer)
+    writer.sync = true
+    exit_code = nil
+    tempfile = Tempfile.new('heroku-console-log')
+
+    loop do
+      nothing_to_read = if IO.select([reader], nil, nil, SLEEP_INTERVAL)
+        contents = (reader.readpartial(4096) rescue nil) unless writer.closed?
+        copy_output(contents, tempfile)
+        !!contents
+      else
+        true
+      end
+
+      thread_dead = if thread.join(SLEEP_INTERVAL)
+        writer.close unless writer.closed?
+        true
+      end
+
+      break if thread_dead && nothing_to_read
+    end
+
+    # read everything one last time
+    copy_output(reader.read, tempfile)
+
+    # go back a bit in the console output to check on the exit status, aka poor man's tail(1)
+    tempfile.seek([-tempfile.size, -32].max, IO::SEEK_END)
+
+    if last_line = tempfile.readlines.last
+      if match_data = last_line.match(/Command exited with (\d+)/)
+        exit_code = match_data[1].to_i
+      end
+    end
+
+    exit_code
+  end
+
+  def copy_output(contents, tempfile)
+    return unless contents
+    tempfile.print contents
+    print contents
+  end
+
+  def migrate_command
+    'rake db:migrate --trace'
+  end
+
+  def maybe_create_app
+    print ANSI::Code.ansi('Checking to see if app already exists... ', :cyan)
+    if app_exists?
+      print ANSI::Code.ansi("OK\n", :green)
+    else
+      print ANSI::Code.ansi("No\n", :yellow)
+      create_app
+    end
+  end
+
+  def setup_configuration
+    print ANSI::Code.ansi('Setting up config vars... ', :cyan)
+
+    # config_var_list returns a dup
+    configs = config_var_list
+
+    configs << "BUILDPACK_URL=#{buildpack_url}" if buildpack_url
+
+    if configs.empty?
+      print ANSI::Code.ansi("No config vars specified\n", :green)
+      return
+    end
+
+    existing_vars = client.config_var.info(app_name)
+
+    vars = configs.inject({}) do |memo, var|
+      key, value = var.split('=', 2)
+      if existing_vars[key] != value
+        memo[key] = value
+      end
+      memo
+    end
+
+    if vars.empty?
+      print ANSI::Code.ansi("No change required\n", :green)
+    else
+      print ANSI::Code.ansi("\nUpdating config vars #{vars.keys.join(', ')}... ", :cyan)
+      client.config_var.update(app_name, vars)
+      print ANSI::Code.ansi("OK\n", :green)
+    end
+  end
+
+  def git_push
+    if pull_request_number
+      print ANSI::Code.ansi("Pushing upstream branch #{snap_upstream_branch} from pull request #{pull_request_number} to heroku.\n", :cyan)
+    else
+      print ANSI::Code.ansi("Pushing branch #{snap_branch} to heroku.\n", :cyan)
+    end
+    cmd = "git push https://git.heroku.com/#{app_name}.git HEAD:refs/heads/master -f"
+    puts "$ #{ANSI::Code.ansi(cmd, :green)}"
+    sh(cmd) do |ok, res|
+      raise "Could not push to heroku remote. The exit code was #{res.exitstatus}." unless ok
+    end
+  end
+
+  def create_app
+    print ANSI::Code.ansi('Creating app on heroku since it does not exist... ', :cyan)
+    client.app.create({ name: app_name, region: region, stack: stack_name })
+    print ANSI::Code.ansi("Done\n", :green)
+  end
+
+  def app_exists?
+    !!client.app.info(app_name)
+  rescue Excon::Errors::Unauthorized, Excon::Errors::Forbidden => e
+    raise "You are not authorized to check if the app exists, perhaps you don't own that app?. The server returned status code #{e.response[:status]}."
+  rescue Excon::Errors::NotFound => ignore
+    false
+  end
+
+  def check_auth
+    print ANSI::Code.ansi('Checking heroku credentials... ', :cyan)
+    client.account.info
+    print ANSI::Code.ansi("OK\n", :green)
+  rescue Excon::Errors::HTTPStatusError => e
+    raise "Could not connect to heroku to check your credentials. The server returned status code #{e.response[:status]}."
+  end
+
+  def client
+    SnapDeploy::Provider::Heroku::API.connect_oauth(token)
+  end
+
+  def netrc
+    @netrc ||= Netrc.read
+  end
+
+  def token
+    @token ||= netrc['api.heroku.com'].password
+  end
+
+  def default_options
+    {
+    }
+  end
+
+end