dpl-connect 1.8.43

data/lib/dpl/provider/pages.rb

@@ -0,0 +1,79 @@
+module DPL
+  class Provider
+    class Pages < Provider
+      """Implements Github Pages deployment
+
+      Options:
+        - repo [optional, for pushed to other repos]
+        - github-token [required]
+        - github-url [optional, defaults to github.com]
+        - target-branch [optional, defaults to gh-pages]
+        - local-dir [optional, defaults to `pwd`]
+        - fqdn [optional]
+        - project-name [optional, defaults to fqdn or repo slug]
+        - email [optional, defaults to deploy@travis-ci.org]
+        - name [optional, defaults to Deployment Bot]
+      """
+
+      require 'tmpdir'
+
+      experimental 'GitHub Pages'
+
+      def initialize(context, options)
+        super
+
+        @build_dir = options[:local_dir] || '.'
+        @project_name = options[:project_name] || fqdn || slug
+        @target_branch = options[:target_branch] || 'gh-pages'
+
+        @gh_fqdn = fqdn
+        @gh_url = options[:github_url] || 'github.com'
+        @gh_token = option(:github_token)
+
+        @gh_email = options[:email] || 'deploy@travis-ci.org'
+        @gh_name = "#{options[:name] || 'Deployment Bot'} (from Travis CI)"
+
+        @gh_ref = "#{@gh_url}/#{slug}.git"
+      end
+
+      def fqdn
+        options.fetch(:fqdn) { nil }
+      end
+
+      def slug
+        options.fetch(:repo) { context.env['TRAVIS_REPO_SLUG'] }
+      end
+
+      def check_auth
+      end
+
+      def needs_key?
+        false
+      end
+
+      def github_deploy
+        context.shell 'rm -rf .git > /dev/null 2>&1'
+        context.shell "touch \"deployed at `date` by #{@gh_name}\""
+        context.shell 'git init' or raise 'Could not create new git repo'
+        context.shell "git config user.email '#{@gh_email}'"
+        context.shell "git config user.name '#{@gh_name}'"
+        context.shell "echo '#{@gh_fqdn}' > CNAME" if @gh_fqdn
+        context.shell 'git add .'
+        context.shell "FILES=\"`git commit -m 'Deploy #{@project_name} to #{@gh_ref}:#{@target_branch}' | tail`\"; echo \"$FILES\"; echo \"$FILES\" | [ `wc -l` -lt 10 ] || echo '...'"
+        context.shell "git push --force --quiet 'https://#{@gh_token}@#{@gh_ref}' master:#{@target_branch} > /dev/null 2>&1"
+      end
+
+      def push_app
+        Dir.mktmpdir {|tmpdir|
+            FileUtils.cp_r("#{@build_dir}/.", tmpdir)
+            FileUtils.cd(tmpdir, :verbose => true) do
+              unless github_deploy
+                error "Couldn't push the build to #{@gh_ref}:#{@target_branch}"
+              end
+            end
+        }
+      end
+
+    end
+  end
+end

data/lib/dpl/provider/puppet_forge.rb

@@ -0,0 +1,43 @@
+module DPL
+  class Provider
+    class PuppetForge < Provider
+      require 'pathname'
+
+      requires 'json_pure', :version => '< 2.0', :load => 'json/pure'
+      requires 'puppet', :load => 'puppet/face'
+      requires 'puppet-blacksmith', :load => 'puppet_blacksmith'
+
+      def modulefile
+        @modulefile ||= Blacksmith::Modulefile.new
+      end
+
+      def forge
+        @forge ||= Blacksmith::Forge.new(options[:user], options[:password], options[:url])
+      end
+
+      def build
+        pmod = Puppet::Face['module', :current]
+        pmod.build('./')
+      end
+
+      def needs_key?
+        false
+      end
+
+      def check_app
+        modulefile.metadata
+      end
+
+      def check_auth
+        raise Error, "must supply a user" unless option(:user)
+        raise Error, "must supply a password" unless option(:password)
+      end
+
+      def push_app
+        build
+        log "Uploading to Puppet Forge #{forge.username}/#{modulefile.name}"
+        forge.push!(modulefile.name)
+      end
+    end
+  end
+end

data/lib/dpl/provider/pypi.rb

@@ -0,0 +1,111 @@
+module DPL
+  class Provider
+    class PyPI < Provider
+      DEFAULT_SERVER = 'https://upload.pypi.org/legacy/'
+      PYPIRC_FILE = '~/.pypirc'
+
+      def pypi_user
+        option(:username, :user) || context.env['PYPI_USER'] || context.env['PYPI_USERNAME']
+      end
+
+      def pypi_password
+        options[:password] || context.env['PYPI_PASSWORD']
+      end
+
+      def pypi_server
+        options[:server] || context.env['PYPI_SERVER'] || DEFAULT_SERVER
+      end
+
+      def pypi_distributions
+        options[:distributions] || context.env['PYPI_DISTRIBUTIONS'] || 'sdist'
+      end
+
+      def pypi_docs_dir_option
+        docs_dir = options[:docs_dir] || context.env['PYPI_DOCS_DIR'] || ''
+        if !docs_dir.empty?
+          '--upload-dir ' + docs_dir
+        end
+      end
+
+      def skip_upload_docs?
+        ! options.has_key?(:skip_upload_docs) ||
+          (options.has_key?(:skip_upload_docs) && options[:skip_upload_docs])
+      end
+
+      def self.install_setuptools
+        shell 'wget https://bootstrap.pypa.io/ez_setup.py -O - | sudo python'
+        shell 'rm -f setuptools-*.zip'
+      end
+
+      def self.install_twine
+        shell("pip install twine", retry: true) if `which twine`.chop.empty?
+      end
+
+      def initialize(*args)
+        super(*args)
+        self.class.pip 'wheel' if pypi_distributions.to_s.include? 'bdist_wheel'
+      end
+
+      install_setuptools
+      install_twine
+
+      def config
+        {
+          :header => '[distutils]',
+          :servers_line => 'index-servers = pypi',
+          :servers => {
+            'pypi' => [
+                         "repository: #{pypi_server}",
+                         "username: #{pypi_user}",
+                         "password: #{pypi_password}",
+                      ]
+          }
+        }
+      end
+
+      def write_servers(f)
+        config[:servers].each do |key, val|
+          f.puts " " * 4 + key
+        end
+
+        config[:servers].each do |key, val|
+          f.puts "[#{key}]"
+          f.puts val
+        end
+      end
+
+      def write_config
+        File.open(File.expand_path(PYPIRC_FILE), 'w') do |f|
+          config.each do |key, val|
+            f.puts(val) if val.is_a? String or val.is_a? Array
+          end
+          write_servers(f)
+        end
+      end
+
+      def check_auth
+        error "missing PyPI username" unless pypi_user
+        error "missing PyPI password" unless pypi_password
+        write_config
+        log "Authenticated as #{pypi_user}"
+      end
+
+      def check_app
+      end
+
+      def needs_key?
+        false
+      end
+
+      def push_app
+        context.shell "python setup.py #{pypi_distributions}"
+        context.shell "twine upload -r pypi dist/*"
+        context.shell "rm -rf dist/*"
+        unless skip_upload_docs?
+          log "Uploading documentation (skip with \"skip_upload_docs: true\")"
+          context.shell "python setup.py upload_docs #{pypi_docs_dir_option} -r #{pypi_server}"
+        end
+      end
+    end
+  end
+end

data/lib/dpl/provider/releases.rb

@@ -0,0 +1,139 @@
+module DPL
+  class Provider
+    class Releases < Provider
+      require 'pathname'
+
+      if RUBY_VERSION >= "2.0.0"
+        requires 'octokit', version: '~> 4.6.2'
+      else
+        requires 'octokit', version: '~> 4.3.0'
+      end
+
+      requires 'mime-types', version: '~> 2.0'
+
+      def travis_tag
+        # Check if $TRAVIS_TAG is unset or set but empty
+        if context.env.fetch('TRAVIS_TAG','') == ''
+          nil
+        else
+          context.env['TRAVIS_TAG']
+        end
+      end
+
+      def get_tag
+        if travis_tag.nil?
+          @tag ||= `git describe --tags --exact-match 2>/dev/null`.chomp
+        else
+          @tag ||= travis_tag
+        end
+      end
+
+      def api
+        if options[:user] and options[:password]
+          @api ||= Octokit::Client.new(:login => options[:user], :password => options[:password])
+        else
+          @api ||= Octokit::Client.new(:access_token => option(:api_key))
+        end
+      end
+
+      def slug
+        options.fetch(:repo) { context.env['TRAVIS_REPO_SLUG'] }
+      end
+
+      def releases
+        @releases ||= api.releases(slug)
+      end
+
+      def user
+        @user ||= api.user
+      end
+
+      def files
+        if options[:file_glob]
+          Array(options[:file]).map do |glob|
+            Dir.glob(glob)
+          end.flatten
+        else
+          Array(options[:file])
+        end
+      end
+
+      def needs_key?
+        false
+      end
+
+      def check_app
+        log "Deploying to repo: #{slug}"
+
+        context.shell 'git fetch --tags' if travis_tag.nil?
+        log "Current tag is: #{get_tag}"
+      end
+
+      def setup_auth
+        user.login
+      end
+
+      def check_auth
+        setup_auth
+
+        unless api.scopes.include? 'public_repo' or api.scopes.include? 'repo'
+          raise Error, "Dpl does not have permission to upload assets. Make sure your token contains the repo or public_repo scope."
+        end
+
+        log "Logged in as #{user.name}"
+      end
+
+      def push_app
+        tag_matched = false
+        release_url = nil
+
+        if options[:release_number]
+          tag_matched = true
+          release_url = "https://api.github.com/repos/" + slug + "/releases/" + options[:release_number]
+        else
+          releases.each do |release|
+            if release.tag_name == get_tag
+              release_url = release.rels[:self].href
+              tag_matched = true
+            end
+          end
+        end
+
+        #If for some reason GitHub hasn't already created a release for the tag, create one
+        if tag_matched == false
+          release_url = api.create_release(slug, get_tag, options.merge({:draft => true})).rels[:self].href
+        end
+
+        files.each do |file|
+          existing_url = nil
+          filename = Pathname.new(file).basename.to_s
+          api.release(release_url).rels[:assets].get.data.each do |existing_file|
+            if existing_file.name == filename
+              existing_url = existing_file.url
+            end
+          end
+          if !existing_url
+            upload_file(file, filename, release_url)
+          elsif existing_url && options[:overwrite]
+            log "#{filename} already exists, overwriting."
+            api.delete_release_asset(existing_url)
+            upload_file(file, filename, release_url)
+          else
+            log "#{filename} already exists, skipping."
+          end
+        end
+
+        api.update_release(release_url, {:draft => false}.merge(options))
+      end
+
+      def upload_file(file, filename, release_url)
+        content_type = MIME::Types.type_for(file).first.to_s
+        if content_type.empty?
+          # Specify the default content type, as it is required by GitHub
+          content_type = "application/octet-stream"
+        end
+        api.upload_asset(release_url, file, {:name => filename, :content_type => content_type})
+      end
+    end
+  end
+end

data/lib/dpl/provider/rubygems.rb

@@ -0,0 +1,51 @@
+module DPL
+  class Provider
+    class RubyGems < Provider
+      requires 'gems', version: '>= 0.8.3'
+
+      def setup_auth
+        ::Gems.key = option(:api_key) if options[:api_key]
+        ::Gems.username = option(:user) unless options[:api_key]
+        ::Gems.password = option(:password) unless options[:api_key]
+      end
+
+      def needs_key?
+        false
+      end
+
+      def setup_gem
+        options[:gem] ||= options[:app]
+      end
+
+      def gemspec
+        options[:gemspec].gsub('.gemspec', '') if options[:gemspec]
+      end
+
+      def check_app
+        setup_auth
+        setup_gem
+        log "Looking up gem #{options[:gem]}"
+        info = ::Gems.info(options[:gem])
+        log "Found gem #{info['name']}"
+      end
+
+      def check_auth
+        setup_auth
+        log "Authenticated with username #{::Gems.username}" if ::Gems.username
+      end
+
+      def push_app
+        setup_auth
+        setup_gem
+        context.shell "gem build #{gemspec || option(:gem)}.gemspec"
+        Dir.glob("#{gemspec || option(:gem)}-*.gem") do |f|
+          if options[:host]
+            log ::Gems.push(File.new(f), options[:host])
+          else
+            log ::Gems.push(File.new f)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/dpl/provider/s3.rb

@@ -0,0 +1,123 @@
+require 'json'
+
+module DPL
+  class Provider
+    class S3 < Provider
+      requires 'aws-sdk', version: '~> 2.0'
+      requires 'mime-types', version: '~> 2.0'
+
+      def api
+        @api ||= ::Aws::S3::Resource.new(s3_options)
+      end
+
+      def needs_key?
+        false
+      end
+
+      def check_app
+        log 'Warning: The endpoint option is no longer used and can be removed.' if options[:endpoint]
+      end
+
+      def access_key_id
+        options[:access_key_id] || context.env['AWS_ACCESS_KEY_ID'] || raise(Error, "missing access_key_id")
+      end
+
+      def secret_access_key
+        options[:secret_access_key] || context.env['AWS_SECRET_ACCESS_KEY'] || raise(Error, "missing secret_access_key")
+      end
+
+      def s3_options
+        {
+          region:      options[:region] || 'us-east-1',
+          credentials: ::Aws::Credentials.new(access_key_id, secret_access_key)
+        }
+      end
+
+      def check_auth
+        log "Logging in with Access Key: #{access_key_id[-4..-1].rjust(20, '*')}"
+      end
+
+      def upload_path(filename)
+        [options[:upload_dir], filename].compact.join("/")
+      end
+
+      def push_app
+        glob_args = ["**/*"]
+        glob_args << File::FNM_DOTMATCH if options[:dot_match]
+        Dir.chdir(options.fetch(:local_dir, Dir.pwd)) do
+          Dir.glob(*glob_args) do |filename|
+            opts                          = content_data_for(filename)
+            opts[:cache_control]          = get_option_value_by_filename(options[:cache_control], filename) if options[:cache_control]
+            opts[:acl]                    = options[:acl].gsub(/_/, '-') if options[:acl]
+            opts[:expires]                = get_option_value_by_filename(options[:expires], filename) if options[:expires]
+            opts[:storage_class]          = options[:storage_class] if options[:storage_class]
+            opts[:server_side_encryption] = "AES256" if options[:server_side_encryption]
+            unless File.directory?(filename)
+              log "uploading #{filename.inspect} with #{opts.inspect}"
+              result = api.bucket(option(:bucket)).object(upload_path(filename)).upload_file(filename, opts)
+              warn "error while uploading #{filename.inspect}" unless result
+            end
+          end
+        end
+
+        if suffix = options[:index_document_suffix]
+          api.bucket(option(:bucket)).website.put(
+            website_configuration: {
+              index_document: {
+                suffix: suffix
+              }
+            }
+          )
+        end
+      end
+
+      def deploy
+        super
+      rescue ::Aws::S3::Errors::InvalidAccessKeyId
+        raise Error, "Invalid S3 Access Key Id, Stopping Deploy"
+      rescue ::Aws::S3::Errors::ChecksumError
+        raise Error, "Aws Secret Key does not match Access Key Id, Stopping Deploy"
+      rescue ::Aws::S3::Errors::AccessDenied
+        raise Error, "Oops, It looks like you tried to write to a bucket that isn't yours or doesn't exist yet. Please create the bucket before trying to write to it."
+      end
+
+      private
+      def content_data_for(path)
+        content_data = {}
+        content_type = MIME::Types.type_for(path).first
+        content_data[:content_type] = content_type.to_s
+
+        encoding = encoding_for(path)
+        if detect_encoding?
+          content_data[:content_encoding] = encoding if encoding
+        end
+
+        if encoding == 'text' && default_text_charset?
+          content_data[:content_type] = "#{content_data[:content_type]}; charset=#{default_text_charset}"
+        end
+
+        return content_data
+      end
+
+      def get_option_value_by_filename(option_values, filename)
+        return option_values if !option_values.kind_of?(Array)
+        preferred_value = nil
+        hashes = option_values.select {|value| value.kind_of?(Hash) }
+        hashes.each do |hash|
+          hash.each do |value, patterns|
+            unless patterns.kind_of?(Array)
+              patterns = [patterns]
+            end
+            patterns.each do |pattern|
+              if File.fnmatch?(pattern, filename)
+                preferred_value = value
+              end
+            end
+          end
+        end
+        preferred_value = option_values.select {|value| value.kind_of?(String) }.last if preferred_value.nil?
+        return preferred_value
+      end
+    end
+  end
+end