dpl-connect 1.8.43

data/lib/dpl/provider/scalingo.rb

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

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

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

@@ -0,0 +1,190 @@
+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'
+      require 'tempfile'
+
+
+      VERSION = "0.1"
+      TAG = "-TestFairy-"
+      SERVER = "http://api.testfairy.com"
+      UPLOAD_URL_PATH = "/api/upload";
+      UPLOAD_SIGNED_URL_PATH = "/api/upload-signed";
+
+      def check_auth
+        if android?
+          storepassToPrint = option(:storepass).clone
+          aliasToPrint = option(:alias).clone
+          puts "keystore-file = #{option(:keystore_file)} storepass = #{storepassToPrint.sub! storepassToPrint[1..-2], '****'} alias = #{aliasToPrint.sub! aliasToPrint[1..-2], '****'}"
+        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
+        if android?
+          puts response['instrumented_url']
+          instrumentedFile = download_from_url response['instrumented_url']
+          signedApk = signing_apk instrumentedFile
+          response = upload_signed_apk signedApk
+        end
+        puts "Upload success!, check your build on #{response['build_url']}"
+      end
+
+      def android?
+        option(:app_file).include? "apk"
+      end
+
+
+      private
+
+      def signing_apk(instrumentedFile)
+        signed = Tempfile.new(['instrumented-signed', '.apk'])
+        zipOutput = %x[#{zip_path} -qd #{instrumentedFile} META-INF/*]
+        if zipOutput.include? 'error'
+          raise Error, zipOutput
+        end
+
+        jarSignerOutput = %x[#{jarsigner_path} -keystore #{option(:keystore_file)} -storepass #{option(:storepass)} -digestalg SHA1 -sigalg MD5withRSA #{instrumentedFile} #{option(:alias)}]
+        if jarSignerOutput.include? 'error'
+          raise Error, jarSignerOutput
+        end
+
+        verifyOutput = %x[#{jarsigner_path} -verify  #{instrumentedFile}]
+        if !verifyOutput.include? 'jar verified'
+          raise Error, verifyOutput
+        end
+
+        zipAlignOutput = %x[#{zipalign_path} -f 4 #{instrumentedFile} #{signed.path}]
+
+        puts "signing Apk finished: #{signed.path()}  (file size:#{File.size(signed.path())} )"
+        signed.path()
+      end
+
+      def download_from_url(url)
+        puts "downloading from #{url} "
+        url = "#{url}?api_key=#{option(:api_key)}"
+        uri = URI.parse(url)
+        instrumentedFile = Net::HTTP.start(uri.host, uri.port) do |http|
+          resp = http.get "#{uri.path}?#{uri.query}"
+          if resp.code == "302"
+            resp = Net::HTTP.get_response(URI.parse(resp.header['location']))
+          end
+          file = Tempfile.new(['instrumented', '.apk'])
+          file.write(resp.body)
+          file.flush
+          file
+        end
+        puts "Done #{instrumentedFile.path()}  (file size:#{File.size(instrumentedFile.path())} )"
+        instrumentedFile.path()
+      end
+
+      def upload_app
+        uploadUrl = SERVER + UPLOAD_URL_PATH
+        params = get_params
+        post uploadUrl, params
+      end
+
+      def upload_signed_apk apkPath
+        uploadSignedUrl = SERVER + UPLOAD_SIGNED_URL_PATH
+
+        params = {"api_key" => "#{option(:api_key)}"}
+        add_file_param params , 'apk_file', apkPath
+        add_file_param params, 'symbols_file', options[:symbols_file]
+        add_param params, 'testers-groups', options[:testers_groups]
+        add_boolean_param params, 'notify', options[:notify]
+        add_boolean_param params, 'auto-update', options[:auto_update]
+
+        post uploadSignedUrl, 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, 'advanced-options', options[:advanced_options]
+        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, 'icon-watermark', options[:icon_watermark]
+
+        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
+
+      def zip_path
+        @zip_path ||= %x[which zip].split("\n").first
+      end
+
+      def zipalign_path
+        android_home_path = context.env.fetch('ANDROID_HOME', '/usr')
+        @zipalign_path ||= %x[find -L #{android_home_path} -name zipalign 2>/dev/null].split("\n").first
+      end
+
+      def jarsigner_path
+        java_home_path = context.env.fetch('JAVA_HOME', '/usr')
+        @jarsigner_path ||= %x[find -L #{java_home_path} -name jarsigner 2>/dev/null].split("\n").first
+      end
+    end
+  end
+end

data/lib/dpl/provider/transifex.rb

@@ -0,0 +1,45 @@
+module DPL
+  class Provider
+    class Transifex < Provider
+      experimental 'Transifex'
+
+      DEFAULT_CLIENT_VERSION = '>=0.11'
+      DEFAULT_HOSTNAME = 'https://www.transifex.com'
+
+      def install_deploy_dependencies
+        cli_version = options[:cli_version] || DEFAULT_CLIENT_VERSION
+        self.class.pip 'transifex', 'transifex', cli_version
+      end
+
+      def needs_key?
+        false
+      end
+
+      def check_auth
+        install_deploy_dependencies
+        write_transifexrc
+        context.shell 'tx status'
+      end
+
+      def push_app
+        source_push
+      end
+
+      def write_transifexrc
+        File.open(File.expand_path('~/.transifexrc'), 'w') do |f|
+          f.puts [
+            "[#{options[:hostname] || DEFAULT_HOSTNAME}]",
+            "hostname = #{options[:hostname] || DEFAULT_HOSTNAME}",
+            "username = #{options[:username]}",
+            "password = #{options[:password]}",
+            "token = #{options[:token]}",
+          ].join("\n")
+        end
+      end
+
+      def source_push
+        context.shell 'tx push --source --no-interactive', retry: true
+      end
+    end
+  end
+end

data/lib/dpl/version.rb

@@ -0,0 +1,3 @@
+module DPL
+  VERSION = '1.8.43'
+end

data/notes/engine_yard.md

@@ -0,0 +1 @@
+EY has a a special deploy app. Get in touch with Kevin Holler if we don't hear back from them.

data/notes/heroku.md

@@ -0,0 +1,3 @@
+Heroku might send out emails for new deploy keys (doesn't do it for me, but for some others).
+
+Alternative is Anvil, but it's not perfect, as it duplicates a lot of Heroku logic internally (and failed for me in one case).

data/spec/cli_spec.rb

@@ -0,0 +1,36 @@
+require 'spec_helper'
+require 'dpl/cli'
+
+describe DPL::CLI do
+  describe "#options" do
+    example { expect(described_class.new.options[:app])                           .to eq(File.basename(Dir.pwd)) }
+    example { expect(described_class.new(:app => 'foo')            .options[:app]).to eq('foo')                  }
+    example { expect(described_class.new("--app=foo")              .options[:app]).to eq('foo')                  }
+    example { expect(described_class.new("--app")                  .options[:app]).to eq(true)                   }
+    example { expect(described_class.new("--app=foo", "--app=bar") .options[:app]).to eq(['foo', 'bar'])         }
+
+    example "error handling" do
+      expect($stderr).to receive(:puts).with('invalid option "app"')
+      expect { described_class.new("app") }.to raise_error(SystemExit)
+    end
+  end
+
+  describe "#run" do
+    example "triggers deploy" do
+      provider = double('provider')
+      expect(DPL::Provider).to receive(:new).and_return(provider)
+      expect(provider).to receive(:deploy)
+
+      described_class.run("--provider=foo")
+    end
+
+    example "error handling" do
+      expect($stderr).to receive(:puts).with('missing provider')
+      expect { described_class.run }.to raise_error(SystemExit)
+    end
+
+    example "error handling in debug mode" do
+      expect { described_class.run("--debug") }.to raise_error(DPL::Error, 'missing provider')
+    end
+  end
+end