shenzhen_fir 0.14.5

data/lib/shenzhen/plugins/hockeyapp.rb

@@ -0,0 +1,119 @@
+require 'json'
+require 'openssl'
+require 'faraday'
+require 'faraday_middleware'
+
+module Shenzhen::Plugins
+  module HockeyApp
+    class Client
+      HOSTNAME = 'upload.hockeyapp.net'
+
+      def initialize(api_token)
+        @api_token = api_token
+        @connection = Faraday.new(:url => "https://#{HOSTNAME}") do |builder|
+          builder.request :multipart
+          builder.request :url_encoded
+          builder.response :json, :content_type => /\bjson$/
+          builder.use FaradayMiddleware::FollowRedirects
+          builder.adapter :net_http
+        end
+      end
+
+      def upload_build(ipa, options)
+        options[:ipa] = Faraday::UploadIO.new(ipa, 'application/octet-stream') if ipa and File.exist?(ipa)
+
+        if dsym_filename = options.delete(:dsym_filename)
+          options[:dsym] = Faraday::UploadIO.new(dsym_filename, 'application/octet-stream')
+        end
+
+        @connection.post do |req|
+          if options[:public_identifier].nil?
+            req.url("/api/2/apps/upload")
+          else
+            req.url("/api/2/apps/#{options.delete(:public_identifier)}/app_versions/upload")
+          end
+          req.headers['X-HockeyAppToken'] = @api_token
+          req.body = options
+        end.on_complete do |env|
+          yield env[:status], env[:body] if block_given?
+        end
+      end
+    end
+  end
+end
+
+command :'distribute:hockeyapp' do |c|
+  c.syntax = "ipa distribute:hockeyapp [options]"
+  c.summary = "Distribute an .ipa file over HockeyApp"
+  c.description = ""
+  c.option '-f', '--file FILE', ".ipa file for the build"
+  c.option '-d', '--dsym FILE', "zipped .dsym package for the build"
+  c.option '-a', '--token TOKEN', "API Token. Available at https://rink.hockeyapp.net/manage/auth_tokens"
+  c.option '-i', '--identifier PUBLIC_IDENTIFIER', "Public identifier of the app you are targeting, if not specified HockeyApp will use the bundle identifier to choose the right"
+  c.option '-m', '--notes NOTES', "Release notes for the build (Default: Textile)"
+  c.option '-r', '--release RELEASE', [:beta, :store, :alpha, :enterprise], "Release type: 0 - Beta, 1 - Store, 2 - Alpha , 3 - Enterprise"
+  c.option '--markdown', 'Notes are written with Markdown'
+  c.option '--tags TAGS', "Comma separated list of tags which will receive access to the build"
+  c.option '--teams TEAMS', "Comma separated list of team ID numbers to which this build will be restricted"
+  c.option '--users USERS', "Comma separated list of user ID numbers to which this build will be restricted"
+  c.option '--notify', "Notify permitted teammates to install the build"
+  c.option '--downloadOff', "Upload but don't allow download of this version just yet"
+  c.option '--mandatory', "Make this update mandatory"
+  c.option '--commit-sha SHA', "The Git commit SHA for this build"
+  c.option '--build-server-url URL', "The URL of the build job on your build server"
+  c.option '--repository-url URL', "The URL of your source repository"
+
+  c.action do |args, options|
+    determine_file! unless @file = options.file
+    say_warning "Missing or unspecified .ipa file" unless @file and File.exist?(@file)
+
+    determine_dsym! unless @dsym = options.dsym
+    say_warning "Specified dSYM.zip file doesn't exist" if @dsym and !File.exist?(@dsym)
+
+    determine_hockeyapp_api_token! unless @api_token = options.token || ENV['HOCKEYAPP_API_TOKEN']
+    say_error "Missing API Token" and abort unless @api_token
+
+    determine_notes! unless @notes = options.notes
+    say_error "Missing release notes" and abort unless @notes
+
+    parameters = {}
+    parameters[:public_identifier] = options.identifier if options.identifier
+    parameters[:notes] = @notes
+    parameters[:notes_type] = options.markdown ? "1" : "0"
+    parameters[:notify] = "1" if options.notify && !options.downloadOff
+    parameters[:status] = options.downloadOff ? "1" : "2"
+    parameters[:tags] = options.tags if options.tags
+    parameters[:teams] = options.teams if options.teams
+    parameters[:users] = options.users if options.users
+    parameters[:dsym_filename] = @dsym if @dsym
+    parameters[:mandatory] = "1" if options.mandatory
+    parameters[:release_type] = case options.release
+                                when :beta
+                                  "0"
+                                when :store
+                                  "1"
+                                when :alpha 
+                                  "2"
+                                when :enterprise
+                                  "3"
+                                end
+    parameters[:commit_sha] = options.commit_sha if options.commit_sha
+    parameters[:build_server_url] = options.build_server_url if options.build_server_url
+    parameters[:repository_url] = options.repository_url if options.repository_url
+
+    client = Shenzhen::Plugins::HockeyApp::Client.new(@api_token)
+    response = client.upload_build(@file, parameters)
+    case response.status
+    when 200...300
+      say_ok "Build successfully uploaded to HockeyApp"
+    else
+      say_error "Error uploading to HockeyApp: #{response.body}"
+    end
+  end
+
+  private
+
+  def determine_hockeyapp_api_token!
+    @api_token ||= ask "API Token:"
+  end
+end

data/lib/shenzhen/plugins/itunesconnect.rb

@@ -0,0 +1,142 @@
+require 'security'
+require 'fileutils'
+require 'digest/md5'
+require 'shellwords'
+
+module Shenzhen::Plugins
+  module ITunesConnect
+    ITUNES_CONNECT_SERVER = 'Xcode:itunesconnect.apple.com'
+
+    class Client
+      attr_reader :ipa, :sdk, :params
+
+      def initialize(ipa, apple_id, sdk, account, password, params = [])
+        @ipa = ipa
+        @apple_id = apple_id
+        @sdk = sdk
+        @account = account
+        @password = password
+        @params = params
+        @filename = File.basename(@ipa).tr(" ", "_")
+      end
+
+      def upload_build!
+        size = File.size(@ipa)
+        checksum = Digest::MD5.file(@ipa)
+
+        begin
+          FileUtils.mkdir_p("Package.itmsp")
+          FileUtils.copy_entry(@ipa, "Package.itmsp/#{@filename}")
+
+          File.write("Package.itmsp/metadata.xml", metadata(@apple_id, checksum, size))
+
+          raise if /(error)|(fail)/i === transport
+        rescue
+          say_error "An error occurred when trying to upload the build to iTunesConnect.\nRun with --verbose for more info." and abort
+        ensure
+          FileUtils.rm_rf("Package.itmsp", :secure => true)
+        end
+      end
+
+      private
+
+      def transport
+        xcode = `xcode-select --print-path`.strip
+        tool = File.join(File.dirname(xcode), "Applications/Application Loader.app/Contents/MacOS/itms/bin/iTMSTransporter").gsub(/\s/, '\ ')
+        tool = File.join(File.dirname(xcode), "Applications/Application Loader.app/Contents/itms/bin/iTMSTransporter").gsub(/\s/, '\ ') if !File.exist?(tool)
+
+        escaped_password = Shellwords.escape(@password)
+        args = [tool, "-m upload", "-f Package.itmsp", "-u #{Shellwords.escape(@account)}", "-p #{escaped_password}"]
+        command = args.join(' ')
+
+        puts command.sub("-p #{escaped_password}", "-p ******") if $verbose
+
+        output = `#{command} 2> /dev/null`
+        puts output.chomp if $verbose
+
+        raise "Failed to upload package to iTunes Connect" unless $?.exitstatus == 0
+
+        output
+      end
+
+      def metadata(apple_id, checksum, size)
+        %{<?xml version="1.0" encoding="UTF-8"?>
+          <package version="software4.7" xmlns="http://apple.com/itunes/importer">
+            <software_assets apple_id="#{apple_id}">
+              <asset type="bundle">
+                <data_file>
+                  <file_name>#{@filename}</file_name>
+                  <checksum type="md5">#{checksum}</checksum>
+                  <size>#{size}</size>
+                </data_file>
+              </asset>
+            </software_assets>
+          </package>
+        }
+      end
+    end
+  end
+end
+
+command :'distribute:itunesconnect' do |c|
+  c.syntax = "ipa distribute:itunesconnect [options]"
+  c.summary = "Upload an .ipa file to iTunes Connect"
+  c.description = "Upload an .ipa file directly to iTunes Connect for review. Requires that the app is in the 'Waiting for upload' state and the --upload flag to be set."
+  c.option '-f', '--file FILE', ".ipa file for the build"
+  c.option '-a', '--account ACCOUNT', "Apple ID used to log into https://itunesconnect.apple.com"
+  c.option '-p', '--password PASSWORD', "Password for the account unless already stored in the keychain"
+  c.option '-u', '--upload', "Actually attempt to upload the build to iTunes Connect"
+  c.option '-w', '--warnings', "Check for warnings when validating the ipa"
+  c.option '-e', '--errors', "Check for errors when validating the ipa"
+  c.option '-i', '--apple-id STRING', "Apple ID from iTunes Connect"
+  c.option '--sdk SDK', "SDK to use when validating the ipa. Defaults to 'iphoneos'"
+  c.option '--save-keychain', "Save the provided account in the keychain for future use"
+
+  c.action do |args, options|
+    options.default :upload => false, :sdk => 'iphoneos', :save_keychain => true
+
+    determine_file! unless @file = options.file
+    say_error "Missing or unspecified .ipa file" and abort unless @file and File.exist?(@file)
+
+    determine_itunes_connect_account! unless @account = options.account || ENV['ITUNES_CONNECT_ACCOUNT']
+    say_error "Missing iTunes Connect account" and abort unless @account
+
+    apple_id = options.apple_id
+    say_error "Missing Apple ID" and abort unless apple_id
+
+    @password = options.password || ENV['ITUNES_CONNECT_PASSWORD']
+    if @password.nil? && @password = Security::GenericPassword.find(:s => Shenzhen::Plugins::ITunesConnect::ITUNES_CONNECT_SERVER, :a => @account)
+      @password = @password.password
+      say_ok "Found password in keychain for account: #{@account}" if options.verbose
+    else
+      determine_itunes_connect_password! unless @password
+      say_error "Missing iTunes Connect password" and abort unless @password
+
+      Security::GenericPassword.add(Shenzhen::Plugins::ITunesConnect::ITUNES_CONNECT_SERVER, @account, @password, {:U => nil}) if options.save_keychain
+    end
+
+    unless /^[0-9a-zA-Z]*$/ === @password
+      say_warning "Password contains special characters, which may not be handled properly by iTMSTransporter. If you experience problems uploading to iTunes Connect, please consider changing your password to something with only alphanumeric characters."
+    end
+
+    parameters = []
+    parameters << :warnings if options.warnings
+    parameters << :errors if options.errors
+
+    client = Shenzhen::Plugins::ITunesConnect::Client.new(@file, apple_id, options.sdk, @account, @password, parameters)
+
+    client.upload_build!
+    say_ok "Upload complete."
+    say_warning "You may want to double check iTunes Connect to make sure it was received correctly."
+  end
+
+  private
+
+  def determine_itunes_connect_account!
+    @account ||= ask "iTunes Connect account:"
+  end
+
+  def determine_itunes_connect_password!
+    @password ||= password "iTunes Connect password:"
+  end
+end

data/lib/shenzhen/plugins/pgyer.rb

@@ -0,0 +1,135 @@
+require 'json'
+require 'openssl'
+require 'faraday'
+require 'faraday_middleware'
+
+module Shenzhen::Plugins
+  module Pgyer
+    class Client
+      HOSTNAME = 'www.pgyer.com'
+
+      def initialize(user_key, api_key)
+        @user_key, @api_key = user_key, api_key
+        @connection = Faraday.new(:url => "http://#{HOSTNAME}", :request => { :timeout => 120 }) do |builder|
+          builder.request :multipart
+          builder.request :json
+          builder.response :json, :content_type => /\bjson$/
+          builder.use FaradayMiddleware::FollowRedirects
+          builder.adapter :net_http
+        end
+      end
+
+      def upload_build(ipa, options)
+        options.update({
+          :uKey => @user_key,
+          :_api_key => @api_key,
+          :file => Faraday::UploadIO.new(ipa, 'application/octet-stream')
+        })
+
+        @connection.post("/apiv1/app/upload", options).on_complete do |env|
+          yield env[:status], env[:body] if block_given?
+        end
+
+      rescue Faraday::Error::TimeoutError
+        say_error "Timed out while uploading build. Check http://www.pgyer.com/my to see if the upload was completed." and abort
+      end
+
+      def update_app_info(options)
+        connection = Faraday.new(:url => "http://#{HOSTNAME}", :request => { :timeout => 120 }) do |builder|
+          builder.request :url_encoded
+          builder.request :json
+          builder.response :logger
+          builder.response :json, :content_type => /\bjson$/
+          builder.use FaradayMiddleware::FollowRedirects
+          builder.adapter :net_http
+        end
+
+        options.update({
+          :uKey => @user_key,
+          :_api_key => @api_key,
+        })
+
+        connection.post("/apiv1/app/update", options) do |env|
+          yield env[:status], env[:body] if block_given?
+        end
+
+      rescue Faraday::Error::TimeoutError
+        say_error "Timed out while uploading build. Check http://www.pgyer.com/my to see if the upload was completed." and abort
+      end
+    end
+  end
+end
+
+command :'distribute:pgyer' do |c|
+  c.syntax = "ipa distribute:pgyer [options]"
+  c.summary = "Distribute an .ipa file over Pgyer"
+  c.description = ""
+  c.option '-f', '--file FILE', ".ipa file for the build"
+  c.option '-a', '--api_key KEY', "API KEY. Available at http://www.pgyer.com/doc/api#uploadApp"
+  c.option '-u', '--user_key KEY', "USER KEY. Available at http://www.pgyer.com/doc/api#uploadApp/"
+  c.option '--range RANGE', "Publish range. e.g. 1 (default), 2, 3"
+  c.option '--[no-]public', "Allow build app on public to download. it is not public default."
+  c.option '--password PASSWORD', "Set password to allow visit app web page."
+
+  c.action do |args, options|
+    determine_file! unless @file = options.file
+    say_error "Missing or unspecified .ipa file" and abort unless @file and File.exist?(@file)
+
+    determine_pgyer_user_key! unless @user_key = options.user_key || ENV['PGYER_USER_KEY']
+    say_error "Missing User Key" and abort unless @user_key
+
+    determine_pgyer_api_key! unless @api_key = options.api_key || ENV['PGYER_API_KEY']
+    say_error "Missing API Key" and abort unless @api_key
+
+    determine_publish_range! unless @publish_range = options.range
+    say_error "Missing Publish Range" and abort unless @publish_range
+
+    determine_is_public! unless @is_public = !!options.public
+    @is_public = @is_public ? 1 : 2
+
+    parameters = {}
+    parameters[:publishRange] = @publish_range
+    parameters[:isPublishToPublic] = @is_public
+    parameters[:password] = options.password.chomp if options.password
+
+    client = Shenzhen::Plugins::Pgyer::Client.new(@user_key, @api_key)
+    response = client.upload_build(@file, parameters)
+    case response.status
+    when 200...300
+      app_id = response.body['appKey']
+      app_short_uri = response.body['appShortcutUrl']
+
+      app_response = client.update_app_info({
+        :aKey => app_id,
+        :appUpdateDescription => @notes
+      })
+
+      if app_response.status == 200
+        say_ok "Build successfully uploaded to Pgyer, visit url: http://www.pgyer.com/#{app_short_uri}"
+      else
+        say_error "Error update build information: #{response.body}" and abort
+      end
+    else
+      say_error "Error uploading to Pgyer: #{response.body}" and abort
+    end
+  end
+
+  private
+
+  def determine_pgyer_api_key!
+    @api_key ||= ask "API Key:"
+  end
+
+  def determine_pgyer_user_key!
+    @user_key ||= ask "User Key:"
+  end
+
+  def determine_publish_range!
+    @publish_range ||= "1"
+  end
+
+  def determine_is_public!
+    @is_public ||= false
+  end
+
+end

data/lib/shenzhen/plugins/rivierabuild.rb

@@ -0,0 +1,81 @@
+require 'json'
+require 'openssl'
+require 'faraday'
+require 'faraday_middleware'
+
+module Shenzhen::Plugins
+  module RivieraBuild
+    class Client
+      HOSTNAME = 'apps.rivierabuild.com'
+
+      def initialize(api_token)
+        @api_token = api_token
+        @connection = Faraday.new(:url => "https://#{HOSTNAME}", :request => { :timeout => 120 }) do |builder|
+          builder.request :multipart
+          builder.request :url_encoded
+          builder.response :json, :content_type => /\bjson$/
+          builder.use FaradayMiddleware::FollowRedirects
+          builder.adapter :net_http
+        end
+      end
+
+      def upload_build(ipa, options)
+        options[:file] = Faraday::UploadIO.new(ipa, 'application/octet-stream') if ipa and File.exist?(ipa)
+
+        @connection.post do |req|
+          req.url("/api/upload")
+          req.body = options
+        end.on_complete do |env|
+          yield env[:status], env[:body] if block_given?
+        end
+      end
+    end
+  end
+end
+
+command :'distribute:rivierabuild' do |c|
+  c.syntax = "ipa distribute:rivierabuild [options]"
+  c.summary = "Distribute an .ipa file over RivieraBuild"
+  c.description = ""
+  c.option '-f', '--file FILE', ".ipa file for the build"
+  c.option '-k', '--key KEY', "API KEY. Available at https://apps.rivierabuild.com/settings"
+  c.option '-a', '--availability AVAILABILITY', "For how long the build will be available? More info: http://api.rivierabuild.com"
+  c.option '-p', '--passcode PASSCODE', "Optional passcode required to install the build on a device"
+  c.option '-n', '--note NOTE', "Release notes for the build, Markdown"
+  c.option '--commit-sha SHA', "The Git commit SHA for this build"
+  c.option '--app-id', "Riviera Build Application ID"
+
+  c.action do |args, options|
+    determine_file! unless @file = options.file
+    say_warning "Missing or unspecified .ipa file" unless @file and File.exist?(@file)
+
+    determine_rivierabuild_api_token! unless @api_token = options.key || ENV['RIVIERA_API_KEY']
+    say_error "Missing API Token" and abort unless @api_token
+
+    determine_availability! unless @availability = options.availability
+    say_error "Missing availability" and abort unless @availability
+
+    parameters = {}
+    parameters[:api_key] = @api_token
+    parameters[:availability] = @availability
+    parameters[:passcode] = options.passcode if options.passcode
+    parameters[:app_id] = options.app_id if options.app_id
+    parameters[:note] = options.note if options.note
+    parameters[:commit_sha] = options.commit_sha if options.commit_sha
+
+    client = Shenzhen::Plugins::RivieraBuild::Client.new(@api_token)
+    response = client.upload_build(@file, parameters)
+    case response.status
+    when 200...300
+      say_ok "Build successfully uploaded to RivieraBuild: #{response.body['file_url']}"
+    else
+      say_error "Error uploading to RivieraBuild: #{response.body}"
+    end
+  end
+
+  private
+
+  def determine_rivierabuild_api_token!
+    @api_token ||= ask "API Key:"
+  end
+end

data/lib/shenzhen/plugins/s3.rb

@@ -0,0 +1,139 @@
+require 'aws-sdk'
+
+module Shenzhen::Plugins
+  module S3
+    class Client
+      def initialize(access_key_id, secret_access_key, region)
+        @s3 = AWS::S3.new(:access_key_id => access_key_id,
+          :secret_access_key => secret_access_key,
+          :region => region)
+      end
+
+      def upload_build(ipa, options)
+        path = expand_path_with_substitutions_from_ipa_plist(ipa, options[:path]) if options[:path]
+
+        @s3.buckets.create(options[:bucket]) if options[:create]
+
+        bucket = @s3.buckets[options[:bucket]]
+
+        uploaded_urls = []
+
+        files = []
+        files << ipa
+        files << options[:dsym] if options[:dsym]
+        files.each do |file|
+          basename = File.basename(file)
+          key = path ? File.join(path, basename) : basename
+          File.open(file) do |descriptor|
+            obj = bucket.objects.create(key, descriptor, :acl => options[:acl])
+            uploaded_urls << obj.public_url.to_s
+          end
+        end
+
+        uploaded_urls
+      end
+
+      private
+
+      def expand_path_with_substitutions_from_ipa_plist(ipa, path)
+        substitutions = path.scan(/\{CFBundle[^}]+\}/)
+        return path if substitutions.empty?
+
+        Dir.mktmpdir do |dir|
+          system "unzip -q #{ipa} -d #{dir} 2> /dev/null"
+
+          plist = Dir["#{dir}/**/*.app/Info.plist"].last
+
+          substitutions.uniq.each do |substitution|
+            key = substitution[1...-1]
+            value = Shenzhen::PlistBuddy.print(plist, key)
+
+            path.gsub!(Regexp.new(substitution), value) if value
+          end
+        end
+
+        return path
+      end
+    end
+  end
+end
+
+command :'distribute:s3' do |c|
+  c.syntax = "ipa distribute:s3 [options]"
+  c.summary = "Distribute an .ipa file over Amazon S3"
+  c.description = ""
+
+  c.example '', '$ ipa distribute:s3 -f ./file.ipa -a accesskeyid --bucket bucket-name'
+
+  c.option '-f', '--file FILE', ".ipa file for the build"
+  c.option '-d', '--dsym FILE', "zipped .dsym package for the build"
+  c.option '-a', '--access-key-id ACCESS_KEY_ID', "AWS Access Key ID"
+  c.option '-s', '--secret-access-key SECRET_ACCESS_KEY', "AWS Secret Access Key"
+  c.option '-b', '--bucket BUCKET', "S3 bucket"
+  c.option '--[no-]create', "Create bucket if it doesn't already exist"
+  c.option '-r', '--region REGION', "Optional AWS region (for bucket creation)"
+  c.option '--acl ACL', "Uploaded object permissions e.g public_read (default), private, public_read_write, authenticated_read"
+  c.option '--source-dir SOURCE', "Optional source directory e.g. ./build"
+  c.option '-P', '--path PATH', "S3 'path'. Values from Info.plist will be substituded for keys wrapped in {}  \n\t\t eg. \"/path/to/folder/{CFBundleVersion}/\" could be evaluated as \"/path/to/folder/1.0.0/\""
+
+  c.action do |args, options|
+    Dir.chdir(options.source_dir) if options.source_dir
+
+    determine_file! unless @file = options.file
+    say_error "Missing or unspecified .ipa file" and abort unless @file and File.exist?(@file)
+
+    determine_dsym! unless @dsym = options.dsym
+    say_error "Specified dSYM.zip file doesn't exist" if @dsym and !File.exist?(@dsym)
+
+    determine_access_key_id! unless @access_key_id = options.access_key_id
+    say_error "Missing AWS Access Key ID" and abort unless @access_key_id
+
+    determine_secret_access_key! unless @secret_access_key = options.secret_access_key
+    say_error "Missing AWS Secret Access Key" and abort unless @secret_access_key
+
+    determine_bucket! unless @bucket = options.bucket
+    say_error "Missing bucket" and abort unless @bucket
+
+    determine_region! unless @region = options.region
+
+    determine_acl! unless @acl = options.acl
+    say_error "Missing ACL" and abort unless @acl
+
+    @path = options.path
+
+    client = Shenzhen::Plugins::S3::Client.new(@access_key_id, @secret_access_key, @region)
+
+    begin
+      urls = client.upload_build @file, {:bucket => @bucket, :create => !!options.create, :acl => @acl, :dsym => @dsym, :path => @path}
+      urls.each { |url| say_ok url}
+      say_ok "Build successfully uploaded to S3"
+    rescue => exception
+      say_error "Error while uploading to S3: #{exception}"
+    end
+  end
+
+  private
+
+  def determine_access_key_id!
+    @access_key_id ||= ENV['AWS_ACCESS_KEY_ID']
+    @access_key_id ||= ask "Access Key ID:"
+  end
+
+  def determine_secret_access_key!
+    @secret_access_key ||= ENV['AWS_SECRET_ACCESS_KEY']
+    @secret_access_key ||= ask "Secret Access Key:"
+  end
+
+  def determine_bucket!
+    @bucket ||= ENV['S3_BUCKET']
+    @bucket ||= ask "S3 Bucket:"
+  end
+
+  def determine_region!
+    @region ||= ENV['AWS_REGION']
+  end
+
+  def determine_acl!
+    @acl ||= "public_read"
+  end
+end