dpl 1.8.48.travis.2486.5 → 1.9.0

data/lib/dpl/provider/rubygems.rb

@@ -1,51 +0,0 @@
-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

@@ -1,123 +0,0 @@
-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

data/lib/dpl/provider/scalingo.rb

@@ -1,97 +0,0 @@
-require 'net/http'
-require 'uri'
-require 'json'
-require 'date'
-
-module DPL
-  class Provider
-    class Scalingo < Provider
-
-      def install_deploy_dependencies
-        unless context.shell "curl -OL https://cli-dl.scalingo.io/release/scalingo_latest_linux_amd64.tar.gz && tar -zxvf scalingo_latest_linux_amd64.tar.gz && mv scalingo_*_linux_amd64/scalingo . && rm scalingo_latest_linux_amd64.tar.gz && rm -r scalingo_*_linux_amd64"
-          error "Couldn't install Scalingo CLI."
-        end
-      end
-
-      def initialize(context, options)
-        super
-        @options = options
-        @remote = options[:remote] || "scalingo"
-        @branch = options[:branch] || "master"
-      end
-
-      def logged_in
-        context.shell "DISABLE_INTERACTIVE=true ./scalingo login 2> /dev/null > /dev/null"
-      end
-
-      def check_auth
-        if @options[:api_key]
-          unless context.shell "mkdir -p ~/.config/scalingo"
-            error "Couldn't create authentication file."
-          end
-          url = URI.parse('http://api.scalingo.com/v1/users/self')
-          http = Net::HTTP.new(url.host, url.port)
-          request = Net::HTTP::Get.new(url.request_uri)
-          request.basic_auth("", @options[:api_key])
-          request["Accept"] = "application/json"
-          request["Content-type"] = "application/json"
-          response = http.request(request)
-          data = {}
-          if File.exist?("#{Dir.home}/.config/scalingo/auth")
-            data = JSON.parse(File.read("#{Dir.home}/.config/scalingo/auth"))
-          end
-          begin
-            user = JSON.parse(response.body)
-          rescue
-            error "Invalid API token."
-          end
-          data["auth_config_data"] = {}
-          data["auth_config_data"]["api.scalingo.com"] = {}
-          data["auth_config_data"]["api.scalingo.com"]["id"] = user["user"]["id"]
-          data["auth_config_data"]["api.scalingo.com"]["last_name"] = user["user"]["last_name"]
-          data["auth_config_data"]["api.scalingo.com"]["username"] = user["user"]["username"]
-          data["auth_config_data"]["api.scalingo.com"]["email"] = user["user"]["email"]
-          data["auth_config_data"]["api.scalingo.com"]["first_name"] = user["user"]["first_name"]
-          data["auth_config_data"]["api.scalingo.com"]["auth_token"] = @options[:api_key]
-          data["last_update"] = DateTime.now
-          f = File.open("#{Dir.home}/.config/scalingo/auth", "w+") {
-            |f| f.write(data.to_json)
-          }
-        elsif @options[:username] && @options[:password]
-          context.shell "echo -e \"#{@options[:username]}\n#{@options[:password]}\" | timeout 2 ./scalingo login 2> /dev/null > /dev/null"
-        end
-        if !logged_in
-          error "Couldn't connect to Scalingo API."
-        end
-      end
-
-      def setup_key(file, type = nil)
-        if !logged_in
-          error "Couldn't connect to Scalingo API."
-        end
-        unless context.shell "./scalingo keys-add dpl_tmp_key #{file}"
-          error "Couldn't add ssh key."
-        end
-      end
-
-      def remove_key
-        if !logged_in
-          error "Couldn't connect to Scalingo API."
-        end
-        unless context.shell "./scalingo keys-remove dpl_tmp_key"
-          error "Couldn't remove ssh key."
-        end
-      end
-
-      def push_app
-        if @options[:app]
-          context.shell "git remote add #{@remote} git@scalingo.com:#{@options[:app]}.git 2> /dev/null > /dev/null"
-        end
-        unless context.shell "git push #{@remote} #{@branch} -f"
-          error "Couldn't push your app."
-        end
-      end
-
-    end
-  end
-end

data/lib/dpl/provider/script.rb

@@ -1,29 +0,0 @@
-module DPL
-  class Provider
-    class Script < Provider
-
-      experimental 'Script'
-
-      def check_auth
-      end
-
-      def check_app
-      end
-
-      def needs_key?
-        false
-      end
-
-      def push_app
-        context.shell script
-        if $?.exitstatus != 0
-          raise Error, "Script failed with status #{$?.exitstatus}"
-        end
-      end
-
-      def script
-        options[:script]
-      end
-    end
-  end
-end

data/lib/dpl/provider/surge.rb

@@ -1,33 +0,0 @@
-module DPL
-  class Provider
-    class Surge < Provider
-      npm_g 'surge'
-
-      def project
-        File.expand_path( (context.env['TRAVIS_BUILD_DIR'] || '.' ) + "/" + (options[:project] || '') )
-      end
-
-      def domain
-        options[:domain] || ''
-      end
-
-      def check_auth
-        if ! context.env['SURGE_TOKEN'] then raise Error, "Please add SURGE_TOKEN in Travis settings (get your token with 'surge token')" end
-        if ! context.env['SURGE_LOGIN'] then raise Error, "Please add SURGE_LOGIN in Travis settings (its your email)" end
-      end
-
-      def check_app
-      	if ! File.directory?(project) then raise Error, "Please set a valid project folder path in .travis.yml under deploy: project: myPath" end
-      	if domain.empty? && ! File.exist?("#{project}/CNAME") then raise Error, "Please set domain in .travis.yml under deploy: project: myDomain (or in a CNAME file in the repo project folder)" end
-      end
-
-      def needs_key?
-        false
-      end
-
-      def push_app
-        context.shell "surge #{project} #{domain}"
-      end
-    end
-  end
-end

data/lib/dpl/provider/testfairy.rb

@@ -1,111 +0,0 @@
-module DPL
-  class Provider
-    class TestFairy < Provider
-
-      requires "multipart-post", load: 'net/http/post/multipart', version: '2.0.0'
-
-      require "net/http"
-      require 'net/http/post/multipart'
-      require 'json'
-
-
-      VERSION = "0.2"
-      TAG = "-TestFairy-"
-      SERVER = "http://api.testfairy.com"
-      UPLOAD_URL_PATH = "/api/upload";
-
-      def check_auth
-        if !options[:app_file]
-          error 'App file is missing'
-        end
-        puts "api-key = #{option(:api_key).gsub(/[123456789]/, '*')} symbols-file = #{options[:symbols_file]}"
-      end
-
-      def needs_key?
-        false
-      end
-
-      def push_app
-        puts "push_app #{TAG}"
-        response = upload_app
-        puts "Upload success!, check your build on #{response['build_url']}"
-      end
-
-      def android?
-        option(:app_file).include? "apk"
-      end
-
-
-      private
-
-      def upload_app
-        uploadUrl = SERVER + UPLOAD_URL_PATH
-        params = get_params
-        post uploadUrl, params
-      end
-
-      def post url, params
-        puts "Upload parameters = #{get_printable_params params} \nto #{url}"
-        uri = URI.parse(url)
-        request = Net::HTTP::Post::Multipart.new(uri.path, params, 'User-Agent' => "Travis plugin version=#{VERSION}")
-        res = Net::HTTP.start(uri.host, uri.port) do |http|
-          http.request(request)
-        end
-        puts res.body
-        resBody = JSON.parse(res.body)
-        if (resBody['status'] == 'fail')
-          raise Error, resBody['message']
-        end
-        return resBody
-      end
-
-      def get_printable_params params
-        paramsToPrint = params.clone
-        paramsToPrint['api_key'] = paramsToPrint['api_key'].gsub(/[123456789]/, '*')
-        paramsToPrint['apk_file'] = paramsToPrint['apk_file'].path()
-        JSON.pretty_generate(paramsToPrint)
-      end
-
-      def get_params
-        params = {'api_key' => "#{option(:api_key)}"}
-        add_file_param params, 'apk_file', option(:app_file)
-        add_file_param params, 'symbols_file', options[:symbols_file]
-        add_param params, 'video-quality', options[:video_quality]
-        add_param params, 'screenshot-interval', options[:screenshot_interval]
-        add_param params, 'max-duration', options[:max_duration]
-        add_param params, 'testers-groups', options[:testers_groups]
-        add_param params, 'metrics', options[:metrics]
-        add_boolean_param params, 'data-only-wifi', options[:data_only_wifi]
-        add_boolean_param params, 'record-on-background', options[:record_on_background]
-        add_boolean_param params, 'video', options[:video]
-        add_boolean_param params, 'notify', options[:notify]
-        add_boolean_param params, 'auto-update', options[:auto_update]
-
-        travisCommitRange = context.env.fetch('TRAVIS_COMMIT_RANGE',nil)
-        if !travisCommitRange.nil?
-          changelog = %x[git log  --pretty=oneline --abbrev-commit #{travisCommitRange}]
-          add_param params, 'changelog', changelog
-        end
-        params
-      end
-
-      def add_file_param params, fileName, filePath
-        if (!filePath.nil? && !filePath.empty?)
-          params[fileName] = UploadIO.new(File.new(filePath), "", filePath.split("/").last)
-        end
-      end
-
-      def add_param params, paramName, param
-        if (!param.nil? && !param.empty?)
-          params[paramName] = param
-        end
-      end
-
-      def add_boolean_param params, paramName, param
-        if (!param.nil?)
-          params[paramName] = (param == true) ? "on" : "off"
-        end
-      end
-    end
-  end
-end