apprepo 0.0.6 → 0.0.8

data/lib/apprepo/runner.rb

@@ -1,64 +1,65 @@
 require_relative 'uploader'
 
 module AppRepo
+  # Responsible for running
   class Runner
     attr_accessor :options
 
     def initialize(options)
-      UI.message('[AppRepo:Runner] Initializing...')
       self.options = options
       AppRepo::DetectValues.new.run!(self.options)
-      # FastlaneCore::PrintTable.print_values(config: options, hide_keys: [:app], mask_keys: ['app_review_information.demo_password'], title: "deliver #{AppRepo::VERSION} Summary")
+      # FastlaneCore::PrintTable.print_values(config: options,
+      # hide_keys: [:app], mask_keys: [],
+      # title: "deliver #{AppRepo::VERSION} Summary")
     end
 
+    # rubocop:disable Metrics/AbcSize
+    # rubocop:disable Metrics/CyclomaticComplexity
     def run
-      UI.success('[AppRepo:Runner] Running!')
-      verify_version if options[:app_version].to_s.length > 0
+      UI.success('AppRepo SFTP Uploader running...')
+      verify_version unless options[:app_version].to_s.empty?
       upload_metadata
-
-      has_binary = (options[:ipa] || options[:pkg])
+      has_binary = options[:ipa]
       if !options[:skip_binary_upload] && !options[:build_number] && has_binary
         upload_binary
       end
-
       UI.success('Finished the upload to AppRepo.')
-
-      notify if options[:notify]
+      notify unless options[:notify].nil?
     end
 
     # Make sure the version on AppRepo matches the one in the ipa
     # If not, the new version will automatically be created
     def verify_version
       app_version = options[:app_version]
-      UI.message("TODO: Make sure the latest version on AppRepo matches '#{app_version}' from the ipa file...")
+      msg = "TODO: Test if AppRepo matches '#{app_version}' from the IPA..."
+      UI.message(msg)
 
       # changed = options[:app].ensure_version!(app_version)
       # if changed
       #  UI.success("Successfully set the version to '#{app_version}'")
       # else
-      #  UI.success("'#{app_version}' is the latest version on iTunes Connect")
+      #  UI.success("'#{app_version}' is the latest version on AppRepo")
       # end
     end
 
-    # Upload all metadata, screenshots, pricing information, etc. to iTunes Connect
+    # Upload all metadata, screenshots, pricing information, etc. to AppRepo
     def upload_metadata
       #
     end
 
-    # Upload the binary to iTunes Connect
+    # Upload the binary to AppRepo
     def upload_binary
-      UI.message('Uploading binary to AppRepo')
       if options[:ipa]
-        AppRepo::Uploader.new(options)
-        # result = transporter.upload(options[:app].apple_id, package_path)
-        # UI.user_error!('Could not upload binary to iTunes Connect. Check out the error above') unless result
+        uploader = AppRepo::Uploader.new(options)
+        result = uploader.upload
+        msg = 'Binary upload failed. Check out the error above'
+        UI.user_error!(msg) unless result
       end
     end
 
     def notify
       # should be in metadata
+      UI.message('TODO: Missing implementation for AppRepo Push Notifier')
     end
-
-    private
   end
 end

data/lib/apprepo/setup.rb

@@ -1,21 +1,21 @@
 module AppRepo
+  # Responsible for setting up the Repofile configuration
   class Setup
     def setup_apprepo(file_path, data, _apprepo_path, _options)
       UI.message('[AppRepo:Setup] Setting up...')
       File.write(file_path, data)
 
       # TODO: implement later
-      # download_metadata(apprepo_path, options)
+      download_manifest(apprepo_path, options)
 
       UI.success("NOT! created new Repofile at path '#{file_path}'")
     end
 
-    # This method takes care of creating a new 'apprepo' folder, containg the app metadata
+    # This method takes care of creating a new 'apprepo' folder with metadata
     # and screenshots folders
     def generate_apprepo_file(_apprepo_path, options)
-      #
       # v = options[:app].latest_version
-      # generate_metadata_files(v, File.join(apprepo_path, 'metadata'))
+      # generate_apprepo_file(v, File.join(apprepo_path, 'manifest.json'))
 
       # Generate the final Repofile here
       gem_path = Helper.gem_path('apprepo')
@@ -24,15 +24,14 @@ module AppRepo
       apprepo.gsub!('[[APPREPO_IPA_PATH]]', options[:app].file_path)
       apprepo.gsub!('[[APP_VERSION]]', options[:app].version)
       apprepo.gsub!('[[APP_NAME]]', options[:app].name)
-      UI.user_error("TODO: ADJUST Repofile'")
-      # deliver => apprepo??
+      # apprepo (was deliver)
     end
 
-    def download_metadata(apprepo_path, _options)
+    def download_manifest(apprepo_path, _options)
       path = File.join(apprepo_path, 'metadata')
       FileUtils.mkdir_p(path)
-      UI.success("TODO: DOWNLOAD METADATA'")
-      # AppRepo::DownloadManifest.run(options, path)
+      UI.success("TODO: DOWNLOAD MANIFEST'")
+      AppRepo::Uploader.download_metadata(options, path)
     end
 
     def run(options)

data/lib/apprepo/uploader.rb

@@ -10,9 +10,11 @@ require 'fastlane_core'
 require 'fastlane_core/languages'
 
 require_relative 'options'
-require_relative 'upload_descriptor' # will deprecate, should have contain Repofile data but it will be in options as expected
 
 module AppRepo
+  # rubocop:disable Metrics/ClassLength
+
+  # Responsible for performing the SFTP operation
   class Uploader
     attr_accessor :options
 
@@ -28,176 +30,258 @@ module AppRepo
     attr_accessor :manifest_path
     attr_accessor :appcode
 
-    def initialize
-      Fastlane::UI.message('[AppRepo:Uploader] Initializing...')
-      self.host = 'repo.teacloud.net'
-      self.user = 'circle'
-      self.password = 'circle'
-      self.rsa_keypath = '../assets/circle.key'
-      self.ipa_path = '../sampleapp.ipa'
-      self.manifest_path = '../assets/example_manifest.json'
-      self.appcode = 'APPREPO'
-      # self.options = options
+    # rubocop:disable Metrics/AbcSize
+    # rubocop:disable Metrics/MethodLength
+    def initialize(options)
+      self.options = options unless options.nil?
+      self.host = options[:repo_url] # 'repo.teacloud.net'
+      self.user = options[:repo_user]
+      self.password = options[:repo_password]
+      self.rsa_keypath = options[:repo_key] # '../assets/circle.key'
+      self.ipa_path = options[:ipa] # '../sampleapp.ipa'
+      self.manifest_path = options[:manifest_path] # '../assets/example_manifest.json'
+      self.appcode = options[:appcode]
+
       # AppRepo::Uploader.new.run!
-      # FastlaneCore::PrintTable.print_values(config: nil , hide_keys: [:app], mask_keys: ['app_review_information.demo_password'], title: "deliver #{AppRepo::VERSION} Summary") # options
+      # FastlaneCore::PrintTable.print_values(config: nil , hide_keys: [:app],
+      # mask_keys: ['app_review_information.demo_password'],
+      # title: "deliver #{AppRepo::VERSION} Summary") # options
     end
 
     #
-    # Main
+    # Upload IPA & manifest
     #
 
-    def run
+    # rubocop:disable Metrics/AbcSize
+    # rubocop:disable Metrics/MethodLength
+    def upload
       # Login & Upload IPA with metadata using RSA key or username/password
-      rsa_key = load_rsa_key(self.rsa_keypath)
+      rsa_key = load_rsa_key(rsa_keypath)
+      success = false
+      if !rsa_key.nil?
+        FastlaneCore::UI.message('Logging in with RSA key...')
+        Net::SSH.start(host, user, key_data: rsa_key, keys_only: true) do |ssh|
+          FastlaneCore::UI.message('Uploading IPA & Manifest...')
+          success = ssh_sftp_upload(ssh, ipa_path, manifest_path)
+        end
+      else
+        FastlaneCore::UI.message('Logging in...')
+        Net::SSH.start(host, user, password: password) do |ssh|
+          self.ssh_session = ssh
+          FastlaneCore::UI.message('Logged in, uploading IPA & Manifest...')
+          success = ssh_sftp_upload(ssh, ipa_path, manifest_path)
+        end
+      end
+      success
+    end
+
+    #
+    # Download metadata only
+    #
+
+    # rubocop:disable Metrics/AbcSize
+    # rubocop:disable Metrics/MethodLength
+    def download_metadata
+      rsa_key = load_rsa_key(rsa_keypath)
       if rsa_key?
-      #if !rsa_key.nil?
-        Fastlane::UI.message('[AppRepo:Uploader] Logging in with RSA key ' + rsa_keypath)
+        FastlaneCore::UI.message('Logging in with RSA key...')
         Net::SSH.start(host, user, key_data: rsa_key, keys_only: true) do |ssh|
-          Fastlane::UI.message('[AppRepo:Uploader] Logged in, uploading UPA & Manifest...')
-          ssh_sftp_upload(ssh, ipa_path, manifest_path)
+          self.ssh_session = ssh
+          FastlaneCore::UI.message('Uploading UPA & Manifest...')
+          ssh_sftp_download(ssh, manifest_path)
         end
       else
-        #  Login with
-        Fastlane::UI.message('[AppRepo:Uploader] Logging in with username ' + user + ' and password *****...')
+        FastlaneCore::UI.message('Logging in...')
         Net::SSH.start(host, user, password: password) do |ssh|
-          Fastlane::UI.message('Logged in, uploading UPA & Manifest...')
-          ssh_sftp_upload(ssh, ipa_path, manifest_path)
+          self.ssh_session = ssh
+          FastlaneCore::UI.message('Logged in, uploading UPA & Manifest...')
+          ssh_sftp_download(ssh, manifest_path)
         end
       end
     end
 
+    private
+
+    def ssh_sftp_download(ssh, local_ipa_path, _manifest_path)
+      ssh.sftp.connect do |sftp|
+        break unless check_ipa(local_ipa_path)
+        FastlaneCore::UI.message('[Downloading] Will start...')
+        manifest = download_manifest(sftp)
+        puts '********************************************************'
+        puts JSON.pretty_generate(manifest)
+        puts '********************************************************'
+      end
+    end
+
     def ssh_sftp_upload(ssh, local_ipa_path, manifest_path)
       ssh.sftp.connect do |sftp|
+        break unless check_ipa(local_ipa_path)
+        check_appcode(sftp, appcode)
+        path = remote_path(appcode)
+        manifest = download_manifest(sftp)
+        puts JSON.pretty_generate(manifest) unless manifest.nil?
+        bump_ipa(sftp, local_ipa_path, appcode)
+        remote_ipa_path = get_remote_ipa_path(local_ipa_path, appcode)
+        upload_ipa(sftp, local_ipa_path, remote_ipa_path)
+        upload_manifest(sftp, manifest_path, remote_manifest_path(appcode))
+        # Lists the entries in a directory for verification
+        sftp.dir.foreach(path) do |entry|
+          FastlaneCore::UI.message(entry.longname)
+        end
+      end
+    end
 
-        ipa_name = File.basename(local_ipa_path)
+    # Check IPA existence locally
+    #
+    # @param local_ipa_path
+    def check_ipa(local_ipa_path)
+      if File.exist?(local_ipa_path)
+        FastlaneCore::UI.important('IPA found at ' + local_ipa_path)
+        return true
+      else
+        FastlaneCore::UI.verbose('IPA at given path does not exist yet.')
+        return false
+      end
+    end
 
-        if File.exist?(local_ipa_path)
-          Fastlane::UI.message('[AppRepo:Uploader] Local IPA found at ' + local_ipa_path)
-        else
-          Fastlane::UI.message('[AppRepo:Uploader] IPA at given path does not exist!')
-          return
-        end
+    # Private methods - Remote Operations
 
-        #
-        # Check/create remote APPCODE directory
-        # @params sftp, appcode;
-        # @callees remote_path()
-        #
-
-        remote_path = get_remote_path + appcode
-        Fastlane::UI.message('[AppRepo:Uploader] Checking APPCODE at: ' + remote_path)
-        remote_mkdir(sftp, remote_path)
-
-        #
-        # Check/fetch remote MANIFEST
-        # @params sftp, appcode;
-        # @callees remote_path()
-        #
-
-        remote_manifest_path = remote_path + '/manifest.json'
-
-        Fastlane::UI.message('[AppRepo:Uploader] Checking remote Manifest.')
-        begin
-          sftp.stat!(remote_manifest_path) do |response|
-            if response.ok?
-              Fastlane::UI.message('Reading existing Manifest.')
-              sftp.file.open(remote_manifest_path, 'w') do |remote_manifest|                
-                manifest = remote_manifest.gets
-                json = JSON.parse(manifest)                
-                UI.message('[AppRepo:Uploader] Opened file from sftp...')
-                puts '****************************************************************'
-                puts json
-                puts '****************************************************************'
+    # Checks/creates remote APPCODE directory
+    # @param sftp
+    # @param [String] appcode
+    def check_appcode(sftp, appcode)
+      path = remote_path(appcode)
+      FastlaneCore::UI.message('Checking APPCODE')
+      remote_mkdir(sftp, path)
+    end
+
+    # Checks/renames remote IPA
+    #
+    # @params sftp
+    # @params [String] local_ipa_path
+    def bump_ipa(sftp, local, appcode)
+      remote = get_remote_ipa_path(local, appcode)
+      FastlaneCore::UI.message('Checking remote IPA')
+      begin
+        sftp.stat!(remote) do |response|
+          if response.ok?
+            begin
+              sftp.rename!(remote, remote + '.bak')
+            rescue
+              begin
+                sftp.remove(remote + '.bak') # may fail if not existent
+                FastlaneCore::UI.message('Removed ' + remote + '.bak')
+              rescue
+                sftp.rename!(remote, remote + '.bak')
+                FastlaneCore::UI.message('Bumped to ' + remote + '.bak')
               end
             end
           end
-        rescue
-          Fastlane::UI.message('[AppRepo:Uploader] No previous Manifest found.')
         end
+      rescue
+        FastlaneCore::UI.message('No previous IPA found.')
+      end
+    end
 
-        #
-        # Check/delete remote (rename from metadata later) IPA
-        # @params sftp, appcode, local_ipa_path, ;
-        # @callees get_remote_ipa_path()
-        #
-
-        remote_ipa_path = get_remote_ipa_path(local_ipa_path)
-        Fastlane::UI.message('[AppRepo:Uploader] Checking remote IPA.')
-        begin
-          sftp.stat!(remote_ipa_path) do |response|
-            if response.ok?
-              Fastlane::UI.message('[AppRepo:Uploader] Removing existing IPA...')
-              sftp.remove!(remote_ipa_path)
-            end
+    # Downloads remote manifest, self.appcode required by options.
+    #
+    # @param sftp
+    # @param [String] remote_path
+    # @returns [JSON] json or nil
+    def download_manifest(sftp)
+      FastlaneCore::UI.message('Checking remote Manifest')
+      json = nil
+      remote_manifest_path = remote_manifest_path(appcode)
+      begin
+        sftp.stat!(remote_manifest_path) do |response|
+          if response.ok?
+            FastlaneCore::UI.success('Loading remote manifest:')
+            manifest = sftp.download!(remote_manifest_path)
+            json = JSON.parse(manifest)
           end
-        rescue
-          Fastlane::UI.message('[AppRepo:Uploader] No previous IPA found.')
         end
+      rescue
+        FastlaneCore::UI.message('No previous Manifest found')
+      end
+      json
+    end
 
-        Fastlane::UI.message('[AppRepo:Uploader] Will upload IPA...')
-
-        #
-        # Upload current manifest.json
-        # @params sftp, local_ipa_path, remote_ipa_path;
-        # @callees get_remote_path()
-        #
-
-        path = File.dirname(__FILE__) + '/' + local_ipa_path
-        Fastlane::UI.message('[AppRepo:Uploader] Uploading IPA: ' + path + ' to path ' + remote_ipa_path)
-        sftp.upload!(path, remote_ipa_path)
-
-        #
-        # Upload current manifest.json
-        # @params sftp, manifest_path, remote_manifest_path;
-        # @callees get_remote_path()
-        #
-
-        Fastlane::UI.message('[AppRepo:Uploader] Uploading Manifest: ' + manifest_path + ' to path ' + remote_manifest_path)
-        sftp.upload!(manifest_path, remote_manifest_path)
-
-        #
-        # Lists the entries in a directory for verification
-        #
+    # Upload current IPA
+    #
+    # @param sftp
+    # @param [String] local_ipa_path
+    # @param [String] remote_ipa_path
+    def upload_ipa(sftp, local_ipa_path, remote_ipa_path)
+      msg = '[Uploading IPA] ' + local_ipa_path + ' to ' + remote_ipa_path
+      FastlaneCore::UI.message(msg)
+      result = sftp.upload!(local_ipa_path, remote_ipa_path) do |event, _uploader, *_args|
+        case event
+        when :open then
+          putc '.'
+        when :put then
+          putc '.'
+          $stdout.flush
+        when :close then
+          puts "\n"
+        when :finish then
+          FastlaneCore::UI.success('Upload successful!')
+        end
+      end
+    end
 
-        sftp.dir.foreach(remote_path) do |entry|
-          Fastlane::UI.message(entry.longname)
+    # Upload current manifest.json
+    #
+    # @param sftp
+    # @param [String] manifest_path
+    # @param [String] remote_manifest_path
+    def upload_manifest(sftp, local_path, remote_path)
+      msg = '[Uploading Manifest] ' + local_path + ' to ' + remote_path
+      FastlaneCore::UI.message(msg)
+      result = sftp.upload!(local_path, remote_path) do |event, _uploader, *_args|
+        case event
+        when :finish then
+          FastlaneCore::UI.success('Upload successful!')
         end
       end
     end
 
-    # Private methods – Remote Operations   
+    def get_remote_ipa_path(local_ipa_path, appcode)
+      remote_path(appcode) + File.basename(local_ipa_path)
+    end
+
+    def remote_path(appcode)
+      generate_remote_path + appcode + '/'
+    end
 
-    def get_remote_ipa_path(ipa_path)
-      path = get_remote_path + appcode + '/' + File.basename(ipa_path)
-      Fastlane::UI.message('[AppRepo:Uploader] remote_ipa_path: ' + path)
-      path
+    def remote_manifest_path(appcode)
+      remote_manifest_path = remote_path(appcode) + 'manifest.json'
     end
 
-    def get_remote_path
-      path = '/home/' + user + '/repo/apps/'
-      Fastlane::UI.message('[AppRepo:Uploader] get_remote_path: ' + path)
-      path
+    def generate_remote_path
+      '/home/' + user + '/repo/apps/'
     end
 
-     def remote_mkdir(sftp, remote_path)
+    def remote_mkdir(sftp, remote_path)
       sftp.mkdir remote_path
     rescue Net::SFTP::StatusException => e
-      if e.code == 11
-        Fastlane::UI.message('[AppRepo:Uploader] Remote directory' + remote_path + ' already exists. OK...')
-      else
-        raise
-      end
+      raise if e.code != 11
+      msg = 'Remote dir ' + remote_path + ' exists.'
+      FastlaneCore::UI.message(msg)
     end
 
-    # Private methods – Local Operations   
+    # Private methods - Local Operations
 
     def load_rsa_key(rsa_keypath)
-      File.open(File.dirname(__FILE__) + '/' + rsa_keypath, 'r') do |file|
+      File.open(rsa_keypath, 'r') do |file|
+        rsa_key = nil
         rsa_key = [file.read]
-        Fastlane::UI.message('[AppRepo:Uploader] Successfully loaded RSA key...') unless rsa_key.nil?
-        return rsa_key
+        if !rsa_key.nil?
+          FastlaneCore::UI.success('Successfully loaded RSA key...')
+        else
+          FastlaneCore::UI.user_error!('Failed to load RSA key...')
+        end
+        rsa_key
       end
     end
-
   end
 end