lg_pod_plugin 1.1.6.7 → 1.1.7.3

data/lib/lg_pod_plugin/downloader/overload_cache.rb

@@ -0,0 +1,329 @@
+# frozen_string_literal: true
+
+require 'cocoapods'
+require 'fileutils'
+require 'tmpdir'
+
+module Pod
+  module Downloader
+    # The class responsible for managing Pod downloads, transparently caching
+    # them in a cache directory.
+    #
+    class Cache
+      # @return [Pathname] The root directory where this cache store its
+      #         downloads.
+      #
+      attr_reader :root
+
+      # Initialize a new instance
+      #
+      # @param  [Pathname,String] root
+      #         see {#root}
+      #
+      def initialize(root)
+        @root = Pathname(root)
+        ensure_matching_version
+      end
+
+      # Downloads the Pod from the given `request`
+      #
+      # @param  [Request] request
+      #         the request to be downloaded.
+      #
+      # @return [Response] the response from downloading `request`
+      #
+      def download_pod(request)
+        cached_pod(request) || uncached_pod(request)
+      rescue Informative
+        raise
+      rescue
+        UI.puts("\n[!] Error installing #{request.name}".red)
+        raise
+      end
+
+      # @return [Hash<String, Hash<Symbol, String>>]
+      #         A hash whose keys are the pod name
+      #         And values are a hash with the following keys:
+      #         :spec_file : path to the spec file
+      #         :name      : name of the pod
+      #         :version   : pod version
+      #         :release   : boolean to tell if that's a release pod
+      #         :slug      : the slug path where the pod cache is located
+      #
+      def cache_descriptors_per_pod
+        specs_dir = root + 'Specs'
+        release_specs_dir = specs_dir + 'Release'
+        return {} unless specs_dir.exist?
+
+        spec_paths = specs_dir.find.select { |f| f.fnmatch('*.podspec.json') }
+        spec_paths.reduce({}) do |hash, spec_path|
+          spec = Specification.from_file(spec_path)
+          hash[spec.name] ||= []
+          is_release = spec_path.to_s.start_with?(release_specs_dir.to_s)
+          request = Downloader::Request.new(:spec => spec, :released => is_release)
+          hash[spec.name] << {
+            :spec_file => spec_path,
+            :name => spec.name,
+            :version => spec.version,
+            :release => is_release,
+            :slug => root + request.slug,
+          }
+          hash
+        end
+      end
+
+      # Convenience method for acquiring a shared lock to safely read from the
+      # cache. See `Cache.lock` for more details.
+      #
+      # @param  [Pathname] location
+      #         the path to require a lock for.
+      #
+      # @param  [block] &block
+      #         the block to execute inside the lock.
+      #
+      # @return [void]
+      #
+      def self.read_lock(location, &block)
+        Cache.lock(location, File::LOCK_SH, &block)
+      end
+
+      # Convenience method for acquiring an exclusive lock to safely write to
+      # the cache. See `Cache.lock` for more details.
+      #
+      # @param  [Pathname] location
+      #         the path to require a lock for.
+      #
+      # @param  [block] &block
+      #         the block to execute inside the lock.
+      #
+      # @return [void]
+      #
+      def self.write_lock(location, &block)
+        Cache.lock(location, File::LOCK_EX, &block)
+      end
+
+      # Creates a .lock file at `location`, aquires a lock of type
+      # `lock_type`, checks that it is valid, and executes passed block while
+      # holding on to that lock. Afterwards, the .lock file is deleted, which is
+      # why validation of the lock is necessary, as you might have a lock on a
+      # file that doesn't exist on the filesystem anymore.
+      #
+      # @param  [Pathname] location
+      #         the path to require a lock for.
+      #
+      # @param  [locking_constant] lock_type
+      #         the type of lock, either exclusive (File::LOCK_EX) or shared
+      #         (File::LOCK_SH).
+      #
+      # @return [void]
+      #
+      def self.lock(location, lock_type)
+        raise ArgumentError, 'no block given' unless block_given?
+        lockfile = "#{location}.lock"
+        f = nil
+        loop do
+          f.close if f
+          f = File.open(lockfile, File::CREAT, 0o644)
+          f.flock(lock_type)
+          break if Cache.valid_lock?(f, lockfile)
+        end
+        begin
+          yield location
+        ensure
+          if lock_type == File::LOCK_SH
+            f.flock(File::LOCK_EX)
+            File.delete(lockfile) if Cache.valid_lock?(f, lockfile)
+          else
+            File.delete(lockfile)
+          end
+          f.close
+        end
+      end
+
+      # Checks that the lock is on a file that still exists on the filesystem.
+      #
+      # @param  [File] file
+      #         the actual file that we have a lock for.
+      #
+      # @param  [String] filename
+      #         the filename of the file that we have a lock for.
+      #
+      # @return [Boolean]
+      #         true if `filename` still exists and is the same file as `file`
+      #
+      def self.valid_lock?(file, filename)
+        file.stat.ino == File.stat(filename).ino
+      rescue Errno::ENOENT
+        false
+      end
+
+      private
+
+      # Ensures the cache on disk was created with the same CocoaPods version as
+      # is currently running.
+      #
+      # @return [Void]
+      #
+      def ensure_matching_version
+        version_file = root + 'VERSION'
+        if version_file.file?
+          version = version_file.read.strip
+        else
+          version = Pod::VERSION
+        end
+        pod_version = %x(bundle exec pod --version).split("\n").first
+        if version != pod_version
+          version = pod_version
+          version_file.open('w') { |f| f << version }
+        end
+      end
+
+      # @param  [Request] request
+      #         the request to be downloaded.
+      #
+      # @param  [Hash<Symbol,String>] slug_opts
+      #         the download options that should be used in constructing the
+      #         cache slug for this request.
+      #
+      # @return [Pathname] The path for the Pod downloaded from the given
+      #         `request`.
+      #
+      def path_for_pod(request, slug_opts = {})
+        root + request.slug(**slug_opts)
+      end
+
+      # @param  [Request] request
+      #         the request to be downloaded.
+      #
+      # @param  [Hash<Symbol,String>] slug_opts
+      #         the download options that should be used in constructing the
+      #         cache slug for this request.
+      #
+      # @return [Pathname] The path for the podspec downloaded from the given
+      #         `request`.
+      #
+      def path_for_spec(request, slug_opts = {})
+        path = root + 'Specs' + request.slug(**slug_opts)
+        Pathname.new(path.to_path + '.podspec.json')
+      end
+
+      # @param  [Request] request
+      #         the request to be downloaded.
+      #
+      # @return [Response] The download response for the given `request` that
+      #         was found in the download cache.
+      #
+      def cached_pod(request)
+        cached_spec = cached_spec(request)
+        path = path_for_pod(request)
+
+        return unless cached_spec && path.directory?
+        spec = request.spec || cached_spec
+        Response.new(path, spec, request.params)
+      end
+
+      # @param  [Request] request
+      #         the request to be downloaded.
+      #
+      # @return [Specification] The cached specification for the given
+      #         `request`.
+      #
+      def cached_spec(request)
+        path = path_for_spec(request)
+        path.file? && Specification.from_file(path)
+      rescue JSON::ParserError
+        nil
+      end
+
+      # @param  [Request] request
+      #         the request to be downloaded.
+      #
+      # @return [Response] The download response for the given `request` that
+      #         was not found in the download cache.
+      #
+      def uncached_pod(request)
+        in_tmpdir do |target|
+          result, podspecs = download(request, target)
+          result.location = nil
+
+          podspecs.each do |name, spec|
+            destination = path_for_pod(request, :name => name, :params => result.checkout_options)
+            copy_and_clean(target, destination, spec)
+            write_spec(spec, path_for_spec(request, :name => name, :params => result.checkout_options))
+            if request.name == name
+              result.location = destination
+            end
+          end
+
+          result
+        end
+      end
+
+      def download(request, target)
+        Downloader.download_request(request, target)
+      end
+
+      # Performs the given block inside a temporary directory,
+      # which is removed at the end of the block's scope.
+      #
+      # @return [Object] The return value of the given block
+      #
+      def in_tmpdir(&blk)
+        tmpdir = Pathname(Dir.mktmpdir)
+        blk.call(tmpdir)
+      ensure
+        FileUtils.remove_entry(tmpdir, :force => true) if tmpdir && tmpdir.exist?
+      end
+
+      # Copies the `source` directory to `destination`, cleaning the directory
+      # of any files unused by `spec`.
+      #
+      # @param  [Pathname] source
+      #
+      # @param  [Pathname] destination
+      #
+      # @param  [Specification] spec
+      #
+      # @return [Void]
+      #
+      def copy_and_clean(source, destination, spec)
+        specs_by_platform = group_subspecs_by_platform(spec)
+        destination.parent.mkpath
+        Cache.write_lock(destination) do
+          FileUtils.rm_rf(destination)
+          FileUtils.cp_r(source, destination)
+          Pod::Installer::PodSourcePreparer.new(spec, destination).prepare!
+          Sandbox::PodDirCleaner.new(destination, specs_by_platform).clean!
+        end
+      end
+
+      def group_subspecs_by_platform(spec)
+        specs_by_platform = {}
+        [spec, *spec.recursive_subspecs].each do |ss|
+          ss.available_platforms.each do |platform|
+            specs_by_platform[platform] ||= []
+            specs_by_platform[platform] << ss
+          end
+        end
+        specs_by_platform
+      end
+
+      # Writes the given `spec` to the given `path`.
+      #
+      # @param  [Specification] spec
+      #         the specification to be written.
+      #
+      # @param  [Pathname] path
+      #         the path the specification is to be written to.
+      #
+      # @return [Void]
+      #
+      def write_spec(spec, path)
+        path.dirname.mkpath
+        Cache.write_lock(path) do
+          path.open('w') { |f| f.write spec.to_pretty_json }
+        end
+      end
+    end
+  end
+end

data/lib/lg_pod_plugin/downloader/request.rb

@@ -1,5 +1,4 @@
 require 'net/http'
-# require 'singleton'
 require 'cocoapods-core'
 
 module LgPodPlugin
@@ -13,7 +12,7 @@ module LgPodPlugin
     attr_accessor :config
     attr_accessor :net_ping
     attr_accessor :params
-    attr_accessor :lockfile
+    # attr_accessor :lockfile
     attr_accessor :checkout_options
     def initialize(pod)
       @name = pod.name
@@ -50,9 +49,9 @@ module LgPodPlugin
     end
 
     public
-    def get_lockfile
-      self.lockfile = LgPodPlugin::LockfileModel.from_file
-    end
+    # def get_lockfile
+      # self.lockfile = LgPodPlugin::LockfileModel.from_file
+    # end
 
     # 获取缓存用的hash_map
     public
@@ -68,16 +67,17 @@ module LgPodPlugin
       tag = options[:tag] ||= self.params[:tag]
       branch = options[:branch] ||= self.params[:branch]
       commit = options[:commit] ||= self.params[:commit]
-      return hash_map unless git
+      return nil unless git
       hash_map[:git] = git
-      if git && commit
+      if git &&  commit
         hash_map[:commit] = commit
+        return  hash_map
       elsif git && tag
         hash_map[:tag] = tag
-      elsif git && branch && commit
-        hash_map[:commit] = commit
+        return  hash_map
+      else
+        return {:git => git}
       end
-      hash_map
     end
 
     public
@@ -111,9 +111,9 @@ module LgPodPlugin
 
     #获取下载参数
     def get_request_params
-      unless self.lockfile
-        self.lockfile = self.get_lockfile
-      end
+      # unless self.lockfile
+      #   self.lockfile = self.get_lockfile
+      # end
       Hash.new.merge!(self.get_lock_params)
     end
 
@@ -124,28 +124,28 @@ module LgPodPlugin
       return [nil, nil] unless (ip && network_ok)
       if branch
         new_commit, _ = GitLabAPI.request_github_refs_heads git, branch, self.net_ping.uri
-        unless new_commit
-          id = LPodLatestRefs.get_pod_id(name, git, branch)
-          pod_info = LSqliteDb.shared.query_pod_refs(id)
-          new_commit = pod_info ? pod_info.commit : nil
-          return [branch, new_commit]
-        end
-        if new_commit
-          LSqliteDb.shared.insert_pod_refs(name, git, branch, nil, new_commit)
-        end
+        # unless new_commit
+        #   id = LPodLatestRefs.get_pod_id(name, git, branch)
+        #   pod_info = LSqliteDb.shared.query_pod_refs(id)
+        #   new_commit = pod_info ? pod_info.commit : nil
+        #   return [branch, new_commit]
+        # end
+        # if new_commit
+        #   LSqliteDb.shared.insert_pod_refs(name, git, branch, nil, new_commit)
+        # end
         [branch, new_commit]
       else
         new_commit, new_branch = GitLabAPI.request_github_refs_heads git, nil, self.net_ping.uri
-        unless new_commit
-          id = LPodLatestRefs.get_pod_id(name, git, "HEAD")
-          pod_info = LSqliteDb.shared.query_pod_refs(id)
-          new_commit = pod_info ? pod_info.commit : nil
-          new_branch = pod_info ? pod_info.branch : nil
-          return [new_branch, new_commit]
-        end
-        if new_commit
-          LSqliteDb.shared.insert_pod_refs(name, git, "HEAD", nil, new_commit)
-        end
+        # unless new_commit
+        #   id = LPodLatestRefs.get_pod_id(name, git, "HEAD")
+        #   pod_info = LSqliteDb.shared.query_pod_refs(id)
+        #   new_commit = pod_info ? pod_info.commit : nil
+        #   new_branch = pod_info ? pod_info.branch : nil
+        #   return [new_branch, new_commit]
+        # end
+        # if new_commit
+        #   LSqliteDb.shared.insert_pod_refs(name, git, "HEAD", nil, new_commit)
+        # end
         [new_branch, new_commit]
       end
     end

data/lib/lg_pod_plugin/git/gitlab_api.rb

@@ -9,7 +9,6 @@ module LgPodPlugin
 
     # 通过读取本地文件获取 access_token
     def self.get_gitlab_access_token(uri, user_id)
-      text = LUtils.encrypt("AzfAjh-xTzyRBXmYuGBr", "AZMpxzVxzbo3sFDLRZMpxzVxzbo3sFDZ")
       db_path = LFileManager.download_director.join("database")
       db_path.mkdir unless db_path.exist?
       token_file = db_path.join("access_token.json")
@@ -48,9 +47,9 @@ module LgPodPlugin
     # 检查 token 是否在有效期内
     def self.check_gitlab_access_token_valid(uri, user_info)
       time_now = Time.now.to_i
+      refresh_token = user_info.refresh_token
       # 判断 token 是否失效
-      if user_info.expires_in <= time_now
-        refresh_token = user_info.refresh_token
+      if user_info.expires_in  <= time_now
         if refresh_token.nil? || refresh_token == "" # 使用本地令牌访问
           project_name = LUtils.get_git_project_name(uri.to_s)
           token_vaild = GitLabAPI.request_user_emails(uri.hostname, user_info.access_token)
@@ -65,21 +64,28 @@ module LgPodPlugin
           end
         else
           # 刷新 token 失败时, 通过已经保存的用户名密码来刷新 token
-          new_user_info = GitLabAPI.refresh_gitlab_access_token uri.hostname, refresh_token
-          if new_user_info.nil?
-            username = user_info.username
-            password = user_info.password
-            user_info = GitLabAPI.get_gitlab_access_token_input(uri, user_info.user_id, username, password)
-            return nil unless user_info
-          else
-            user_info = new_user_info
-          end
+          return refreshUserToken uri, refresh_token, user_info.id, user_info.username, user_info.password
         end
       else
-        return user_info
+        update_time = user_info.update_time.to_i
+        if time_now - update_time > 1800
+          user_info = refreshUserToken uri, refresh_token, user_info.id, user_info.username, user_info.password
+          return  user_info
+        else
+          return user_info
+        end
       end
     end
 
+    def self.refreshUserToken(uri, refresh_token, user_id, username, password)
+      # 刷新 token 失败时, 通过已经保存的用户名密码来刷新 token
+      new_user_info = GitLabAPI.refresh_gitlab_access_token uri.hostname, refresh_token
+      unless new_user_info
+        return GitLabAPI.get_gitlab_access_token_input(uri, user_id, username, password)
+      end
+      return new_user_info
+    end
+
     public
     # 获取 GitLab access_token
     def self.request_gitlab_access_token(host, username, password)
@@ -94,6 +100,7 @@ module LgPodPlugin
         if error != nil
           if error == "invalid_grant"
             LSqliteDb.shared.delete_user_info(user_id)
+            LgPodPlugin.log_yellow "LSqliteDb.shared.delete_user_info(#{user_id}"
           end
           raise json["error_description"]
         end
@@ -101,7 +108,8 @@ module LgPodPlugin
         refresh_token = json["refresh_token"]
         expires_in = json["expires_in"] ||= 7200
         created_at = json["created_at"] ||= Time.now.to_i
-        user_model = LUserAuthInfo.new(user_id, username, password, host, access_token, refresh_token, (created_at + expires_in))
+        time_now = Time.now.to_i
+        user_model = LUserAuthInfo.new(user_id, username, password, host, access_token, refresh_token, (created_at + expires_in), time_now)
         LSqliteDb.shared.insert_user_info(user_model)
         LgPodPlugin.log_green "请求成功: `access_token` => #{access_token}, expires_in => #{expires_in}"
       rescue => exception
@@ -121,7 +129,7 @@ module LgPodPlugin
         if res.body
           json = JSON.parse(res.body)
         else
-          return nil
+          json   = nil
         end
         return nil unless json.is_a?(Hash)
         error = json["error"]
@@ -129,16 +137,19 @@ module LgPodPlugin
           error_description = json["error_description"]
           raise error_description
         end
+        time_now = Time.now.to_i
         access_token = json["access_token"]
         refresh_token = json["refresh_token"]
         expires_in = json["expires_in"] ||= 7200
-        created_at = json["created_at"] ||= Time.now.to_i
+        created_at = json["created_at"] ||= time_now
         user_id = LUserAuthInfo.get_user_id(host)
         user_model = LSqliteDb.shared.query_user_info(user_id)
         user_model.expires_in = (created_at + expires_in)
         user_model.access_token = access_token
         user_model.refresh_token = refresh_token
+        user_model.update_time = time_now
         LSqliteDb.shared.insert_user_info(user_model)
+        LgPodPlugin.log_green "刷新token成功: `refresh_token` => #{refresh_token}, expires_in => #{expires_in}"
         return user_model
       rescue => exception
         LgPodPlugin.log_yellow "刷新 `access_token` 失败, error => #{exception.to_s}"
@@ -166,7 +177,7 @@ module LgPodPlugin
           path = json["path"] ||= ""
           path_with_namespace = json["path_with_namespace"] ||= ""
           name_with_namespace = (json["name_with_namespace"] ||= "").gsub(/[ ]/, '')
-          if git.include?(path_with_namespace)
+          if git.include?(path_with_namespace) ||  git.downcase.include?(name_with_namespace.downcase)
             id = json["id"]
             web_url = json["web_url"]
             description = json["description"]
@@ -233,7 +244,7 @@ module LgPodPlugin
     # 通过github api 获取 git 最新commit
     def self.request_github_refs_heads(git, branch, uri = nil)
       return [nil, nil] unless git
-      unless git.include?("https://github.com/") || git.include?("git@github.com:")
+      unless git.include?("github.com/") || git.include?("git@github.com:")
         if LgPodPlugin::LUtils.is_gitlab_uri(git, "")
           return self.request_gitlab_refs_heads(git, branch, uri)
         end

data/lib/lg_pod_plugin/installer/install.rb

@@ -21,10 +21,7 @@ module LgPodPlugin
     def install(pod)
       hash = pod.checkout_options
       path = hash[:path]
-      unless path.nil?
-        LProject.shared.need_update_pods[pod.name] = "1"
-        return nil
-      end
+      return nil unless path.nil?
       @downloader = LDownloader.new(pod)
       self.download_params = @downloader.pre_download_pod
       return self.download_params

data/lib/lg_pod_plugin/installer/main.rb

@@ -45,7 +45,6 @@ module LgPodPlugin
           if download_params
             name = download_params["name"]
             all_installers[name] = installer
-            LProject.shared.need_update_pods[name] = "1"
           end
         end
       end

data/lib/lg_pod_plugin/installer/project.rb

@@ -8,22 +8,18 @@ module LgPodPlugin
     include Singleton
 
     attr_reader :podfile
-    attr_reader :lockfile
     attr_reader :update
     attr_reader :targets
     attr_reader :workspace
     attr_reader :repo_update
     attr_reader :external_pods
-    attr_reader :need_update_pods
     attr_accessor :cache_specs
-    # attr_accessor :redirect_url_hash
+    attr_accessor :refreshToken
     def setup(workspace,podfile_path, update, repo_update)
       @podfile = Pod::Podfile.from_file(podfile_path)
       @update = update
       @workspace = workspace
       @repo_update = repo_update
-      lockfile_path = workspace.join("Podfile.lock")
-      @lockfile = Pod::Lockfile.from_file(lockfile_path) if lockfile_path.exist?
       target =  @podfile.send(:current_target_definition)
       children = target.children
       @targets = Array.new
@@ -35,8 +31,7 @@ module LgPodPlugin
       end
       @cache_specs = Hash.new
       @external_pods = Hash.new.merge!(external_pods)
-      @need_update_pods = Hash.new
-      # @redirect_url_hash = Hash.new
+      @refreshToken = nil
       return self
     end