travis_dpl_test 2.0.3.beta.4.ror

data/lib/dpl/providers/chef_supermarket.rb

@@ -0,0 +1,132 @@
+# frozen_string_literal: true
+
+module Dpl
+  module Providers
+    class ChefSupermarket < Provider
+      register :'chef-supermarket'
+      register :chef_supermarket
+
+      status :alpha
+
+      full_name 'Chef Supermarket'
+
+      description sq(<<-STR)
+        tbd
+      STR
+
+      gem 'chef', '~> 18', require: %w[
+        chef/cookbook/cookbook_version_loader
+        chef/cookbook_uploader
+      ]
+
+      gem 'json'
+      gem 'mime-types', '~> 3.4.1'
+      gem 'net-telnet', '~> 0.1.0' if ruby_pre?('2.3')
+      gem 'rack'
+
+      env :chef
+
+      opt '--user_id ID',         'Chef Supermarket user name', required: true
+      opt '--name NAME',          'Cookbook name', note: 'defaults to the name given in metadata.json or metadata.rb', alias: :cookbook_name, deprecated: :cookbook_name
+      opt '--category CAT',       'Cookbook category in Supermarket', required: true, see: 'https://docs.getchef.com/knife_cookbook_site.html#id12', alias: :cookbook_category, deprecated: :cookbook_category
+      opt '--client_key KEY',     'Client API key file name', default: 'client.pem'
+      opt '--dir DIR',            'Directory containing the cookbook', default: '.'
+
+      URL = 'https://supermarket.chef.io/api/v1/cookbooks'
+
+      msgs validate: 'Validating cookbook',
+           upload: 'Uploading cookbook %{name} to %{url}',
+           missing_file: 'Missing file: %s',
+           unknown_error: 'Unknown error while sharing cookbook: %s',
+           version_exists: 'The same version of this cookbook already exists on the Opscode Cookbook Site.'
+
+      def setup
+        Chef::Config[:client_key] = client_key
+        chdir dir
+      end
+
+      def validate
+        info :validate
+        validate_file client_key
+        uploader.validate_cookbooks
+      end
+
+      def deploy
+        info :upload
+        upload
+      end
+
+      private
+
+      def upload
+        res = Chef::Knife::Core::CookbookSiteStreamingUploader.post(URL, user_id, client_key, params)
+        handle_error(res.body) if res.code.to_i != 201
+      end
+
+      def params
+        { cookbook: json(category: category), tarball: tarball}
+      end
+
+      def tarball
+        shell "tar -czf /tmp/#{name}.tgz -C #{build_dir} ."
+        shell "tar -tvf /tmp/#{name}.tgz"
+        open "/tmp/#{name}.tgz"
+      end
+
+      def name
+        @name ||= name_from_json || name_from_rb || error(:missing_file, 'metadata.json or metadata.rb')
+      end
+
+      def name_from_json
+        JSON.parse(read('metadata.json'))['name'] if file?('metadata.json')
+      end
+
+      def name_from_rb
+        Chef::Cookbook::Metadata.new.from_file('metadata.rb') if file?('metadata.rb')
+      end
+
+      def cookbook
+        @cookbook ||= loader.cookbook_version
+      end
+
+      def loader
+        Chef::Cookbook::CookbookVersionLoader.new('.').tap(&:load!)
+      end
+
+      def uploader
+        Chef::CookbookUploader.new(cookbook)
+      end
+
+      def build_dir
+        @build_dir ||= Chef::Knife::Core::CookbookSiteStreamingUploader.create_build_dir(cookbook)
+      end
+
+      def validate_file(path)
+        error :missing_file, path unless file?(path)
+      end
+
+      def url
+        URL
+      end
+
+      def handle_error(res)
+        res = JSON.parse(res)
+        unknown_error(res) unless res['error_messages']
+        version_exists if res['error_messages'][0].include?('Version already exists')
+        error (res['error_messages'][0]).to_s
+      end
+
+      def unknown_error(msg)
+        error :unknown_error, msg
+      end
+
+      def version_exists
+        error :version_exists
+      end
+
+      def json(obj)
+        JSON.dump(obj)
+      end
+    end
+  end
+end

data/lib/dpl/providers/cloud66.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module Dpl
+  module Providers
+    class Cloud66 < Provider
+      register :cloud66
+
+      status :alpha
+
+      description sq(<<-STR)
+        tbd
+      STR
+
+      env :cloud66
+
+      opt '--redeployment_hook URL', 'The redeployment hook URL', required: true, secret: true
+
+      msgs failed: 'Redeployment failed (%s)'
+
+      def deploy
+        response = client.request(request)
+        error :failed, response.code if response.code != '200'
+      end
+
+      private
+
+      def client
+        Net::HTTP.new(uri.host, uri.port).tap do |client|
+          client.use_ssl = use_ssl?
+        end
+      end
+
+      def request
+        Net::HTTP::Post.new(uri.path)
+      end
+
+      def uri
+        @uri ||= URI.parse(redeployment_hook)
+      end
+
+      def use_ssl?
+        uri.scheme.downcase == 'https'
+      end
+    end
+  end
+end

data/lib/dpl/providers/cloudfiles.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+module Dpl
+  module Providers
+    class Cloudfiles < Provider
+      register :cloudfiles
+
+      status :alpha
+
+      full_name 'Cloud Files'
+
+      description sq(<<-STR)
+        tbd
+      STR
+
+      gem 'nokogiri', '~> 1.15'
+      gem 'fog-core', '~> 2.3', require: 'fog/core'
+      gem 'fog-rackspace', '~> 0.1.6', git: 'https://github.com/travis-oss/fog-rackspace', require: 'fog/rackspace'
+
+      env :cloudfiles
+
+      opt '--username USER',  'Rackspace username', required: true
+      opt '--api_key KEY',    'Rackspace API key', required: true, secret: true
+      opt '--region REGION',  'Cloudfiles region', required: true, enum: %w[ord dfw syd iad hkg]
+      opt '--container NAME', 'Name of the container that files will be uploaded to', required: true
+      opt '--glob GLOB',      'Paths to upload', default: '**/*'
+      opt '--dot_match',      'Upload hidden files starting a dot'
+
+      msgs missing_container: 'The specified container does not exist.'
+
+      def deploy
+        paths.each do |path|
+          container.files.create(key: path, body: File.open(path))
+        end
+      end
+
+      def paths
+        paths = Dir.glob(*glob)
+        paths.reject { |path| File.directory?(path) }
+      end
+
+      def glob
+        glob = [super]
+        glob << File::FNM_DOTMATCH if dot_match?
+        glob
+      end
+
+      def container
+        @container ||= api.directories.get(super) || error(:missing_container)
+      end
+
+      def api
+        @api ||= Fog::Storage.new(
+          provider: 'Rackspace',
+          rackspace_username: username,
+          rackspace_api_key: api_key,
+          rackspace_region: region
+        )
+      end
+    end
+  end
+end

data/lib/dpl/providers/cloudformation.rb

@@ -0,0 +1,281 @@
+# frozen_string_literal: true
+
+module Dpl
+  module Providers
+    class Cloudformation < Provider
+      register :cloudformation
+      status :stable
+
+      full_name 'AWS CloudFormation'
+
+      description sq(<<-STR)
+        tbd
+      STR
+
+      gem 'aws-sdk-cloudformation', '~> 1.0'
+
+      env :aws, :cloudformation
+      config '~/.aws/credentials', prefix: 'aws'
+
+      opt '--access_key_id ID', 'AWS Access Key ID', required: true, secret: true
+      opt '--secret_access_key KEY', 'AWS Secret Key', required: true, secret: true
+      opt '--region REGION', 'AWS Region to deploy to', default: 'us-east-1'
+      opt '--template STR', 'CloudFormation template file', required: true, note: 'can be either a local path or an S3 URL'
+      opt '--stack_name NAME', 'CloudFormation Stack Name.', required: true
+      opt '--stack_name_prefix STR', 'CloudFormation Stack Name Prefix.'
+      opt '--promote', 'Deploy changes', default: true, note: 'otherwise a change set is created'
+      opt '--role_arn ARN', 'AWS Role ARN'
+      opt '--sts_assume_role ARN', 'AWS Role ARN for cross account deployments (assumed by travis using given AWS credentials).'
+      opt '--capabilities STR', 'CloudFormation allowed capabilities', type: :array, enum: %w[CAPABILITY_IAM CAPABILITY_NAMED_IAM CAPABILITY_AUTO_EXPAND], sep: ',', see: 'https://docs.aws.amazon.com/AWSCloudFormation/latest/APIReference/API_CreateStack.html'
+      opt '--wait', 'Wait for CloutFormation to finish the stack creation and update', default: true
+      opt '--wait_timeout SEC', 'How many seconds to wait for stack creation and update.', type: :integer, default: 3600
+      opt '--create_timeout SEC', 'How many seconds to wait before the stack status becomes CREATE_FAILED', type: :integer, default: 3600, note: 'valid only when creating a stack'
+      opt '--parameters STR', 'key=value pairs or ENV var names', type: :array, eg: 'one=1 or ENV_VAR_TWO'
+      opt '--output_file PATH', 'Path to output file to store CloudFormation outputs to'
+
+      msgs login: 'Using Access Key: %{access_key_id}',
+           create_stack: 'Creating stack ...',
+           promote_stack: 'Promoting stack ...',
+           create_change_set: 'Creating change set ...',
+           stack_up_to_date: 'Stack already up to date.',
+           delete_change_set: 'No changes in stack. Removing changeset.',
+           done: 'Done.',
+           missing_template: 'File does not exist: %{template}',
+           invalid_creds: 'Invalid credentials'
+
+      strs change_set_name: 'travis-ci-build-%{build_number}-%{now}',
+           change_set_desc: 'Changeset created by Travis CI job for build #%{build_number} (%{git_sha})'
+
+      def login
+        info :login
+      end
+
+      def deploy
+        stack_exists? ? update : create
+        store_events if output_file?
+      rescue Aws::CloudFormation::Errors::InvalidAccessKeyId
+        error :invalid_creds
+      end
+
+      private
+
+      def update
+        promote? ? promote : create_change_set(:update)
+      rescue Aws::CloudFormation::Errors::ValidationError => e
+        raise e unless e.message.start_with?('No updates are to be performed')
+
+        info :stack_up_to_date
+      end
+
+      def promote
+        info :promote_stack
+        client.update_stack(common_params)
+        stream_events(stack_name, :stack_update_complete) if wait?
+        info :done
+      end
+
+      def create
+        promote? ? create_stack : create_change_set(:create)
+      end
+
+      def create_stack
+        info :create_stack
+        params = { timeout_in_minutes: create_timeout, on_failure: 'ROLLBACK' }
+        client.create_stack(common_params.merge(params))
+        stream_events(stack_name, :stack_create_complete) if wait?
+        info :done
+      end
+
+      def create_change_set(type)
+        info :create_change_set
+        set = client.create_change_set(common_params.merge(change_set_params(type)))
+        wait_for(:change_set_create_complete, change_set_name: set.id) if wait? && !test?
+        info :done
+      rescue Aws::Waiters::Errors::FailureStateError => e
+        raise e unless change_set_contains_changes?(set)
+
+        info :delete_change_set
+        client.delete_change_set(change_set_name: set.id)
+      end
+
+      def change_set_params(type)
+        {
+          change_set_type: type.to_s.upcase,
+          change_set_name: interpolate(str(:change_set_name)),
+          description: interpolate(str(:change_set_desc))
+        }
+      end
+
+      def change_set_contains_changes?(change_set)
+        data = client.describe_change_set(change_set_name: change_set.id)
+        data.status_reason.start_with?(%(The submitted information didn't contain changes))
+      end
+
+      def stack_exists?
+        stack = last_stack
+        stack && stack.stack_status != 'REVIEW_IN_PROGRESS'
+      rescue Aws::CloudFormation::Errors::ValidationError => e
+        raise e unless e.message.include?('does not exist')
+
+        false
+      end
+
+      def stream_events(stack_name, condition)
+        stream = EventStream.new(client, stack_name, method(:info))
+        wait_for(condition, stack_name:) unless test? # hmm.
+      ensure
+        stream&.stop
+      end
+
+      def wait_for(cond, params)
+        started_at = Time.now
+        timeout = ->(*) { throw :failure if Time.now - started_at > wait_timeout }
+        # params = params.merge(max_attempts: nil, delay: 5, before_wait: timeout)
+        client.wait_until(cond, params) { |w| w.before_wait(&timeout) }
+      end
+
+      def store_events
+        logs = last_stack.outputs || {}
+        logs = logs.map { |log| "#{log[:output_key]}=#{log[:output_value]}" }
+        File.write(output_file, logs.join("\n"))
+      end
+
+      def last_stack
+        client.describe_stacks(stack_name:)[:stacks].first
+      end
+
+      def common_params
+        params = {
+          stack_name:,
+          role_arn:,
+          capabilities:,
+          parameters:
+        }
+        params.merge!(template_param)
+        @common_params ||= compact(params)
+      end
+
+      def parameters
+        @parameters ||= Array(super).map do |str|
+          key, value = str.split('=', 2)
+          { parameter_key: key, parameter_value: value || ENV[key] }
+        end
+      end
+
+      def create_timeout
+        super / 60
+      end
+
+      def stack_name
+        @stack_name ||= "#{stack_name_prefix}#{super}"
+      end
+
+      def template_param
+        str = template
+        return { template_url: str } if url?(str)
+        return { template_body: read(str) } if file?(str)
+
+        error(:missing_template)
+      end
+
+      def client
+        @client ||= Aws::CloudFormation::Client.new(client_options)
+      end
+
+      def client_options
+        params = { region:, credentials: }
+        params = params.merge(credentials: assume_role(params)) if sts_assume_role?
+        params
+      end
+
+      def credentials
+        Aws::Credentials.new(access_key_id, secret_access_key)
+      end
+
+      def assume_role(params)
+        assumed_role = Aws::STS::Client.new(params).assume_role(
+          role_arn: sts_assume_role,
+          role_session_name: "travis-build-#{build_number}"
+        )
+        Aws::Credentials.new(
+          assumed_role.credentials.access_key_id,
+          assumed_role.credentials.secret_access_key,
+          assumed_role.credentials.session_token
+        )
+      end
+
+      def now
+        Time.now.strftime('%Y%m%d%H%M%S')
+      end
+
+      def url?(str)
+        str =~ %r{^https?://}
+      end
+
+      class EventStream < Struct.new(:client, :stack_name, :handler)
+        attr_reader :thread
+
+        def initialize(*)
+          super
+          @event = describe_stack_events.stack_events.first
+          @thread = Thread.new(&method(:process))
+        end
+
+        def stop
+          mutex.synchronize { @stop = true }
+          thread.join
+        end
+
+        private
+
+        def process
+          until mutex.synchronize { @stop }
+            @event, events = events_since(@event)
+            events.each { |e| handler.call(format_event(e)) }
+            sleep 5 unless ENV['ENV'] == 'test'
+          end
+        end
+
+        # source: https://github.com/rvedotrc/cfn-events/blob/master/lib/cfn-events/runner.rb
+        def events_since(event)
+          described_stack = describe_stack_events
+          stack_events = described_stack.stack_events
+          return [event, []] if stack_events.first.event_id == event.event_id
+
+          events = []
+          described_stack.each_page do |page|
+            if (oldest_new = page.stack_events.index { |e| e.event_id == event.event_id })
+              events.concat(page.stack_events[0..oldest_new - 1])
+              return [events.first, events.reverse]
+            end
+            events.concat(page.stack_events)
+          end
+
+          warn %(Last-seen stack event is no longer returned by AWS. Please raise this as a provider's bug.)
+          [events.first, events.reverse]
+        end
+
+        def describe_stack_events
+          client.describe_stack_events(stack_name:)
+        end
+
+        def mutex
+          @mutex ||= Mutex.new
+        end
+
+        EVENT_KEYS = %i[timestamp resource_type resource_status logical_resource_id
+                        physical_resource_id resource_status_reason].freeze
+
+        def format_event(event)
+          parts = EVENT_KEYS.map { |key| event.send(key) }
+          parts[0] = format_timestamp(parts[0])
+          parts.join(' ')
+        end
+
+        def format_timestamp(timestamp)
+          timestamp.utc.strftime('%Y-%m-%dT%H:%M:%SZ')
+        end
+      end
+    end
+  end
+end

data/lib/dpl/providers/cloudfoundry.rb

@@ -0,0 +1,89 @@
+# frozen_string_literal: true
+
+module Dpl
+  module Providers
+    class Cloudfoundry < Provider
+      register :cloudfoundry
+
+      status :stable
+
+      full_name 'Cloud Foundry'
+
+      description sq(<<-STR)
+        tbd
+      STR
+
+      env :cloudfoundry
+
+      opt '--username USER',       'Cloud Foundry username', required: true
+      opt '--password PASS',       'Cloud Foundry password', required: true, secret: true
+      opt '--organization ORG',    'Cloud Foundry organization', required: true
+      opt '--space SPACE',         'Cloud Foundry space', required: true
+      opt '--api URL',             'Cloud Foundry api URL', default: 'https://api.run.pivotal.io'
+      opt '--app_name APP',        'Application name'
+      opt '--buildpack PACK',      'Buildpack name or Git URL'
+      opt '--manifest FILE',       'Path to the manifest'
+      opt '--skip_ssl_validation', 'Skip SSL validation'
+      opt '--deployment_strategy STRATEGY', 'Deployment strategy, either rolling or null'
+      opt '--v3', 'Use the v3 API version to push the application'
+      opt '--logout', default: true, internal: true
+
+      cmds install: 'test $(uname) = "Linux" && rel="linux64-binary" || rel="macosx64"; wget "https://cli.run.pivotal.io/stable?release=${rel}&version=v7&source=github" -qO cf.tgz && tar -zxvf cf.tgz && rm cf.tgz',
+           api: './cf api %{api} %{skip_ssl_validation_opt}',
+           login: './cf login -u %{username} -p %{password} -o %{organization} -s %{space}',
+           push: './cf %{push_cmd} %{push_args}',
+           logout: './cf logout'
+
+      errs install: 'Failed to install CLI tools',
+           api: 'Failed to set api %{api}',
+           login: 'Failed to login',
+           push: 'Failed to push app',
+           logout: 'Failed to logout'
+
+      msgs manifest_missing: 'Application must have a manifest.yml for unattended deployment'
+
+      def install
+        shell :install
+      end
+
+      def validate
+        error :manifest_missing if manifest? && manifest_missing?
+      end
+
+      def login
+        shell :api
+        shell :login
+      end
+
+      def deploy
+        shell :push
+      end
+
+      def finish
+        shell :logout if logout?
+      end
+
+      private
+
+      def push_cmd
+        v3? ? 'v3-push' : 'push'
+      end
+
+      def push_args
+        args = []
+        args << quote(app_name)  if app_name?
+        args << "-f #{manifest}" if manifest?
+        args << "--strategy #{deployment_strategy}" if deployment_strategy?
+        args.join(' ')
+      end
+
+      def skip_ssl_validation_opt
+        '--skip-ssl-validation' if skip_ssl_validation?
+      end
+
+      def manifest_missing?
+        !File.exist?(manifest)
+      end
+    end
+  end
+end