dpl 1.8.48.travis.2486.5 → 1.9.0

data/lib/dpl/provider/bitballoon.rb

@@ -1,22 +0,0 @@
-module DPL
-  class Provider
-    class BitBalloon < Provider
-      requires 'bitballoon'
-
-      def check_auth
-      end
-
-      def needs_key?
-        false
-      end
-
-      def push_app
-        command = 'bitballoon deploy'
-        command << " ./#{option(:local_dir)}" if options.fetch(:local_dir,false)
-        command << " --site-id=#{option(:site_id)}" if options[:site_id]
-        command << " --access-token=#{option(:access_token)}" if options[:access_token]
-        context.shell command
-      end
-    end
-  end
-end

data/lib/dpl/provider/bluemix_cloud_foundry.rb

@@ -1,23 +0,0 @@
-module DPL
-  class Provider
-    class BluemixCloudFoundry < CloudFoundry
-
-      REGIONS = Hash.new {"api.ng.bluemix.net"}.update(
-        "eu-gb" => "api.eu-gb.bluemix.net",
-        "eu-de" => "api.eu-de.bluemix.net",
-        "au-syd" => "api.au-syd.bluemix.net"
-      )
-
-      def set_api
-        region = options[:region] || "ng"
-        options[:api] = options[:api] || REGIONS[region]
-      end
-
-      def check_auth
-        set_api
-        super
-      end
-
-    end
-  end
-end

data/lib/dpl/provider/boxfuse.rb

@@ -1,57 +0,0 @@
-module DPL
-  class Provider
-    class Boxfuse < Provider
-
-      def deploy
-        @user = options[:user]
-        @secret = options[:secret]
-        @configfile = options[:configfile]
-        @payload = options[:payload]
-        @image = options[:image]
-        @env = options[:env]
-        @extra_args = options[:extra_args]
-
-        @param_user = ''
-        if @user.to_s != ''
-          @param_user = " -user=" + @user
-        end
-
-        @param_secret = ''
-        if @secret.to_s != ''
-          @param_secret = " -secret=" + @secret
-        end
-
-        @param_configfile = ''
-        if @configfile.to_s != ''
-          @param_configfile = ' "-configfile=' + @configfile + '"'
-        end
-
-        @param_payload = ''
-        if @payload.to_s != ''
-          @param_payload = ' "' + @payload + '"'
-        end
-
-        @param_image = ''
-        if @image.to_s != ''
-          @param_image = " -image=" + @image
-        end
-
-        @param_env = ' -env=test'
-        if @env.to_s != ''
-          @param_env = " -env=" + @env
-        end
-
-        @param_extra_args = ''
-        if @extra_args.to_s != ''
-          @param_extra_args = " " + @extra_args
-        end
-
-        context.shell "curl -L https://files.boxfuse.com/com/boxfuse/client/boxfuse-commandline/latest/boxfuse-commandline-latest-linux-x64.tar.gz | tar xz"
-
-        @command = "boxfuse/boxfuse run" + @param_user + @param_secret + @param_configfile + @param_payload + @param_image + @param_env + @param_extra_args
-        context.fold("Deploying application") { context.shell @command }
-      end
-
-    end
-  end
-end

data/lib/dpl/provider/catalyze.rb

@@ -1,49 +0,0 @@
-module DPL
-  class Provider
-    class Catalyze < Provider
-      def config
-        {
-            # the git repository to deploy to
-            "target" => options[:target] || context.env['CATALYZE_TARGET'],
-            # the pathspec for files to add to git for deployment e.g. your build directory. defaults to all files.
-            "path" => options[:path] || context.env['CATALYZE_PATH'] || '.'
-        }
-      end
-
-      def needs_key?
-        false
-      end
-
-      def check_app
-      end
-
-      def check_auth
-        error "Missing Catalyze target" unless config['target']
-      end
-
-      def push_app
-        log "Deploying to Catalyze '#{config['target']}'"
-
-        if options[:skip_cleanup]
-          # create commit message
-          build_num = context.env["TRAVIS_BUILD_NUMBER"]
-          commit = context.env["TRAVIS_COMMIT"]
-          repo_slug = context.env["TRAVIS_REPO_SLUG"]
-          branch = context.env["TRAVIS_BRANCH"]
-          if build_num && commit && repo_slug && branch
-            commit_message = "Build ##{build_num} (#{commit}) of #{repo_slug}@#{branch}"
-          else
-            commit_message = "Local build"
-          end
-
-          log "Using build files for deployment"
-          context.shell "git checkout HEAD"
-          context.shell "git add #{config["path"]} --all --force"
-          context.shell "git commit -m \"#{commit_message}\" --quiet"
-        end
-
-        context.shell "git push --force #{config['target']} HEAD:master"
-      end
-    end
-  end
-end

data/lib/dpl/provider/chef_supermarket.rb

@@ -1,85 +0,0 @@
-module DPL
-  class Provider
-    class ChefSupermarket < Provider
-
-      # Most of the code is inspired by:
-      # https://github.com/opscode/chef/blob/11.16.4/lib/chef/knife/cookbook_site_share.rb
-
-      # Compatibility with ruby 1.9
-      requires 'rack', version: '< 2.0'
-      requires 'mime-types', version: '~> 1.16'
-      requires 'chef', version: '< 12.0'
-      requires 'chef', load: 'chef/config'
-      requires 'chef', load: 'chef/cookbook_loader'
-      requires 'chef', load: 'chef/cookbook_uploader'
-      requires 'chef', load: 'chef/cookbook_site_streaming_uploader'
-
-      attr_reader :cookbook_name, :cookbook_category
-      attr_reader :cookbook
-
-      def needs_key?
-        false
-      end
-
-      def check_auth
-        error "Missing user_id option" unless options[:user_id]
-        error "Missing client_key option" unless options[:client_key]
-        ::Chef::Config[:client_key] = options[:client_key]
-        error "#{options[:client_key]} does not exist" unless ::File.exist?(options[:client_key])
-      end
-
-      def check_app
-        @cookbook_name = options[:cookbook_name] || options[:app]
-        @cookbook_category = options[:cookbook_category]
-        unless cookbook_category
-          error "Missing cookbook_category option\n" +
-            "see https://docs.getchef.com/knife_cookbook_site.html#id12"
-        end
-
-        log "Validating cookbook #{cookbook_name}"
-        # Check that cookbook exist and is valid
-        # So we assume cookbook path is '..'
-        cl = ::Chef::CookbookLoader.new '..'
-        @cookbook = cl[cookbook_name]
-        ::Chef::CookbookUploader.new(cookbook, '..').validate_cookbooks
-      end
-
-      def push_app
-        log "Creating cookbook build directory"
-        tmp_cookbook_dir = Chef::CookbookSiteStreamingUploader.create_build_dir(cookbook)
-        log "Making tarball in #{tmp_cookbook_dir}"
-        system("tar -czf #{cookbook_name}.tgz #{cookbook_name}", :chdir => tmp_cookbook_dir)
-
-        uri = "https://supermarket.chef.io/api/v1/cookbooks"
-
-        log "Uploading to #{uri}"
-        category_string = { 'category'=>cookbook_category }.to_json
-        http_resp = ::Chef::CookbookSiteStreamingUploader.post(
-          uri,
-          options[:user_id],
-          options[:client_key],
-          {
-            :tarball => File.open("#{tmp_cookbook_dir}/#{cookbook_name}.tgz"),
-            :cookbook => category_string
-          }
-        )
-        res = ::Chef::JSONCompat.from_json(http_resp.body)
-        if http_resp.code.to_i != 201
-          if res['error_messages']
-            if res['error_messages'][0] =~ /Version already exists/
-              error "The same version of this cookbook already exists on the Opscode Cookbook Site."
-            else
-              error "#{res['error_messages'][0]}"
-            end
-          else
-            error "Unknown error while sharing cookbook\n" +
-              "Server response: #{http_resp.body}"
-          end
-        end
-
-        log "Upload complete."
-        ::FileUtils.rm_rf tmp_cookbook_dir
-      end
-    end
-  end
-end

data/lib/dpl/provider/cloud66.rb

@@ -1,38 +0,0 @@
-require 'net/http'
-require 'net/https'
-
-module DPL
-  class Provider
-    class Cloud66 < Provider
-      def needs_key?
-        false
-      end
-
-      def push_app
-        uri = URI.parse(redeployment_hook)
-
-        response = webhook_call(uri.scheme, uri.host, uri.port, uri.path)
-
-        error("Redeployment failed [#{response.code}]") if response.code != '200'
-      end
-
-      def check_auth
-      end
-
-      private
-
-      def webhook_call(scheme, host, port, path)
-        http = Net::HTTP.new(host, port)
-        http.use_ssl = (scheme.downcase == 'https')
-
-        request = Net::HTTP::Post.new(path)
-
-        return http.request(request)
-      end
-
-      def redeployment_hook
-        option(:redeployment_hook)
-      end
-    end
-  end
-end

data/lib/dpl/provider/cloud_files.rb

@@ -1,38 +0,0 @@
-require 'dpl/provider'
-
-module DPL
-  class Provider
-    class CloudFiles < Provider
-      requires 'net-ssh',    load: 'net/ssh',    version: '~> 2.9.2' # Anything higher requires Ruby 2.x
-      requires 'mime-types', load: 'mime/types', version: '~> 2.6.2' # Anything higher requires Ruby 2.x
-      requires 'nokogiri', version: '~> 1.6.8.1' # 1.7.0 and up requires Ruby 2.1.0 (via fog-xml)
-      requires 'fog-rackspace', load: 'fog/rackspace'
-      experimental 'Rackspace Cloud Files'
-
-      def needs_key?
-        false
-      end
-
-      def api
-        @api ||= Fog::Storage.new(:provider => 'Rackspace', :rackspace_username => option(:username), :rackspace_api_key => option(:api_key), :rackspace_region => option(:region))
-      end
-
-      def check_auth
-        log "Authenticated as #{option(:username)}"
-      end
-
-      def push_app
-        container = api.directories.get(option(:container))
-
-        raise Error, 'The specified container does not exist.' if container.nil?
-
-        glob_args = ['**/*']
-        glob_args << File::FNM_DOTMATCH if options[:dot_match]
-
-        Dir.glob(*glob_args).each do |name|
-          container.files.create(:key => name, :body => File.open(name)) unless File.directory?(name)
-        end
-      end
-    end
-  end
-end

data/lib/dpl/provider/cloud_foundry.rb

@@ -1,43 +0,0 @@
-module DPL
-  class Provider
-    class CloudFoundry < Provider
-
-      def initial_go_tools_install
-        context.shell 'test x$TRAVIS_OS_NAME = "xlinux" && rel="linux64-binary" || rel="macosx64"; wget "https://cli.run.pivotal.io/stable?release=${rel}&source=github" -qO cf.tgz && tar -zxvf cf.tgz && rm cf.tgz'
-      end
-
-      def check_auth
-        initial_go_tools_install
-        context.shell "./cf api #{option(:api)} #{'--skip-ssl-validation' if options[:skip_ssl_validation]}"
-        context.shell "./cf login -u #{option(:username)} -p #{option(:password)} -o #{option(:organization)} -s #{option(:space)}"
-      end
-
-      def check_app
-        if options[:manifest]
-          error 'Application must have a manifest.yml for unattended deployment' unless File.exists? options[:manifest]
-        end
-      end
-
-      def needs_key?
-        false
-      end
-
-      def push_app
-        error 'Failed to push app' unless context.shell("./cf push#{manifest}")
-
-      ensure
-        context.shell "./cf logout"
-      end
-
-      def cleanup
-      end
-
-      def uncleanup
-      end
-
-      def manifest
-        options[:manifest].nil? ? "" : " -f #{options[:manifest]}"
-      end
-    end
-  end
-end

data/lib/dpl/provider/code_deploy.rb

@@ -1,154 +0,0 @@
-require 'json'
-
-module DPL
-  class Provider
-    class CodeDeploy < Provider
-      requires 'aws-sdk', pre: true, version: '~> 2.0'
-
-      def code_deploy
-        @code_deploy ||= Aws::CodeDeploy::Client.new(code_deploy_options)
-      end
-
-      def s3api
-        @s3api ||= Aws::S3::Client.new(code_deploy_options)
-      end
-
-      def code_deploy_options
-        code_deploy_options = {
-          region:      options[:region] || 'us-east-1',
-          credentials: Aws::Credentials.new(access_key_id, secret_access_key)
-        }
-        code_deploy_options[:endpoint] = options[:endpoint] if options[:endpoint]
-        code_deploy_options
-      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 needs_key?
-        false
-      end
-
-      def revision
-        case options[:revision_type].to_s.downcase
-        when "s3"     then s3_revision
-        when "github" then github_revision
-        when ""       then options[:bucket] ? s3_revision : github_revision
-        else error("unknown revision type %p" % options[:revision_type])
-        end
-      end
-
-      def revision_version_info
-        s3api.head_object({
-          bucket: option(:bucket),
-          key: s3_key
-        })
-      rescue Aws::Errors::ServiceError
-        {}
-      end
-
-      def s3_revision
-        info = {
-          revision_type: 'S3',
-          s3_location: {
-            bucket:      option(:bucket),
-            bundle_type: bundle_type,
-            key:         s3_key,
-          }
-        }
-        unless revision_version_info.empty?
-          info[:s3_location][:version] = revision_version_info[:version_id]
-          info[:s3_location][:e_tag]   = revision_version_info[:etag]
-        end
-
-        info
-      end
-
-      def github_revision
-        {
-          revision_type: 'GitHub',
-          git_hub_location: {
-            commit_id:  options[:commit_id]  || context.env['TRAVIS_COMMIT']    || `git rev-parse HEAD`.strip,
-            repository: options[:repository] || context.env['TRAVIS_REPO_SLUG'] || option(:repository)
-          }
-        }
-      end
-
-      def push_app
-        rev = revision()
-        rev_info = rev[:s3_location]
-
-        if rev_info && rev_info[:version]
-          log "Registering app revision with version=#{rev_info[:version]}, etag=#{rev_info[:e_tag]}"
-          code_deploy.register_application_revision({
-            revision:               rev,
-            application_name:       options[:application] || option(:application_name),
-            description:            options[:description] || default_description
-          })
-        end
-
-        data = code_deploy.create_deployment({
-          revision:               revision,
-          application_name:       options[:application]      || option(:application_name),
-          deployment_group_name:  options[:deployment_group] || option(:deployment_group_name),
-          description:            options[:description]      || default_description
-        })
-        log "Triggered deployment #{data.deployment_id.inspect}."
-        return unless options[:wait_until_deployed]
-        print "Deploying "
-        deployment = wait_until_deployed(data[:deployment_id])
-        print "\n"
-        if deployment[:status] == 'Succeeded'
-          log "Deployment successful."
-        else
-          error "Deployment failed."
-        end
-      rescue Aws::CodeDeploy::Errors::DeploymentLimitExceededException => exception
-        error(exception.message)
-      end
-
-      def wait_until_deployed(deployment_id)
-        deployment = {}
-        loop do
-          result = code_deploy.get_deployment(deployment_id: deployment_id)
-          deployment = result[:deployment_info]
-          break if deployment[:status] == "Succeeded" || deployment[:status] == "Failed" || deployment[:status] == "Stopped"
-          print "."
-          sleep 5
-        end
-        deployment
-      end
-
-      def bundle_type
-        if s3_key =~ /\.(tar|tgz|zip)$/
-          options[:bundle_type] || $1
-        else
-          option(:bundle_type)
-        end
-      end
-
-      def s3_key
-        options[:key] || option(:s3_key)
-      end
-
-      def default_description
-        "Deploy build #{context.env['TRAVIS_BUILD_NUMBER']} via Travis CI"
-      end
-
-      def check_auth
-        log "Logging in with Access Key: #{access_key_id[-4..-1].rjust(20, '*')}"
-      end
-
-      def cleanup
-      end
-
-      def uncleanup
-      end
-    end
-  end
-end