batali 0.1.0 → 0.1.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 12ae5060ad51ee573081c34f077e1242908dddd7
-  data.tar.gz: b569cf195a11b93a1b7c1ddf87df063c63df1693
+  metadata.gz: 68737e2f016b576dbe9b038f1d6a3930b17fd8ee
+  data.tar.gz: 47a886779b940b36035dfa68d8cf07f4631bb24f
 SHA512:
-  metadata.gz: 909cfbcd842a0f2187efab1e4bf9453bc15234e38a0de13317b6ae1a5cf02b222cf499b4caf8ef6da814aa12c1cb74f2dbbde92089645ac9410e230f63f0d1e5
-  data.tar.gz: 1523d71a2af4dd85a487effeeb1bc967160f1093fec75925019afee3f3b128d0e32f3d07d983740d08f754e3732838ba909d672d2c565456466fbc660a333642
+  metadata.gz: cdd04d4d64c21b700d89b85403367badaa16d4168461e4b393105d39e4e2b243e79cde92b5dad431fc1a765f461bced6b341bb8cb63067c778dc1d83796e7a2a
+  data.tar.gz: c4beb1a4fe18118e09c53962f04603aeeb5246b8fcbf565577ccc773b1aeb03d11c9b5bbdc414ef704c3765ed423bd184b74ff4a373f7fc66e0ad5af2bcb2f5a

data/CHANGELOG.md

@@ -1,2 +1,7 @@
+# v0.1.2
+* Add support for git and path origins
+* Cache assets from origins locally for reuse
+* Add initial support for infrastructure resolution
+
 # v0.1.0
 * Initial release

data/README.md

@@ -27,10 +27,120 @@ by default.
 
 _IT WILL DESTROY YOUR COOKBOOKS DIRECTORY BY DEFAULT_
 
-There is other cool stuff too, to be documented later. Currently
-only site sources can be defined (no path, or git, or anything else).
+## Commands
 
+* `batali resolve` - Resolve dependencies and produce `batali.manifest`
+* `batali install` - Install entries from the `batali.manifest`
+* `batali update`  - Perform `resolve` and then `install`
+
+## Features
+
+### Origins
+
+Currently supported "origins":
+
+* RemoteSite
+* Path
+* Git
+
+#### RemoteSite
+
+This is simply a supermarket endpoint:
+
+```ruby
+source 'https://supermarket.chef.io'
+```
+
+Multiple endpoints can be provided by specifying multiple
+`source` lines. They can also be named:
+
+```ruby
+source 'https://supermarket.chef.io', :name => 'opscode'
+source 'https://cookbooks.example.com', :name => 'example'
+```
+
+##### Path
+
+Paths are defined via cookbook entries:
+
+```ruby
+cookbook 'example', path: '/path/to/example'
+```
+
+##### Git
+
+Git sources are defined via cookbook entries:
+
+```ruby
+cookbook 'example', git: 'git://git.example.com/example-repo.git', ref: 'master'
+```
+
+### Least Impact Updates
+
+After a `batali.manifest` file has been generated, subsequent `resolve` requests
+will update cookbook versions using a "least impact" approach. This means that
+by default if the `Batali` file has not changed, running a `batali resolve` will
+be a noop, even if new versions of cookbooks may be available. This helps to reduce
+unintended upgrades that may break things due to a required cookbook update. Allowing
+a cookbook to be updated is done simply by adding it to the request:
+
+```
+$ batali resolve example
+```
+
+This will only update the version of the example cookbook, and any dependency cookbooks
+that _must_ be updated to provide resolution. Multiple cookbooks can be listed:
+
+```
+$ batali resolve example ipsum lorem
+```
+
+or this feature can be disabled to allow everything to be updated to the latest
+possible versions:
+
+```
+$ batali resolve --no-least-impact
+```
+
+### Light weight
+
+One of the goals for batali was being light weight resolver, in the same vein as
+the [librarian][1] project. This means it does nothing more than manage local cookbooks. This
+includes dependency and constraint resolution, as well as providing a local installation
+of assets defined within the generated manifest. It provides no extra features outside of
+that scope.
+
+### Multiple platform support
+
+Batali does not rely on the [chef][2] gem to function. This removes any dependencies on
+gems that may be incompatible outside the MRI platform.
+
+### Isolated manifest files
+
+Manifest files are fully isolated. The resolver does not need to perform any actions
+for installing cookbooks defined within the manifest. This allows for easy transmission
+and direct installation of a manifest without the requirement of re-pulling information
+from sources.
+
+### Infrastructure manifests
+
+Batali aims to solve the issue of full infrastructure resolution: resolving dependencies
+from an infrastructure repository. Resolving a single dependency path will not provide
+a correct resolution. This is because environments or run lists can provide extra constraints
+that will result in unsolvable resolutions on individual nodes. In this case we want
+to know what cookbooks are _allowed_ within a solution, and ensure all those cookbooks
+are available. Batali provides infrastructure level manifests by setting the `infrastructure`
+flag:
+
+```
+$ batali resolve --infrastructure
+```
+
+_NOTE: Depending on constraints defined within the Batali file, this can be a very large manifest_
 
 # Info
 
 * Repository: https://github.com/hw-labs/batali
+
+[1]: https://rubygems.org/gems/librarian "A Framework for Bundlers"
+[2]: https://rubygems.org/gems/chef "A systems integration framework"

data/batali.gemspec

@@ -10,10 +10,12 @@ Gem::Specification.new do |s|
   s.description = 'Magic'
   s.require_path = 'lib'
   s.license = 'Apache 2.0'
-  s.add_runtime_dependency 'grimoire', '>= 0.1.2'
+  s.add_runtime_dependency 'attribute_struct', '>= 0.2.14'
+  s.add_runtime_dependency 'grimoire', '>= 0.1.4'
   s.add_runtime_dependency 'bogo', '>= 0.1.12'
   s.add_runtime_dependency 'bogo-cli', '>= 0.1.8'
   s.add_runtime_dependency 'bogo-config', '>= 0.1.10'
+  s.add_runtime_dependency 'git'
   s.add_runtime_dependency 'http'
   s.add_development_dependency 'minitest'
   s.add_development_dependency 'pry'

data/bin/batali

@@ -32,6 +32,7 @@ Bogo::Cli::Setup.define do
     on :d, 'dry-run', 'Print changes'
     on :l, 'least-impact', 'Update cookbooks with minimal version impact', :default => true
     on :i, 'install', 'Install cookbooks after update', :default => true
+    on :I, 'infrastructure', 'Resolve infrastructure cookbooks'
 
     run do |opts, args|
       Batali::Command::Update.new({:update => opts.to_hash}, args).execute!
@@ -43,6 +44,7 @@ Bogo::Cli::Setup.define do
     self.instance_exec(&global_opts)
     on :d, 'dry-run', 'Print changes'
     on :l, 'least-impact', 'Update cookbooks with minimal version impact', :default => true
+    on :I, 'infrastructure', 'Resolve infrastructure cookbooks'
 
     run do |opts, args|
       Batali::Command::Resolve.new({:resolve => opts.to_hash}, args).execute!

data/lib/batali/b_file.rb

@@ -4,8 +4,8 @@ module Batali
 
   class Struct < AttributeStruct
 
-    def cookbook(*args)
-      set!(:cookbook, args)
+    def cookbook(*args, &block)
+      set!(:cookbook, args, &block)
       self
     end
 
@@ -24,38 +24,58 @@ module Batali
 
   class BFile < Bogo::Config
 
-    class Cookbook < Grimoire::Utility
+    # @return [Proc] cookbook convert
+    def self.cookbook_coerce
+      proc do |v|
+        case v
+        when Array
+          case v.last
+          when String
+            Cookbook.new(
+              :name => v.first,
+              :constraint => v.slice(1, v.size)
+            )
+          when Hash
+            c_name = v.first
+            Cookbook.new(
+              v.last.merge(
+                :name => c_name
+              )
+            )
+          else
+            raise ArgumentError.new "Unable to coerce given type `#{v.class}` to `Batali::BFile::Cookbook`!"
+          end
+        when String
+          Cookbook.new(:name => v)
+        else
+          raise ArgumentError.new "Unable to coerce given type `#{v.class}` to `Batali::BFile::Cookbook`!"
+        end
+      end
+    end
+
+    class Cookbook < Utility
       attribute :name, String, :required => true
       attribute :constraint, String, :multiple => true
-      attribute :git, Smash, :coerce => lambda{|v| v.to_smash}
+      attribute :git, String
+      attribute :ref, String
       attribute :path, String
     end
 
-    attribute :source, RemoteSite, :multiple => true, :coerce => lambda{|v| RemoteSite.new(:endpoint => v)}
-    attribute :cookbook, Cookbook, :multiple => true, :coerce => lambda{|v|
-      case v
-      when Array
-        Cookbook.new(
-          :name => v.first,
-          :constraint => v.slice(1, v.size)
-        )
-      when String
-        Cookbook.new(:name => v)
-      when Hash
-        c_name = v.keys.first
-        constraints = v.values.first.to_a.flatten.find_all{|i| i.is_a?(String)}
-        Cookbook.new(
-          :name => c_name,
-          :constraint => constraints
-        )
-      else
-        raise ArgumentError.new "Unable to coerce given type `#{v.class}` to `Batali::BFile::Cookbook`!"
-      end
-    }
+    class Restriction < Utility
+      attribute :cookbook, String, :required => true
+      attribute :source, String, :required => true
+    end
+
+    class Group < Utility
+      attribute :name, String, :required => true
+      attribute :cookbook, Cookbook, :multiple => true, :required => true, :coerce => BFile.cookbook_coerce
+    end
+
+    attribute :restrict, Restriction, :multiple => true, :coerce => lambda{|v| Restriction.new(:cookbook => v.first, :source => v.last)}
+    attribute :source, Origin::RemoteSite, :multiple => true, :coerce => lambda{|v| Origin::RemoteSite.new(:endpoint => v)}
+    attribute :group, Group, :multiple => true, :coerce => lambda{|v| Group.new()}
+    attribute :cookbook, Cookbook, :multiple => true, :coerce => BFile.cookbook_coerce
 
-    ## TODO: supported values still required
-    # attribute :restrict -- restrict cookbooks of name `x` to source  named `y`
-    # attribute :group -- cookbook grouping (i.e. :integration)
   end
 
 end

data/lib/batali/command/install.rb

@@ -16,25 +16,31 @@ module Batali
             FileUtils.mkdir_p(install_path)
             nil
           end
-          run_action('Installing cookbooks') do
-            manifest.cookbook.each do |unit|
-              asset_path = unit.source.asset
-              begin
-                FileUtils.mv(
-                  File.join(
-                    asset_path,
-                    unit.name
-                  ),
-                  File.join(
-                    install_path,
-                    unit.name
+          if(manifest.cookbook.nil? || manifest.cookbook.empty?)
+            ui.error "No cookbooks defined within manifest! Try resolving first. (`batali resolve`)"
+          else
+            run_action('Installing cookbooks') do
+              manifest.cookbook.each do |unit|
+                if(unit.source.respond_to?(:cache))
+                  unit.source.cache = cache_directory(
+                    Bogo::Utility.snake(unit.source.class.name.split('::').last)
                   )
-                )
-              ensure
-                FileUtils.rm_rf(asset_path)
+                end
+                asset_path = unit.source.asset
+                begin
+                  FileUtils.cp_r(
+                    File.join(asset_path, '.'),
+                    File.join(
+                      install_path,
+                      "#{unit.name}-#{unit.version}"
+                    )
+                  )
+                ensure
+                  unit.source.clean_asset(asset_path)
+                end
               end
+              nil
             end
-            nil
           end
         end
       end

data/lib/batali/command/resolve.rb

@@ -11,15 +11,17 @@ module Batali
       def execute!
         system = Grimoire::System.new
         run_action 'Loading sources' do
-          batali_file.source.map(&:units).flatten.map do |unit|
-            system.add_unit(unit)
-          end
+          UnitLoader.new(
+            :file => batali_file,
+            :system => system,
+            :cache => cache_directory(:git)
+          ).populate!
           nil
         end
         requirements = Grimoire::RequirementList.new(
           :name => :batali_resolv,
           :requirements => batali_file.cookbook.map{ |ckbk|
-            [ckbk.name, *(ckbk.constraint.empty? ? ['> 0'] : ckbk.constraint)]
+            [ckbk.name, *(ckbk.constraint.nil? || ckbk.constraint.empty? ? ['> 0'] : ckbk.constraint)]
           }
         )
         solv = Grimoire::Solver.new(
@@ -27,27 +29,39 @@ module Batali
           :system => system,
           :score_keeper => score_keeper
         )
-        results = []
-        run_action 'Resolving dependency constraints' do
-          results = solv.generate!
-          nil
-        end
-        if(results.empty?)
-          ui.error 'No solutions found defined requirements!'
+        if(opts[:infrastructure])
+          ui.info 'Performing infrastructure path resolution.'
+          run_action 'Writing infrastructure manifest file' do
+            File.open('batali.manifest', 'w') do |file|
+              manifest = Manifest.new(:cookbook => solv.world.units.values.flatten)
+              file.write MultiJson.dump(manifest, :pretty => true)
+              nil
+            end
+          end
         else
-          ideal_solution = results.pop
-          dry_run('manifest file write') do
-            run_action 'Writing manifest' do
-              manifest = Manifest.new(:cookbook => ideal_solution.units)
-              File.open('batali.manifest', 'w') do |file|
-                file.write MultiJson.dump(manifest, :pretty => true)
+          ui.info 'Performing single path resolution.'
+          results = []
+          run_action 'Resolving dependency constraints' do
+            results = solv.generate!
+            nil
+          end
+          if(results.empty?)
+            ui.error 'No solutions found defined requirements!'
+          else
+            ideal_solution = results.pop
+            dry_run('manifest file write') do
+              run_action 'Writing manifest' do
+                manifest = Manifest.new(:cookbook => ideal_solution.units)
+                File.open('batali.manifest', 'w') do |file|
+                  file.write MultiJson.dump(manifest, :pretty => true)
+                end
+                nil
               end
-              nil
             end
+            ui.info "Number of solutions collected for defined requirements: #{results.size + 1}"
+            ui.info 'Ideal solution:'
+            ui.puts ideal_solution.units.sort_by(&:name).map{|u| "#{u.name}<#{u.version}>"}
           end
-          ui.info "Found #{results.size} solutions for defined requirements."
-          ui.info 'Ideal solution:'
-          ui.puts ideal_solution.units.sort_by(&:name).map{|u| "#{u.name}<#{u.version}>"}
         end
       end
 

data/lib/batali/command.rb

@@ -1,4 +1,5 @@
 require 'batali'
+require 'fileutils'
 
 module Batali
   # Customized command base for Batali
@@ -32,6 +33,18 @@ module Batali
       end
     end
 
+    # @return [String] path to local cache
+    def cache_directory(*args)
+      memoize(['cache_directory', *args].join('_')) do
+        directory = opts.fetch(:cache_directory, '/tmp/batali-cache')
+        unless(args.empty?)
+          directory = File.join(directory, *args.map(&:to_s))
+        end
+        FileUtils.mkdir_p(directory)
+        directory
+      end
+    end
+
     # Do not execute block if dry run
     #
     # @param action [String] action to be performed

data/lib/batali/git.rb

@@ -0,0 +1,54 @@
+require 'git'
+require 'batali'
+
+module Batali
+  module Git
+
+    # @return [String] path to repository clone
+    def base_path
+      File.join(cache, Base64.urlsafe_encode64(url))
+    end
+
+    # Clone the repository to the local machine
+    #
+    # @return [TrueClass]
+    def clone_repository
+      if(File.directory?(base_path))
+        repo = ::Git.open(base_path)
+        repo.checkout('master')
+        repo.pull
+        repo.fetch
+      else
+        ::Git.clone(url, base_path)
+      end
+      true
+    end
+
+    # Duplicate reference and store
+    #
+    # @return [String] commit SHA
+    # @note this will update ref to SHA
+    def ref_dup
+      git = ::Git.open(base_path)
+      git.checkout(ref)
+      self.ref = git.log.first.sha
+      self.path = File.join(cache, ref)
+      unless(File.directory?(path))
+        FileUtils.mkdir_p(path)
+        FileUtils.cp_r(File.join(base_path, '.'), path)
+        FileUtils.rm_rf(File.join(path, '.git'))
+      end
+      self.path
+    end
+
+    # Load attributes into class
+    def self.included(klass)
+      klass.class_eval do
+        attribute :url, String, :required => true
+        attribute :ref, String, :required => true
+        attribute :cache, String
+      end
+    end
+
+  end
+end

data/lib/batali/manifest.rb

@@ -2,11 +2,11 @@ require 'batali'
 
 module Batali
   # Collection of resolved units
-  class Manifest < Grimoire::Utility
+  class Manifest < Utility
 
     include Bogo::Memoization
 
-    attribute :cookbook, Unit, :multiple => true, :coerce => lambda{|v| Unit.new(v)}
+    attribute :cookbook, Unit, :multiple => true, :coerce => lambda{|v| Unit.new(v)}, :default => []
 
     # Build manifest from given path. If no file exists, empty
     # manifest will be provided.

data/lib/batali/origin/git.rb

@@ -0,0 +1,54 @@
+require 'git'
+require 'batali'
+
+module Batali
+  class Origin
+    # Fetch unit from local path
+    class Git < Path
+
+      include Batali::Git
+
+      def initialize(args={})
+        unless(args[:path])
+          args[:path] = '/dev/null'
+        end
+        super
+        self.identifier = Smash.new(
+          :url => url,
+          :ref => ref
+        ).checksum
+        unless(name?)
+          self.name = self.identifier
+        end
+      end
+
+      # @return [Array<Unit>]
+      def units
+        memoize(:g_units) do
+          items = super
+          items.first.source = Source::Git.new(
+            :url => url,
+            :ref => ref,
+            :path => path
+          )
+          items
+        end
+      end
+
+      # @return [Smash] metadata information
+      def load_metadata
+        fetch_repo
+        super
+      end
+
+      # @return [String] path to repository
+      def fetch_repo
+        memoize(:fetch_repo) do
+          clone_repository
+          ref_dup
+        end
+      end
+
+    end
+  end
+end

data/lib/batali/origin/path.rb

@@ -0,0 +1,79 @@
+require 'batali'
+
+module Batali
+  class Origin
+    # Fetch unit from local path
+    class Path < Origin
+
+      class Metadata < AttributeStruct
+
+        def depends(*args)
+          set!(:depends, args)
+          self
+        end
+
+      end
+
+      include Bogo::Memoization
+
+      attribute :path, String, :required => true
+
+      def initialize(*_)
+        super
+        self.identifier = Smash.new(:path => path).checksum
+        unless(name?)
+          self.name = self.identifier
+        end
+      end
+
+      # @return [Array<Unit>]
+      def units
+        memoize(:units) do
+          info = load_metadata
+          [
+            Unit.new(
+              :name => info[:name],
+              :version => info[:version],
+              :dependencies => info[:depends],
+              :source => Smash.new(
+                :type => :path,
+                :version => info[:version],
+                :path => path,
+                :dependencies => info[:depends].map{ |dep|
+                  if(dep.size == 1)
+                    dep.push('> 0')
+                  else
+                    dep.to_a
+                  end
+                }
+              )
+            )
+          ]
+        end
+      end
+
+      # @return [Smash] metadata information
+      def load_metadata
+        memoize(:metadata) do
+          if(File.exists?(json = File.join(path, 'metadata.json')))
+            MultiJson.load(json).to_smash
+          elsif(File.exists?(rb = File.join(path, 'metadata.rb')))
+            struct = Metadata.new
+            struct.set_state!(:value_collapse => true)
+            File.readlines(rb).find_all do |line|
+              line.start_with?('name') ||
+                line.start_with?('version') ||
+                line.start_with?('depends')
+            end.each do |line|
+              struct.instance_eval(line)
+            end
+            struct._dump.to_smash
+          else
+            raise Errno::ENOENT.new('No metadata file available to load!')
+          end
+        end
+      end
+
+    end
+  end
+end

data/lib/batali/origin/remote_site.rb

@@ -0,0 +1,100 @@
+require 'batali'
+require 'digest/sha2'
+require 'securerandom'
+require 'http'
+require 'fileutils'
+
+module Batali
+  class Origin
+    # Fetch unit information from remote site
+    class RemoteSite < Origin
+
+      # Site suffix for API endpoint
+      COOKBOOK_API_SUFFIX = 'api/v1/cookbooks'
+
+      include Bogo::Memoization
+
+      attribute :name, String
+      attribute :identifier, String
+      attribute :endpoint, String, :required => true
+      attribute :force_update, [TrueClass, FalseClass], :required => true, :default => false
+      attribute :update_interval, Integer, :required => true, :default => 60
+      attribute :cache, String, :default => File.expand_path('~/.batali/cache/remote_site'), :required => true
+
+      def initialize(*_)
+        super
+        endpoint = URI.join(self.endpoint, COOKBOOK_API_SUFFIX).to_s
+        self.identifier = Digest::SHA256.hexdigest(endpoint)
+        unless(name?)
+          self.name = self.identifier
+        end
+      end
+
+      # @return [String] cache directory path
+      def cache_directory
+        memoize(:cache_directory) do
+          path = File.join(cache, identifier)
+          FileUtils.mkdir_p(path)
+          path
+        end
+      end
+
+      # @return [Array<Unit>] all units
+      def units
+        memoize(:units) do
+          items.map do |u_name, versions|
+            versions.map do |version, info|
+              Unit.new(
+                :name => u_name,
+                :version => version,
+                :dependencies => info[:dependencies].to_a,
+                :source => Smash.new(
+                  :type => :site,
+                  :url => info[:download_url],
+                  :version => version,
+                  :dependencies => info[:dependencies]
+                )
+              )
+            end
+          end.flatten
+        end
+      end
+
+      protected
+
+      # @return [Smash] all info
+      def items
+        memoize(:items) do
+          MultiJson.load(File.read(fetch)).to_smash
+        end
+      end
+
+      # Fetch the universe
+      #
+      # @return [String] path to universe file
+      def fetch
+        do_fetch = true
+        if(File.exists?(universe_path))
+          age = Time.now - File.mtime(universe_path)
+          if(age < update_interval)
+            do_fetch = false
+          end
+        end
+        if(do_fetch)
+          t_uni = "#{universe_path}.#{SecureRandom.urlsafe_base64}"
+          File.open(t_uni, 'w') do |file|
+            file.write HTTP.get(URI.join(endpoint, 'universe')).body.to_s
+          end
+          FileUtils.mv(t_uni, universe_path)
+        end
+        universe_path
+      end
+
+      # @return [String] path to universe file
+      def universe_path
+        File.join(cache_directory, 'universe.json')
+      end
+
+    end
+  end
+end

data/lib/batali/origin.rb

@@ -0,0 +1,20 @@
+require 'batali'
+
+module  Batali
+  # Cookbook source origin
+  class Origin < Utility
+
+    autoload :RemoteSite, 'batali/origin/remote_site'
+    autoload :Git, 'batali/origin/git'
+    autoload :Path, 'batali/origin/path'
+
+    attribute :name, String, :required => true
+    attribute :identifier, String
+
+    # @return [Array<Unit>] all units
+    def units
+      raise NotImplementedError.new 'Abstract class'
+    end
+
+  end
+end

data/lib/batali/source/git.rb

@@ -0,0 +1,36 @@
+require 'batali'
+require 'fileutils'
+require 'tmpdir'
+
+module Batali
+  # Source of asset
+  class Source
+    # Path based source
+    class Git < Path
+
+      include Bogo::Memoization
+      include Batali::Git
+
+      attribute :path, String
+
+      # @return [String] directory containing contents
+      def asset
+        clone_repository
+        self.path = ref_dup
+        super
+      end
+
+      # Overload to remove non-relevant attributes
+      def to_json(*args)
+        MultiJson.dump(
+          Smash.new(
+            :url => url,
+            :ref => ref,
+            :type => self.class.name
+          ), *args
+        )
+      end
+
+    end
+  end
+end

data/lib/batali/source/site.rb

@@ -13,6 +13,8 @@ module Batali
       attr_reader :dependencies
       # @return [String] version
       attr_reader :version
+      # @return [String] local cache path
+      attr_accessor :cache
 
       attribute :url, String, :required => true
       attribute :version, String, :required => true
@@ -38,31 +40,40 @@ module Batali
 
       # @return [String] directory
       def asset
-        path = Dir.mktmpdir('batali')
-        result = HTTP.get(url)
-        while(result.code == 302)
-          result = HTTP.get(result.headers['Location'])
-        end
-        File.open(a_path = File.join(path, 'asset'), 'w') do |file|
-          while(content = result.body.readpartial(2048))
-            file.write content
+        path = File.join(cache, Base64.urlsafe_encode64(url))
+        unless(File.directory?(path))
+          FileUtils.mkdir_p(path)
+          result = HTTP.get(url)
+          while(result.code == 302)
+            result = HTTP.get(result.headers['Location'])
           end
-        end
-        ext = Gem::Package::TarReader.new(
-          Zlib::GzipReader.open(a_path)
-        )
-        ext.rewind
-        ext.each do |entry|
-          next unless entry.file?
-          n_path = File.join(path, entry.full_name)
-          FileUtils.mkdir_p(File.dirname(n_path))
-          File.open(n_path, 'w') do |file|
-            while(content = entry.read(2048))
-              file.write(content)
+          File.open(a_path = File.join(path, 'asset'), 'w') do |file|
+            while(content = result.body.readpartial(2048))
+              file.write content
+            end
+          end
+          ext = Gem::Package::TarReader.new(
+            Zlib::GzipReader.open(a_path)
+          )
+          ext.rewind
+          ext.each do |entry|
+            next unless entry.file?
+            n_path = File.join(path, entry.full_name)
+            FileUtils.mkdir_p(File.dirname(n_path))
+            File.open(n_path, 'w') do |file|
+              while(content = entry.read(2048))
+                file.write(content)
+              end
             end
           end
+          FileUtils.rm(a_path)
         end
-        path
+        Dir.glob(File.join(path, '*')).first
+      end
+
+      # @return [TrueClass, FalseClass]
+      def clean_asset(asset_path)
+        super File.dirname(asset_path)
       end
 
     end

data/lib/batali/source.rb

@@ -2,7 +2,7 @@ require 'batali'
 
 module Batali
   # Source of asset
-  class Source < Grimoire::Utility
+  class Source < Utility
 
     autoload :Path, 'batali/source/path'
     autoload :Site, 'batali/source/site'
@@ -25,6 +25,20 @@ module Batali
       raise NotImplementedError.new 'Abstract class'
     end
 
+    # @return [TrueClass, FalseClass]
+    def clean_asset(asset_path)
+      if(self.respond_to?(:cache))
+        false
+      else
+        if(File.exists?(asset_path))
+          FileUtils.rm_rf(asset_path)
+          true
+        else
+          false
+        end
+      end
+    end
+
     # Build a source
     #
     # @param args [Hash]

data/lib/batali/unit_loader.rb

@@ -0,0 +1,70 @@
+require 'batali'
+
+module Batali
+
+  class UnitLoader < Utility
+
+    include Bogo::Memoization
+
+    attribute :file, BFile, :required => true
+    attribute :system, Grimoire::System, :required => true
+    attribute :cache, String, :required => true
+
+    # Populate the system with units
+    #
+    # @return [self]
+    def populate!
+      memoize(:populate) do
+        file.source.each do |src|
+          src.units.find_all do |unit|
+            if(restrictions[unit.name])
+              restrictions[unit.name] == src.identifier
+            else
+              true
+            end
+          end.each do |unit|
+            system.add_unit(unit)
+          end
+        end
+        file.cookbook.each do |ckbk|
+          if(ckbk.path)
+            source = Origin::Path.new(
+              :name => ckbk.name,
+              :path => ckbk.path
+            )
+          elsif(ckbk.git)
+            source = Origin::Git.new(
+              :name => ckbk.name,
+              :url => ckbk.git,
+              :ref => ckbk.ref || 'master',
+              :cache => cache
+            )
+          end
+          if(source)
+            system.add_unit(source.units.first)
+          end
+        end
+      end
+    end
+
+    # @return [Smash]
+    def restrictions
+      memoize(:restrictions) do
+        rest = (file.restrict || Smash.new).to_smash
+        file.cookbook.each do |ckbk|
+          if(ckbk.path)
+            rest[ckbk.name] = Smash.new(:path => ckbk.path).checksum
+          elsif(ckbk.git)
+            rest[ckbk.name] = Smash.new(
+              :url => ckbk.git,
+              :ref => ckbk.ref
+            ).checksum
+          end
+        end
+        rest
+      end
+    end
+
+  end
+
+end

data/lib/batali/utility.rb

@@ -0,0 +1,7 @@
+require 'batali'
+
+module Batali
+  class Utility < Grimoire::Utility
+
+  end
+end

data/lib/batali/version.rb

@@ -1,3 +1,3 @@
 module Batali
-  VERSION = Gem::Version.new('0.1.0')
+  VERSION = Gem::Version.new('0.1.2')
 end

data/lib/batali.rb

@@ -5,11 +5,14 @@ module Batali
 
   autoload :Command, 'batali/command'
   autoload :Config, 'batali/config'
+  autoload :Git, 'batali/git'
   autoload :Manifest, 'batali/manifest'
-  autoload :RemoteSite, 'batali/remote_site'
+  autoload :Origin, 'batali/origin'
   autoload :ScoreKeeper, 'batali/score_keeper'
   autoload :Source, 'batali/source'
   autoload :Unit, 'batali/unit'
+  autoload :UnitLoader, 'batali/unit_loader'
+  autoload :Utility, 'batali/utility'
 
 end
 

metadata

@@ -1,29 +1,43 @@
 --- !ruby/object:Gem::Specification
 name: batali
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.1.2
 platform: ruby
 authors:
 - Chris Roberts
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-03-06 00:00:00.000000000 Z
+date: 2015-03-10 00:00:00.000000000 Z
 dependencies:
+- !ruby/object:Gem::Dependency
+  name: attribute_struct
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.2.14
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.2.14
 - !ruby/object:Gem::Dependency
   name: grimoire
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.1.2
+        version: 0.1.4
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.1.2
+        version: 0.1.4
 - !ruby/object:Gem::Dependency
   name: bogo
   requirement: !ruby/object:Gem::Requirement
@@ -66,6 +80,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: 0.1.10
+- !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: http
   requirement: !ruby/object:Gem::Requirement
@@ -129,14 +157,21 @@ files:
 - lib/batali/command/resolve.rb
 - lib/batali/command/update.rb
 - lib/batali/config.rb
+- lib/batali/git.rb
 - lib/batali/manifest.rb
 - lib/batali/monkey.rb
-- lib/batali/remote_site.rb
+- lib/batali/origin.rb
+- lib/batali/origin/git.rb
+- lib/batali/origin/path.rb
+- lib/batali/origin/remote_site.rb
 - lib/batali/score_keeper.rb
 - lib/batali/source.rb
+- lib/batali/source/git.rb
 - lib/batali/source/path.rb
 - lib/batali/source/site.rb
 - lib/batali/unit.rb
+- lib/batali/unit_loader.rb
+- lib/batali/utility.rb
 - lib/batali/version.rb
 homepage: https://github.com/hw-labs/batali
 licenses:

data/lib/batali/remote_site.rb

@@ -1,98 +0,0 @@
-require 'batali'
-require 'digest/sha2'
-require 'securerandom'
-require 'http'
-require 'fileutils'
-
-module Batali
-  # Fetch unit information from remote site
-  class RemoteSite < Grimoire::Utility
-
-    # Site suffix for API endpoint
-    COOKBOOK_API_SUFFIX = 'api/v1/cookbooks'
-
-    include Bogo::Memoization
-
-    attribute :name, String
-    attribute :identifier, String
-    attribute :endpoint, String, :required => true
-    attribute :force_update, [TrueClass, FalseClass], :required => true, :default => false
-    attribute :update_interval, Integer, :required => true, :default => 10000 # NOTE: reset this default to 60/120 when ready
-    attribute :cache, String, :default => File.expand_path('~/.batali/cache/remote_site'), :required => true
-
-    def initialize(*_)
-      super
-      endpoint = URI.join(self.endpoint, COOKBOOK_API_SUFFIX).to_s
-      self.identifier = Digest::SHA256.hexdigest(endpoint)
-      unless(name?)
-        self.name = self.identifier
-      end
-    end
-
-    # @return [String] cache directory path
-    def cache_directory
-      memoize(:cache_directory) do
-        path = File.join(cache, identifier)
-        FileUtils.mkdir_p(path)
-        path
-      end
-    end
-
-    # @return [Array<Unit>] all units
-    def units
-      memoize(:units) do
-        items.map do |u_name, versions|
-          versions.map do |version, info|
-            Unit.new(
-              :name => u_name,
-              :version => version,
-              :dependencies => info[:dependencies].to_a,
-              :source => Smash.new(
-                :type => :site,
-                :url => info[:download_url],
-                :version => version,
-                :dependencies => info[:dependencies]
-              )
-            )
-          end
-        end.flatten
-      end
-    end
-
-    protected
-
-    # @return [Smash] all info
-    def items
-      memoize(:items) do
-        MultiJson.load(File.read(fetch)).to_smash
-      end
-    end
-
-    # Fetch the universe
-    #
-    # @return [String] path to universe file
-    def fetch
-      do_fetch = true
-      if(File.exists?(universe_path))
-        age = Time.now - File.mtime(universe_path)
-        if(age < update_interval)
-          do_fetch = false
-        end
-      end
-      if(do_fetch)
-        t_uni = "#{universe_path}.#{SecureRandom.urlsafe_base64}"
-        File.open(t_uni, 'w') do |file|
-          file.write HTTP.get(URI.join(endpoint, 'universe')).body.to_s
-        end
-        FileUtils.mv(t_uni, universe_path)
-      end
-      universe_path
-    end
-
-    # @return [String] path to universe file
-    def universe_path
-      File.join(cache_directory, 'universe.json')
-    end
-
-  end
-end