git-binary-cache 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 0dd2f8906b3f6e897f3d1e2e7b65e7e921b671e5
+  data.tar.gz: aaf81d2d0937af67247fbea29a2e6fa461d1cc1d
+SHA512:
+  metadata.gz: 210cf4842866498a5e6e0a92dd841f311413e805c4728827085226bf3df11827fa49efd3b0999eea4b373d3e7b9e7d4b5195ab005fe9fe38042de30edb036034
+  data.tar.gz: 940366a2cbd192beaa238b38e5b5b9b4b781dbcedf86310c4ba2c5bd02ae5c17bf3b2fded972ca7940701a73d6852a0ef93ce08702fecc2c3b221e9f83433976

data/Gemfile

@@ -0,0 +1,3 @@
+source "http://rubygems.org"
+
+gemspec

data/Gemfile.lock

@@ -0,0 +1,18 @@
+PATH
+  remote: .
+  specs:
+    git-binary-cache (0.0.1)
+      git
+
+GEM
+  remote: http://rubygems.org/
+  specs:
+    git (1.2.9.1)
+    rake (10.4.2)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  git-binary-cache!
+  rake

data/README.md

@@ -0,0 +1,7 @@
+Git-Based Binary Files Cache
+----------------------------
+
+The idea behind this library is to provide projects with a way to declare dependencies on external
+git repositories. Its functionality if very similar to git submodules idea, but the files on which
+a project depends are stored in a separate directory tree and are shared among different projects
+on a single machine.

data/Rakefile

@@ -0,0 +1,2 @@
+require 'bundler'
+Bundler::GemHelper.install_tasks

data/bin/git-binary-cache

@@ -0,0 +1,96 @@
+#!/usr/bin/env ruby
+
+require 'git_binary_cache'
+require 'logger'
+
+#---------------------------------------------------------------------------------------------------
+GitBinaryCache.logger = Logger.new(STDOUT)
+
+def logger
+  GitBinaryCache.logger
+end
+
+#---------------------------------------------------------------------------------------------------
+def error(message)
+  logger.error(message)
+  exit(1)
+end
+
+#---------------------------------------------------------------------------------------------------
+def update_caches!(target)
+  unless File.file?(target) || File.directory?(target)
+    error("Unsupported target argument: it should be a yaml file or a directory!")
+  end
+
+  GitBinaryCache.update_cache_for_target(target)
+  logger.info("Caches are all up to date!")
+end
+
+#---------------------------------------------------------------------------------------------------
+def check_caches!(target)
+  unless File.file?(target) || File.directory?(target)
+    error("Unsupported target argument: it should be a yaml file or a directory!")
+  end
+
+  GitBinaryCache.check_cache_for_target(target)
+  logger.info("Caches are all up to date!")
+
+rescue GitBinaryCache::Error => e
+  error(e.message)
+end
+
+#---------------------------------------------------------------------------------------------------
+def show_help(exit_code)
+  puts "Usage: #{$0} <command> [args]"
+  puts
+  puts "Supported commands:"
+  puts "   update TARGET  – initialize or update the cache"
+  puts "   check TARGET   – check if the cache is up to date"
+  puts "   reset TARGET   – drop the cache and initialize it again"
+  puts "   list-all       – show all caches on this computer"
+  puts "   drop-all       – delete all caches from this computer"
+  puts
+  puts "Where TARGET is either a project directory or a config file name."
+  puts
+  exit(exit_code)
+end
+
+#---------------------------------------------------------------------------------------------------
+command = ARGV.shift
+args = ARGV
+
+case command
+  when 'update'
+    target = args.first
+    error("Missing TARGET argument for update command") unless target
+    update_caches!(target)
+
+  when 'check'
+    target = args.first
+    error("Missing TARGET argument for check command") unless target
+    check_caches!(target)
+
+  when 'reset'
+    target = args.first
+    error("Missing TARGET argument for reset command") unless target
+    reset_caches!(target)
+
+  when 'list-all'
+    list_all_caches!
+
+  when 'drop-all'
+    drop_all_caches!
+
+  when nil
+    show_help(1)
+
+  when 'help'
+    show_help(0)
+
+  else
+    puts "Error: Invalid command: #{command}"
+    show_help(1)
+end
+
+# Done here!
+exit(0)

data/git-binary-cache.gemspec

@@ -0,0 +1,19 @@
+# -*- encoding: utf-8 -*-
+Gem::Specification.new do |s|
+  s.name        = 'git-binary-cache'
+  s.version     = '0.0.1'
+  s.platform    = Gem::Platform::RUBY
+  s.authors     = [ 'Oleksiy Kovyrin' ]
+  s.email       = [ 'alexey@kovyrin.net' ]
+  s.homepage    = 'https://github.com/swiftype/git-binary-cache'
+
+  s.summary     = %q{Git-Based Binary Files Cache}
+  s.description = %q{Git-Based Binary Files Cache}
+
+  s.files            = Dir.glob("**/*")
+  s.executables      = %w[ git-binary-cache ]
+  s.require_paths    = %w[ lib ]
+
+  s.add_dependency 'git'
+  s.add_development_dependency 'rake'
+end

data/lib/git_binary_cache/manager.rb

@@ -0,0 +1,201 @@
+require 'git'
+
+module GitBinaryCache
+  class Manager
+    attr_reader :logger, :name, :git_url
+
+    #-----------------------------------------------------------------------------------------------
+    def initialize(config)
+      raise ArgumentError, "Need a hash!" unless config.kind_of?(Hash)
+
+      @name = config[:name] or raise ArgumentError, "Need a :name for the cache"
+      @git_url = config[:git_url] or raise ArgumentError, "Need a :name for the cache"
+
+      @logger = config[:logger]
+    end
+
+    def log(message)
+      return unless logger
+      logger.info("cache[#{name}]: #{message}")
+    end
+
+    #-----------------------------------------------------------------------------------------------
+    def cache_base_dir
+      ENV['GIT_BINARY_CACHE'] || "/usr/local/var/git-binary-cache"
+    end
+
+    def cache_dir
+      File.join(cache_base_dir, name)
+    end
+
+    #-----------------------------------------------------------------------------------------------
+    def update_cache!(revision = nil)
+      # Make sure cache exists and its remote url is correct
+      if cache_exists?
+        log("Cache repository exists for #{name}, checking remote URL...")
+        remote_url = get_repo_remote_url
+
+        if remote_url != git_url
+          log("Remote URL for existing cache repository is invalid: #{remote_url} != #{git_url}, resetting the cache!")
+          clone_cache_from_upstream!
+        else
+          log("Git remote is correct!")
+        end
+      else
+        clone_cache_from_upstream!
+      end
+
+      # Update the cache
+      update_cache_from_upstream!
+
+      # If a revision give, switch to it
+      if revision
+        log("Revision provided, checking if it exists in the cache repository...")
+        revision_info = get_revision_info(revision)
+        unless revision_info
+          error = "Could not find revision '#{revision}' for cache #{name}. Check revision value!"
+          raise GitBinaryCache::UnknownRevisionError, error
+        end
+
+        if revision_applied?(revision)
+          log("Revision #{revision} has alrealy been applied!")
+        else
+          switch_to_revision!(revision)
+        end
+      else
+        log("No revision provided, switching to the most recent one...")
+        switch_to_revision!('master')
+      end
+    end
+
+    #-----------------------------------------------------------------------------------------------
+    def need_cache!
+      get_revision_info('HEAD')
+    end
+
+    #-----------------------------------------------------------------------------------------------
+    def need_revision!(revision)
+      # Check if we have the revision
+      revision_info = get_revision_info(revision)
+      unless revision_info
+        error = "Could not find revision '#{revision}' for cache #{name}. Try to update the cache!"
+        raise GitBinaryCache::UnknownRevisionError, error
+      end
+      log("Revision #{revision} exists in cache repository...")
+
+      # Then check if we have the revision applied already
+      unless revision_applied?(revision)
+        error = "Revision '#{revision}' is available, but the cache #{name} is outdated. Try to update the cache!"
+        raise GitBinaryCache::OutdatedCacheError, error
+      end
+      log("Revision #{revision} has been applied!")
+
+      # We're good
+      return true
+    end
+
+    #-----------------------------------------------------------------------------------------------
+    def get_repo_remote_url
+      # Open the cache with git
+      git = open_cache!
+
+      # Get origin remote url
+      git.remote('origin').url
+    end
+
+    #-----------------------------------------------------------------------------------------------
+    def get_revision_info(revision)
+      # Open the cache with git
+      git = open_cache!
+
+      # Check the revision
+      begin
+        git.object(revision)
+      rescue Git::GitExecuteError => e
+        # Return nil if revision does not exist
+        return false if e.message =~ /Not a valid object name/
+
+        # Re-raise unexpected error
+        raise
+      end
+    end
+
+    #-----------------------------------------------------------------------------------------------
+    def revision_applied?(revision)
+      # Open the cache with git
+      git = open_cache!
+
+      # Get log between two revisions
+      log = git.log(100).between('HEAD', revision)
+
+      # If revision has already been applied, there will be nothing in the log
+      return log.count == 0
+    end
+
+    #-----------------------------------------------------------------------------------------------
+    def clone_cache_from_upstream!
+      # Create base directory
+      FileUtils.mkdir_p(cache_base_dir)
+
+      # Nuke any remaining files in the cache directory
+      FileUtils.rm_rf(cache_dir)
+
+      # Clone the repo
+      log("Cloning git repo #{git_url} to #{cache_dir}")
+      Git.clone(git_url, cache_dir)
+    end
+
+    #-----------------------------------------------------------------------------------------------
+    def update_cache_from_upstream!
+      # Open the cache
+      git = Git.open(cache_dir)
+
+      # Reset the repo
+      git.reset_hard('HEAD')
+
+      # Fetch updates
+      log("Fetching origin updates for cache directory #{cache_dir}")
+      git.fetch('origin')
+    end
+
+    def switch_to_revision!(revision)
+      # Open the cache
+      git = Git.open(cache_dir)
+
+      # Switch to specified revision
+      log("Switching cache #{name} to revision #{revision}...")
+      git.checkout(revision)
+      log("Done!")
+    end
+
+    #-----------------------------------------------------------------------------------------------
+    def cache_exists?
+      open_cache!
+      return true
+    rescue GitBinaryCache::Error
+      return false
+    end
+
+    #-----------------------------------------------------------------------------------------------
+    def open_cache!
+      # Check if cache directory exists
+      unless Dir.exists?(cache_dir)
+        error = "Cache directory is missing for cache '#{name}'. Try to update the cache!"
+        raise GitBinaryCache::CacheMissingError, error
+      end
+
+      # Open the cache
+      git = Git.open(cache_dir)
+
+      # Check if cache directory is a valid git clone
+      unless Dir.exists?(File.join(cache_dir, '.git')) && git.index.readable?
+        error = "Cache directory is invalid for cache '#{name}'. Try to update the cache!"
+        raise GitBinaryCache::CacheCorruptedError, error
+      end
+
+      # Return our git repo information
+      return git
+    end
+
+  end
+end

data/lib/git_binary_cache.rb

@@ -0,0 +1,139 @@
+require 'yaml'
+require 'git_binary_cache/manager'
+
+module GitBinaryCache
+  class Error < Exception; end
+
+  class CacheError < Error; end
+  class CacheMissingError < CacheError; end
+  class CacheCorruptedError < CacheError; end
+
+  class RevisionError < Error; end
+  class UnknownRevisionError < RevisionError; end
+  class OutdatedCacheError < RevisionError; end
+
+  #-------------------------------------------------------------------------------------------------
+  def self.logger=(logger)
+    @logger = logger
+  end
+
+  def self.logger
+    @logger
+  end
+
+  def self.log(message)
+    return unless logger
+    logger.info("git-binary-cache: #{message}")
+  end
+
+  #-------------------------------------------------------------------------------------------------
+  def self.config_file_for_target(target)
+    return target if File.file?(target)
+    return File.join(target, 'git-binary-cache.yml') if File.directory?(target)
+    raise ArgumentError, "Invalid TARGET value: should be a yaml file or a directory!"
+  end
+
+  #-------------------------------------------------------------------------------------------------
+  def self.check_cache_for_target(target)
+    cache_config_file = config_file_for_target(target)
+    return unless File.readable?(cache_config_file)
+
+    config = load_yaml_config(cache_config_file)
+    config.each do |cache_name, cache_config|
+      check_cache_for_config(cache_name, cache_config)
+    end
+
+    project_dir = File.dirname(cache_config_file)
+    create_symlinks_for_project(project_dir, config)
+  end
+
+  #-------------------------------------------------------------------------------------------------
+  def self.update_cache_for_target(target)
+    cache_config_file = config_file_for_target(target)
+    return unless File.readable?(cache_config_file)
+
+    config = load_yaml_config(cache_config_file)
+    config.each do |cache_name, cache_config|
+      update_cache_for_config(cache_name, cache_config)
+    end
+
+    project_dir = File.dirname(cache_config_file)
+    create_symlinks_for_project(project_dir, config)
+  end
+
+  #-------------------------------------------------------------------------------------------------
+  def self.create_symlinks_for_project(project_dir, config)
+    config.each do |cache_name, cache_config|
+      create_link = cache_config['create_link'] || cache_config.has_key?('link_name')
+      next unless create_link
+
+      link_name = cache_config['link_name'] || cache_name
+      link_path = File.join(project_dir, link_name)
+      manager = manager_for_config(cache_name, cache_config)
+
+      # If something exists with the name of our link
+      if File.exists?(link_path)
+        # Name collision
+        unless File.symlink?(link_path)
+          error = "Could not create link '#{link_name}' for cache '#{cache_name}' because of a name collision with an existing file or directory!"
+          raise Error, error
+        end
+
+        # Link exists and is correct
+        next if File.readlink(link_path) == manager.cache_dir
+
+        # Drop existing link
+        log("Link '#{link_name}' for cache '#{cache_name}' exists, but is pointing to a wrong place, fixing!")
+        File.unlink(link_path)
+      end
+
+      # Create the link
+      log("Creating cache link: #{link_name}...")
+      File.symlink(manager.cache_dir, link_path)
+    end
+  end
+
+  #-------------------------------------------------------------------------------------------------
+  # Checks if specific cache exists and in a state that meets the demands listed in the config
+  #
+  # If there are any issues with the cache, throws an exception explaning the problem.
+  #
+  def self.check_cache_for_config(cache_name, cache_config)
+    log("Checking binary cache status for cache: #{cache_name}")
+    manager = manager_for_config(cache_name, cache_config)
+
+    # Check cache status (either a specific revision or the cache existence)
+    rev = cache_config['revision']
+    if rev
+      log("Checking if the cache has revision #{rev} has already been applied...")
+      manager.need_revision!(rev)
+    else
+      log("Checking if the cache exists...")
+      manager.need_cache!
+    end
+  end
+
+  #-------------------------------------------------------------------------------------------------
+  # Makes sure a specific cache exists and in a state that meets the demands listed in the config
+  def self.update_cache_for_config(cache_name, cache_config)
+    log("Updating binary cache: #{cache_name}")
+    manager = manager_for_config(cache_name, cache_config)
+    manager.update_cache!(cache_config['revision'])
+    log("Done updating binary cache: #{cache_name}")
+  end
+
+private
+
+  def self.load_yaml_config(config_file)
+    log("Loading configuration file: #{config_file}")
+    YAML.load_file(config_file)
+  end
+
+  def self.manager_for_config(cache_name, cache_config)
+    GitBinaryCache::Manager.new(
+      :name => cache_name,
+      :git_url => cache_config['git_url'],
+      :logger => logger
+    )
+  end
+end

metadata

@@ -0,0 +1,81 @@
+--- !ruby/object:Gem::Specification
+name: git-binary-cache
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Oleksiy Kovyrin
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-03-10 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: git
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Git-Based Binary Files Cache
+email:
+- alexey@kovyrin.net
+executables:
+- git-binary-cache
+extensions: []
+extra_rdoc_files: []
+files:
+- bin/git-binary-cache
+- Gemfile
+- Gemfile.lock
+- git-binary-cache.gemspec
+- lib/git_binary_cache/manager.rb
+- lib/git_binary_cache.rb
+- pkg/git-binary-cache-0.0.1.gem
+- Rakefile
+- README.md
+homepage: https://github.com/swiftype/git-binary-cache
+licenses: []
+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.0.14
+signing_key: 
+specification_version: 4
+summary: Git-Based Binary Files Cache
+test_files: []