dpl 1.10.17.travis.6637.6 → 2.0.0.alpha.1

data/lib/dpl/providers/releases.rb

@@ -0,0 +1,214 @@
+module Dpl
+  module Providers
+    class Releases < Provider
+      status :alpha
+
+      full_name 'GitHub Releases'
+
+      description sq(<<-str)
+        tbd
+      str
+
+      gem 'octokit', '~> 4.14.0'
+      gem 'mime-types', '~> 3.2.2'
+      gem 'public_suffix', '~> 3.0.3'
+
+      required :api_key, [:user, :password]
+
+      opt '--api_key TOKEN', 'GitHub oauth token (needs public_repo or repo permission)', secret: true
+      opt '--username LOGIN', 'GitHub login name', alias: :user
+      opt '--password PASS', 'GitHub password', secret: true
+      opt '--repo SLUG', 'GitHub repo slug', default: :repo_slug
+      opt '--file FILE', 'File to release to GitHub', required: true, type: :array
+      opt '--file_glob', 'Interpret files as globs'
+      opt '--overwrite', 'Overwrite files with the same name'
+      opt '--prerelease', 'Identify the release as a prerelease'
+      opt '--release_number NUM', 'Release number (overide automatic release detection)'
+      opt '--release_notes STR', 'Content for the release notes', alias: :body
+      opt '--release_notes_file PATH', 'Path to a file containing the release notes', note: 'will be ignored if --release_notes is given'
+      opt '--draft', 'Identify the release as a draft'
+      opt '--tag_name TAG', 'Git tag from which to create the release'
+      opt '--target_commitish STR', 'Commitish value that determines where the Git tag is created from'
+      opt '--name NAME', 'Name for the release'
+      # should this have --github_url, like Pages does?
+
+      needs :git
+
+      msgs deploy:               'Deploying to repo: %{slug}',
+           local_tag:            'Current tag is: %{local_tag}',
+           login:                'Authenticated as %s',
+           insufficient_scopes:  'Dpl does not have permission to upload assets. Make sure your token has the repo or public_repo scope.',
+           insufficient_perm:    'Release resource not found. Make sure your token belongs to an account which has push permission to this repo.',
+           overwrite_existing:   'File %s already exists, overwriting.',
+           skip_existing:        'File %s already exists, skipping.',
+           set_tag_name:         'Setting tag_name to %s',
+           set_target_commitish: 'Setting target_commitish to %s',
+           missing_file:         'File %s does not exist.',
+           not_a_file:           '%s is not a file, skipping.'
+
+      cmds git_fetch_tags:       'git fetch --tags'
+
+      URL = 'https://api.github.com/repos/%s/releases/%s'
+
+      OCTOKIT_OPTS = %i(
+        repo
+        name
+        body
+        prerelease
+        release_number
+        tag_name
+        target_commitish
+      )
+
+      TIMEOUTS = {
+        timeout: 180,
+        open_timeout: 180
+      }
+
+      def validate
+        info :deploy
+        shell :git_fetch_tags if env_tag.nil?
+        info :local_tag
+      end
+
+      def login
+        user.login
+        info :login, user.login
+        error :insufficient_scopes unless sufficient_scopes?
+      end
+
+      def deploy
+        upload_files
+        api.update_release(url, octokit_opts)
+      end
+
+      def upload_files
+        files.each { |file| upload_file(file) }
+      end
+
+      def upload_file(file)
+        asset = asset(file)
+        return info :skip_existing, file if asset && !overwrite?
+        delete(asset, file) if asset
+        api.upload_asset(url, file, name: File.basename(file), content_type: content_type(file))
+      end
+
+      def delete(asset, file)
+        info :overwrite_existing, file
+        api.delete_release_asset(asset.url)
+      end
+
+      def octokit_opts
+        opts = with_tag(self.opts.dup)
+        opts = with_target_commitish(opts)
+        opts = opts.select { |key, _| OCTOKIT_OPTS.include?(key) }
+        compact(opts.merge(body: release_notes, draft: draft?))
+      end
+
+      def with_tag(opts)
+        return opts if tag_name? || draft?
+        info :set_tag_name, local_tag
+        opts.merge(tag_name: local_tag)
+      end
+
+      def with_target_commitish(opts)
+        return opts if target_commitish? || !same_repo?
+        info :set_target_commitish, git_sha
+        opts.merge(target_commitish: git_sha)
+      end
+
+      def content_type(file)
+        type = MIME::Types.type_for(file).first
+        type ||= 'application/octet-stream'
+        type.to_s
+      end
+
+      def url
+        if release_number?
+          URL % [slug, release_number]
+        elsif release
+          release.rels[:self].href
+        else
+          create_release.rels[:self].href
+        end
+      end
+
+      def release
+        releases.detect { |release| release.tag_name == local_tag }
+      end
+
+      def create_release
+        api.create_release(slug, local_tag, octokit_opts.merge(draft: true))
+      rescue Octokit::NotFound => nf
+        error :insufficient_perm
+      end
+
+      def local_tag
+        env_tag || git_tag
+      end
+
+      def env_tag
+        tag = ENV['TRAVIS_TAG']
+        tag unless tag.to_s.empty?
+      end
+
+      def sufficient_scopes?
+        api.scopes.include?('public_repo') || api.scopes.include?('repo')
+      end
+
+      def slug
+        repo || repo_slug
+      end
+
+      def same_repo?
+        slug == repo_slug
+      end
+
+      def asset(path)
+        api.release_assets(url).detect { |asset| asset.name == path }
+      end
+
+      def release_notes
+        super || release_notes_file || nil
+      end
+
+      def release_notes_file
+        release_notes_file? && exists?(super) && read(super)
+      end
+
+      def user
+        @user ||= api.user
+      end
+
+      def releases
+        @releases ||= api.releases(slug)
+      end
+
+      def api
+        @api ||= Octokit::Client.new(**creds, auto_paginate: true, connection_options: { request: TIMEOUTS })
+      end
+
+      def creds
+        username && password ? { login: username, password: password } : { access_token: api_key }
+      end
+
+      def files
+        files = file_glob? ? Dir.glob("{#{file.join(',')}}").uniq : file
+        files = files.select { |file| exists?(file) }
+        files.select { |file| file?(file) }
+      end
+
+      def exists?(file)
+        return true if File.exists?(file)
+        error :missing_file, file
+        false
+      end
+
+      def file?(file)
+        return true if File.file?(file)
+        warn :not_a_file, file
+        false
+      end
+    end
+  end
+end

data/lib/dpl/providers/rubygems.rb

@@ -0,0 +1,89 @@
+module Dpl
+  module Providers
+    class Rubygems < Provider
+      status :alpha
+
+      description sq(<<-str)
+        tbd
+      str
+
+      gem 'gems', '~> 1.1.1'
+
+      required :api_key, [:user, :password]
+
+      opt '--api_key KEY', 'Rubygems api key', secret: true
+      opt '--username USER', 'Rubygems user name', alias: :user
+      opt '--password PASS', 'Rubygems password', secret: true
+      opt '--gem NAME', 'Name of the gem to release', default: :repo_name
+      opt '--gemspec FILE', 'Gemspec file to use to build the gem'
+      opt '--gemspec_glob GLOB', 'Glob pattern to search for gemspec files when multiple gems are generated in the repository (overrides the gemspec option)'
+      opt '--host URL'
+
+      msgs login_api_key: 'Authenticating with api key %{api_key}',
+           login_creds:   'Authenticating with username %{username} and password %{password}',
+           setup:         'Setting up host %{host}',
+           gem_lookup:    'Looking up gem %{gem} ... ',
+           gem_found:     'found.',
+           gem_not_found: 'no such gem.',
+           gem_push:      'Pushing gem %{gem}'
+
+      cmds gem_build: 'gem build %{gemspec}'
+
+      errs gem_build: 'Failed to build %{gemspec}'
+
+      def setup
+        return unless host?
+        info :setup
+        Gems.host = host
+      end
+
+      def login
+        api_key? ? login_api_key : login_creds
+      end
+
+      def validate
+        print :gem_lookup
+        name = Gems.info(gem)['name']
+        info name ? :gem_found : :gem_not_found
+      end
+
+      def deploy
+        build
+        push
+      end
+
+      private
+
+        def login_api_key
+          info :login_api_key
+          Gems.key = api_key
+        end
+
+        def login_creds
+          info :login_creds
+          Gems.username, Gems.password = username, password
+        end
+
+        def build
+          Dir[gemspec_glob].each do |gemspec|
+            shell :gem_build, gemspec: gemspec.untaint
+          end
+        end
+
+        def push
+          Dir["#{gem}-*.gem"].each do |file|
+            info :gem_push, gem: file.untaint
+            info Gems.push(File.new(file), *[host].compact)
+          end
+        end
+
+        def gemspec_glob
+          super || "#{gemspec || gem}.gemspec"
+        end
+
+        def gemspec
+          super.gsub('.gemspec', '') if gemspec?
+        end
+    end
+  end
+end

data/lib/dpl/providers/s3.rb

@@ -0,0 +1,243 @@
+require 'uri'
+
+# we want this, don't we?
+Thread.abort_on_exception = true
+
+module Dpl
+  module Providers
+    class S3 < Provider
+      status :alpha
+
+      full_name 'AWS S3'
+
+      description sq(<<-str)
+        tbd
+      str
+
+      gem 'aws-sdk-s3', '~> 1.0'
+      gem 'mime-types', '~> 3.2.2'
+
+      env :aws
+      config '~/.aws/credentials', '~/.aws/config', 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 '--bucket BUCKET', 'S3 bucket', required: true
+      opt '--region REGION', 'S3 region', default: 'us-east-1'
+      opt '--endpoint URL', 'S3 endpoint'
+      opt '--upload_dir DIR', 'S3 directory to upload to'
+      opt '--storage_class CLASS', 'S3 storage class to upload as', default: 'STANDARD', enum: %w(STANDARD STANDARD_IA REDUCED_REDUNDANCY)
+      opt '--server_side_encryption', 'Use S3 Server Side Encryption (SSE-AES256)'
+      opt '--local_dir DIR', 'Local directory to upload from', default: '.', example: '~/travis/build (absolute path) or ./build (relative path)'
+      opt '--detect_encoding', 'HTTP header Content-Encoding for files compressed with gzip and compress utilities'
+      opt '--cache_control STR', 'HTTP header Cache-Control to suggest that the browser cache the file', type: :array, default: 'no-cache', enum: [/^no-cache.*/, /^no-store.*/, /^max-age=\d+.*/, /^s-maxage=\d+.*/, /^no-transform/, /^public/, /^private/], note: 'accepts mapping values to globs', eg: 'public: *.css,*.js'
+      opt '--expires DATE', 'Date and time that the cached object expires', type: :array, format: /^"?\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2} .+"?.*$/, note: 'accepts mapping values to globs', eg: '2020-01-01 00:00:00 UTC: *.css,*.js'
+      opt '--acl ACL', 'Access control for the uploaded objects', default: 'private', enum: %w(private public_read public_read_write authenticated_read bucket_owner_read bucket_owner_full_control)
+      opt '--dot_match', 'Upload hidden files starting with a dot'
+      opt '--index_document_suffix SUFFIX', 'Index document suffix of a S3 website'
+      opt '--default_text_charset CHARSET', 'Default character set to append to the content-type of text files'
+      opt '--max_threads NUM', 'The number of threads to use for S3 file uploads', default: 5, max: 15, type: :integer
+      opt '--overwrite', 'Whether or not to overwrite existing files', default: true
+      opt '--force_path_style', 'Whether to force keeping the bucket name on the path'
+      opt '--verbose', 'Be verbose about uploading files'
+      # how come there is no glob or file option?
+
+      msgs login:                 'Using Access Key: %{access_key_id}',
+           default_uri_schema:    'S3 endpoint does not specify a scheme; defaulting to https',
+           access_denied:         'It looks like you tried to write to a bucket that is not yours or does not exist. Please create the bucket before trying to write to it.',
+           checksum_error:        'AWS secret key does not match the access key id',
+           invalid_access_key_id: 'Invalid S3 access key id',
+           upload:                'Uploading %s files with up to %s threads ...',
+           upload_file:           'Uploading %s to %s with %s',
+           upload_skipped:        'Skipping %{file}, already exists',
+           upload_failed:         'Failed to upload %s',
+           index_document_suffix: 'Setting index document suffix to %s'
+
+      DEFAULT_CONTENT_TYPE = 'application/octet-stream'
+
+      def setup
+        @cwd = Dir.pwd
+        Dir.chdir(local_dir)
+        # Aws.eager_autoload!(services: ['S3'])
+      end
+
+      def login
+        info :login
+      end
+
+      def deploy
+        upload
+        index_document_suffix if index_document_suffix?
+      rescue Aws::S3::Errors::ServiceError => e
+        handle_error(e)
+      end
+
+      def finish
+        Dir.chdir(@cwd) if @cwd
+      end
+
+      private
+
+        def upload
+          info :upload, files.length, max_threads
+          threads = max_threads.times.map { |i| Thread.new(&method(:upload_files)) }
+          threads.each(&:join)
+          info "\n" unless verbose?
+        end
+
+        def upload_files
+          while file = files.pop
+            opts = upload_opts(file)
+            progress(file, opts)
+            upload_file(file, opts)
+          end
+        end
+
+        def progress(file, data)
+          if verbose?
+            info :upload_file, file, upload_dir || '/', to_pairs(data)
+          else
+            print '.'
+          end
+        end
+
+        def upload_file(file, opts)
+          object = bucket.object(upload_path(file))
+          return warn :upload_skipped, file: file if !overwrite && object.exists?
+          info :upload_file, file, upload_dir || '/', to_pairs(opts)
+          object.upload_file(file, opts) || warn(:upload_failed, file)
+        end
+
+        def index_document_suffix
+          info :index_document_suffix, super
+          body = { website_configuration: { index_document: { suffix: super } } }
+          bucket.website.put(body)
+        end
+
+        def upload_path(file)
+          [upload_dir, file].compact.join('/')
+        end
+
+        def upload_opts(file)
+          compact(
+            acl: acl,
+            content_type: content_type(file),
+            content_encoding: detect_encoding? ? encoding(file) : nil,
+            cache_control: match_opt(cache_control, file),
+            expires: match_opt(expires, file),
+            storage_class: storage_class,
+            server_side_encryption: server_side_encryption
+          )
+        end
+
+        def files
+          @files ||= Dir.glob(*glob).reject { |path| File.directory?(path) }
+        end
+
+        def glob
+          ['**/*', dot_match? ? File::FNM_DOTMATCH : nil].compact
+        end
+
+        def acl
+          super.gsub(/_/, '-') if acl?
+        end
+
+        def server_side_encryption
+          'AES256' if server_side_encryption?
+        end
+
+        def content_type(file)
+          return DEFAULT_CONTENT_TYPE unless type = MIME::Types.type_for(file).first
+          type = "#{type}; charset=#{default_text_charset}" if encoding(file) == 'text' && default_text_charset?
+          type.to_s
+        end
+
+        def compact(hash)
+          hash.reject { |_, value| value.nil? }.to_h
+        end
+
+        def endpoint
+          @endpoint ||= normalize_endpoint(super) if endpoint?
+        end
+
+        def normalize_endpoint(url)
+          uri = URI.parse(url)
+          return uri if uri.scheme
+          info :default_uri_scheme
+          URI.parse("https://#{url}")
+        end
+
+        def handle_error(e)
+          case e
+          when Aws::S3::Errors::InvalidAccessKeyId
+            error :invalid_access_key_id
+          when Aws::S3::Errors::ChecksumError
+            error :checksum_error
+          when Aws::S3::Errors::AccessDenied
+            error :access_denied
+          else
+            error e.message
+          end
+        end
+
+        def bucket
+          @bucket ||= Aws::S3::Resource.new(client: client).bucket(super)
+        end
+
+        def client
+          Aws::S3::Client.new(s3_opts)
+        end
+
+        def s3_opts
+          compact(
+            region: region,
+            credentials: credentials,
+            endpoint: endpoint,
+            force_path_style: force_path_style?
+          )
+        end
+
+        def credentials
+          Aws::Credentials.new(access_key_id, secret_access_key)
+        end
+
+        def to_pairs(hash)
+          hash.map { |pair| pair.join('=') }.join(' ')
+        end
+
+        def match_opt(strs, file)
+          maps = Array(strs).map { |str| Mapping.new(str, file) }
+          maps.map(&:value).compact.first
+        end
+
+        class Mapping < Struct.new(:str, :file)
+          MATCH = File::FNM_DOTMATCH | File::FNM_EXTGLOB
+
+          def value
+            str, glob = parse
+            unquote(str) if match?(glob)
+          end
+
+          private
+
+            def unquote(str)
+              str =~ /^"(.*)"$/ && $1 || str
+            end
+
+            def match?(glob)
+              glob.nil? || File.fnmatch?(normalize(glob), file, MATCH)
+            end
+
+            def normalize(glob)
+              return glob if glob.include?('{')
+              "{#{glob.split(',').map(&:strip).join(',')}}"
+            end
+
+            def parse
+              parts = str.split(': ')
+              parts.size > 1 ? [parts[0..-2].join(': '), parts.last] : parts
+            end
+        end
+    end
+  end
+end