code_cache 0.2.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 9b35ba34266cc6f725541d547606b0bda66347ff
+  data.tar.gz: 7b9e153b63507075879e93025035381296f86a55
+SHA512:
+  metadata.gz: a0f4c2d7416cd4c446c3662cd307d3a712ea9957a505ad200b04f23f7e05416fa631f23ce48e483607749231fa03d7f0f4f86517a51adc3b6aa1f0e0d8db9e1f
+  data.tar.gz: fef3d5e9b7294679c4ef00497dcb4c83167968872a5f180821a8226b2adfd00d15b4cd9cdd5d7577af6f861d3c5655f1c425b9880b4f3c6de262d233dd0f240e

data/README.md

@@ -0,0 +1,24 @@
+# code_cache
+Version control checkout abstraction and cache.
+
+## Usage
+
+    repo =  CodeCache.repo( repo_url )
+    begin
+      repo.checkout( :head, 'path/to/checkout' )
+    rescue => e
+      puts "Checkout failed"
+    end
+
+## Testing
+
+Tests run against the github svn and git endpoints for this repository. Just run:
+
+    bundle
+    bundle exec rspec
+    
+## License
+
+Code Cache is available to everyone under the terms of the MIT open source licence. Take a look at the LICENSE file in the code.
+
+Copyright (c) 2015 BBC

data/lib/code_cache.rb

@@ -0,0 +1,22 @@
+require 'code_cache/repo/git'
+require 'code_cache/repo/svn'
+
+module CodeCache
+
+  def self.identify(url)
+    if (url =~ /.*\.git\s*$/)
+      :git
+    else
+      :svn
+    end
+  end
+  
+  def self.repo(url)
+    if self.identify(url) == :git
+      Repo::Git.new(url)
+    else
+      Repo::SVN.new(url)
+    end
+  end
+
+end

data/lib/code_cache/repo.rb

@@ -0,0 +1,56 @@
+require 'fileutils'
+
+module CodeCache
+
+  class Repo
+    
+    attr_accessor :url, :cache
+    
+    def initialize(url, options = {})
+      @cache = options[:cache] || '/tmp/code_cache'
+      @url = url
+      
+      check_repo(url)
+    end
+    
+    def create_cache(revision)
+      if !Dir.exist? location_in_cache(revision)
+        FileUtils.mkdir_p @cache
+      end
+    end
+    
+    # Calculates the location of a cached checkout
+    def location_in_cache( revision = nil )
+      begin
+        elements = [cache, repo_type, split_url, revision].flatten.compact.collect { |i| i.to_s } 
+        File.join( elements )
+      rescue => e
+        raise CacheCalculationError.new(e.msg + e.backtrace.to_s)
+      end
+    end
+    
+    def repo_type
+      self.class.to_s.split('::').last.downcase
+    end
+  
+  end
+
+  class BadRepo < StandardError
+  end
+  
+  class UnknownCheckoutError < StandardError
+  end
+  
+  class CacheCalculationError < StandardError
+  end
+  
+  class CacheCorruptionError < StandardError
+  end
+  
+  class UpdateError < StandardError
+  end
+  
+  class CopyError < StandardError
+  end
+
+end

data/lib/code_cache/repo/git.rb

@@ -0,0 +1,73 @@
+require 'code_cache/repo'
+
+module CodeCache
+  class Repo::Git < Repo
+  
+    def initialize(url, options = {})
+      super(url, options)
+    end
+ 
+    # Split the url into a unique array for the cache path
+    def split_url
+      match = /(?:(?:git|ssh)@(.*):|(?:https?:\/\/(.*?)\/))(.*).git/.match(url)
+      match.captures.compact
+    end
+
+    # Check access to the repo in question
+    def check_repo(url)
+      output = `git ls-remote #{url} 2>&1`
+      if ($? != 0)
+        raise BadRepo.new(url + "<<<" + output.to_s + ">>>")
+      end
+    end
+    
+    # Checkout a particular revision from the repo into the destination
+    # Caches the checkout in the process
+    def checkout( revision, destination )
+      
+      if revision != :head
+        raise "Checking out anything other than the head of the default branch not supported"
+      end
+      
+      cache_destination = location_in_cache()
+      
+      # Try and copy into the cache first
+      clone_or_update_repo_in_cache(cache_destination)
+      
+      puts "Cache: #{cache_destination}"
+      puts "Destination: #{destination}"
+      
+      checkout_from_cache_to_destination(cache_destination, destination, revision)
+      
+      true
+    end
+    
+    def clone_or_update_repo_in_cache(cache_destination)
+      update_result = update_cache(cache_destination)
+      if update_result[:status] == true
+        return true
+      else
+        clone_bare_repo_to_cache(cache_destination)
+      end
+    end
+    
+    def update_cache(cache_destination)
+      output = `GIT_DIR=#{cache_destination} git fetch origin +refs/heads/*:refs/heads/* 2>&1`
+      status = $? == 0
+      { :output => output, :status => status }
+    end
+    
+    def clone_bare_repo_to_cache(cache_destination)
+      output = `git clone --bare #{url} #{cache_destination} 2>&1`
+      status = $? == 0
+      { :output => output, :status => status }
+    end
+    
+    def checkout_from_cache_to_destination(cache_destination, destination, revision)
+      output = `git clone --single-branch #{cache_destination} #{destination} 2>&1`
+      status = $? == 0
+      { :output => output, :status => status }
+    end
+    
+  end
+end

data/lib/code_cache/repo/svn.rb

@@ -0,0 +1,99 @@
+require 'code_cache/repo'
+
+module CodeCache
+  class Repo::SVN < Repo
+  
+    def initialize(url, options = {})
+      super(url, options)
+    end
+    
+    # Checkout a particular revision from the repo into the destination
+    # Caches the checkout in the process
+    def checkout( revision, destination )
+      
+      if revision != :head
+        raise "Checking out revisions other than head currently not supported"
+      end
+      
+      cache_destination = location_in_cache(revision)
+      
+      # Try and copy into the cache first
+      begin
+        perform_cache_checkout_or_update(cache_destination)
+        FileUtils.mkdir_p(destination)
+        
+        FileUtils.cp_r(cache_destination+'/.', destination)
+        # Ensure the final copy is consistent
+        raise CopyError if !Dir.exist?(destination)
+        output = perform_update(destination)
+        if !output[:status]
+          raise UpdateError.new(output)
+        end
+        
+      rescue => e
+        puts "Unhandled randomness: " + e.to_s + ' - ' + e.backtrace.to_s
+        # If we can't copy into the cache, copy directly to the destination
+        perform_checkout(destination)
+      end
+      
+      true
+    end
+    
+    def perform_cache_checkout_or_update(destination, attempts = 3)
+      update_result = perform_update(destination)
+      if update_result[:status] == true
+        return true
+      else
+        checkout_result = perform_checkout(destination)
+        if checkout_result[:status]
+          return true
+        else
+          # Cache update in progress, retry with some sleeps
+          if checkout_result[:output] =~ /E155037/
+            sleep 1
+            if attempts > 0
+              perform_cache_checkout_or_update( destination, attempts-1 )
+            else
+              return false
+            end
+ 
+          # Cache has become corrupted
+          elsif checkout_result[:output] =~ /E155004/  
+            raise CacheCorruptionError.new(url)
+          else
+            raise UnknownCheckoutError.new(url)
+          end
+        end
+      end
+    end
+
+    # Perform an svn update on a directory -- checks its a valid svn dir first
+    def perform_update(destination)
+      output = `svn info #{destination} 2>&1 && svn up #{destination} 2>&1`
+      status = $? == 0
+      { :output => output, :status => status }
+    end
+    
+    def perform_checkout(destination)
+      output = `svn co #{url} #{destination} 2>&1`
+      status = $? == 0
+      { :output => output, :status => status }
+    end
+    
+    # Check access to the repo in question
+    def check_repo(url)
+      output = `svn ls #{url} 2>&1`
+      if ($? != 0)
+        raise BadRepo.new(url + "<<<" + output.to_s + ">>>")
+      end
+    end
+   
+    # Split the url into a unique array for the cache path
+    def split_url
+      url.split('//').drop(1).collect{ |e| e.split('/') }.flatten
+    end
+  end
+  
+
+  
+end

metadata

@@ -0,0 +1,63 @@
+--- !ruby/object:Gem::Specification
+name: code_cache
+version: !ruby/object:Gem::Version
+  version: 0.2.0
+platform: ruby
+authors:
+- David Buckhurst
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-10-14 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.3'
+description: Provides a simple api for checking out svn and git repositories. Caches
+  checkouts locally so that subsequent checkouts are optimised.
+email: david.buckhurst@bbc.co.uk
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- README.md
+- lib/code_cache.rb
+- lib/code_cache/repo.rb
+- lib/code_cache/repo/git.rb
+- lib/code_cache/repo/svn.rb
+homepage: https://github.com/bbc/code_cache
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.4.8
+signing_key: 
+specification_version: 4
+summary: Abstracts & caches svn & git operations
+test_files: []