ruby-quilt 0.1.10 → 0.2.0

data/lib/quilt.rb

@@ -12,11 +12,14 @@ class Quilt
   OPTIONAL_KEY = "optional"
   FOOTER_KEY = "footer"
   PREFIX_KEY = "prefix"
+  DEPENDANCIES_KEY = "dependancies"
+  POSITION_KEY = "position"
   DEBUG_PREFIX_KEY = "debug_prefix"
   ARCHIVE_SUFFIX = ".tgz"
   DEFAULT_LRU_SIZE = 10
 
   def initialize(config = "quilt", log = Logger.new(STDOUT))
+    @@fetching_versions = {}
     config_prefix = config ? "#{config}:" : ""
     @config = {
       :local_path => Ecology.property("#{config_prefix}local_path", :as => String),
@@ -59,8 +62,9 @@ class Quilt
     matches[2]
   end
 
-  def get_module(filename, dependancies, version_dir)
+  def get_module(filename, dependancies, position, version_dir)
     tmp_module = {}
+    tmp_module[:position] = position
     tmp_module[:dependancies] = dependancies.is_a?(Array) ? dependancies :
                                                             (dependancies.is_a?(String) ? [ dependancies ] :
                                                             [])
@@ -73,6 +77,14 @@ class Quilt
     tmp_module
   end
 
+  def version_exists_locally?(local_path, version_name)
+    begin
+      manifest = JSON.parse(File.read(File.join(File.join(local_path, version_name), "manifest.json")))
+    rescue Exception => e
+      return false
+    end
+  end
+
   def load_version(local_path, version_name)
     log_debug("Loading Version: "+version_name)
     manifest = {}
@@ -117,9 +129,13 @@ class Quilt
     #    ],
     #    "optional" : {
     #      "<module file>" : [ "<dependancy module name>", ... ],
+    #      "<module file>" : { "dependancies" : [ "<dependancy module name>", ... ], "position" : "<position>" }
     #      ...
     #    }
     #  }
+    #
+    #  where <position> can be one of: before_header, after_header, before_common, after_common,
+    #                                  before_optional, optional, after_optional, before_footer, after_footer
     module_loader = Proc.new do |prefix|
       dir = new_version[prefix][:dir]
       if manifest[HEADER_KEY]
@@ -140,10 +156,18 @@ class Quilt
         end
       end
       if manifest[OPTIONAL_KEY] && manifest[OPTIONAL_KEY].is_a?(Hash)
-        manifest[OPTIONAL_KEY].each do |filename, dependancies|
+        manifest[OPTIONAL_KEY].each do |filename, value|
+          dependancies = []
+          position = :optional
+          if (value.is_a?(Array))
+            dependancies = value
+          elsif (value.is_a?(Hash))
+            dependancies = value[DEPENDANCIES_KEY] || []
+            position = value[POSITION_KEY] ? value[POSITION_KEY].to_sym : :optional
+          end
           tmp_module_name = get_module_name(filename)
           if (tmp_module_name)
-            tmp_module = get_module(filename, dependancies, dir)
+            tmp_module = get_module(filename, dependancies, position, dir)
             if (tmp_module)
               new_version[prefix][:optional][tmp_module_name] = tmp_module
             end
@@ -168,7 +192,7 @@ class Quilt
     new_version
   end
 
-  def resolve_dependancies(modules, version, all_modules = {})
+  def resolve_dependancies(position, modules, version, all_modules = {})
     out = ''
     return out if !modules || !(modules.is_a?(Array)) || modules.empty?
     my_all_modules = all_modules
@@ -184,8 +208,8 @@ class Quilt
         break
       end
       my_all_modules[name] = 1
-      out = "#{out}#{resolve_dependancies(version[:optional][name][:dependancies], version, my_all_modules)}"
-      out = "#{out}#{version[:optional][name][:module]}"
+      out = "#{out}#{resolve_dependancies(position, version[:optional][name][:dependancies], version, my_all_modules)}"
+      out = "#{out}#{version[:optional][name][:module]}" if version[:optional][name][:position] == position
       my_all_modules[name] = 2
     end
     out
@@ -194,61 +218,70 @@ class Quilt
   def get_version(name)
     return @versions[name] if @versions[name]
     # check local path
-    @versions[name] = load_version(@config[:local_path], name)
-    return @versions[name] if @versions[name]
-    # check remote path
-    if (!@config[:remote_host] || !@config[:remote_path])
-      log_error("unable to load from host: #{@config[:remote_host]}, path: #{@config[:remote_path]}")
-      return nil
-    end
-    port = @config[:remote_port] ? @config[:remote_port].to_i : 80
-    # Fetch the version
-    filename = "#{name}#{ARCHIVE_SUFFIX}"
-    version_dir = File.join(@config[:local_path], name)
-    begin
-      res = Net::HTTP.get_response(@config[:remote_host].to_s,
-                                   File.join(@config[:remote_path].to_s, filename), port)
-      if (res.code != "200")
-        log_error("no version fetched : #{res.code}")
-        return nil
+    # sleep at most 10 seconds to wait until a version is fetched and untared
+    @@fetching_versions[name] ||= Mutex.new
+    @@fetching_versions[name].synchronize do
+      if version_exists_locally?(@config[:local_path], name)
+        @versions[name] = load_version(@config[:local_path], name)
+        return @versions[name] if @versions[name]
       end
-      FileUtils.mkdir(version_dir) unless File.exists?(version_dir)
-      open(File.join(version_dir, filename), "wb") do |file|
-        file.write(res.body)
+      # check remote path
+      if (!@config[:remote_host] || !@config[:remote_path])
+        log_error("unable to load from host: #{@config[:remote_host]}, path: #{@config[:remote_path]}")
+        return nil
       end
-    rescue Exception => e
-      log_error("could not fetch version", e)
-      return nil
-    end
-    # Untar the version
-    tar_stdout = nil
-    tar_stderr = nil
-    tar_status =
-      POpen4::popen4("cd #{version_dir} && tar -xzf #{filename} && rm #{filename}") do |stdo, stde, stdi, pid|
-      stdi.close
-      tar_stdout = stdo.read.strip
-      tar_stderr = stde.read.strip
-    end
-    if (!tar_status.exitstatus.zero?)
-      log_error("unable to untar package: cd #{version_dir} && tar -xzf #{filename} && rm #{filename}")
-      log_error("stdout: #{tar_stdout}")
-      log_error("stderr: #{tar_stderr}")
+      port = @config[:remote_port] ? @config[:remote_port].to_i : 80
+      # Fetch the version
+      filename = "#{name}#{ARCHIVE_SUFFIX}"
+      version_dir = File.join(@config[:local_path], name)
       begin
-        FileUtils.rm_r(version_dir)
+        res = Net::HTTP.get_response(@config[:remote_host].to_s,
+                                     File.join(@config[:remote_path].to_s, filename), port)
+        if (res.code != "200")
+          log_error("no version fetched : #{res.code}")
+          return nil
+        end
+        FileUtils.mkdir(version_dir) unless File.exists?(version_dir)
+        open(File.join(version_dir, filename), "wb") do |file|
+          file.write(res.body)
+        end
       rescue Exception => e
-        # do nothing
+        log_error("could not fetch version", e)
+        return nil
       end
-      return nil
-    end
-    # Load the version
-    @versions[name] = load_version(@config[:local_path], name)
-    if (!@versions[name])
-      begin
-        FileUtils.rm_r(version_dir)
-      rescue Exception => e
-        # do nothing
+      # Untar the version
+      tar_stdout = nil
+      tar_stderr = nil
+      tar_status =
+        POpen4::popen4("cd #{version_dir} && tar -xzf #{filename} && rm #{filename}") do |stdo, stde, stdi, pid|
+        stdi.close
+        tar_stdout = stdo.read.strip
+        tar_stderr = stde.read.strip
       end
-      return nil
+      if (!tar_status.exitstatus.zero?)
+        log_error("unable to untar package: cd #{version_dir} && tar -xzf #{filename} && rm #{filename}")
+        log_error("stdout: #{tar_stdout}")
+        log_error("stderr: #{tar_stderr}")
+        begin
+          FileUtils.rm_r(version_dir)
+        rescue Exception => e
+          # do nothing
+        end
+        return nil
+      end
+      # Load the version
+      @versions[name] = load_version(@config[:local_path], name)
+      if (!@versions[name])
+        begin
+          FileUtils.rm_r(version_dir)
+        rescue Exception => e
+          # do nothing
+        end
+        return nil
+      end
+    end
+    @@fetching_versions.reject! do |key, value|
+      key == name
     end
     @versions[name]
   end
@@ -275,39 +308,40 @@ class Quilt
     # resolve dependancies
     dynamics = dynamic_modules && dynamic_modules.is_a?(Hash) ? dynamic_modules : {}
     output = "#{
-      resolve_dynamic(:before_header, dynamics, outversion)
+      resolve_dynamic(:before_header, modules, dynamics, outversion)
     }#{
       outversion[:header]
     }#{
-      resolve_dynamic(:after_header, dynamics, outversion)
+      resolve_dynamic(:after_header, modules, dynamics, outversion)
     }#{
-      resolve_dynamic(:before_common, dynamics, outversion)
+      resolve_dynamic(:before_common, modules, dynamics, outversion)
     }#{
       outversion[:common]
     }#{
-      resolve_dynamic(:after_common, dynamics, outversion)
+      resolve_dynamic(:after_common, modules, dynamics, outversion)
     }#{
-      resolve_dynamic(:before_optional, dynamics, outversion)
+      resolve_dynamic(:before_optional, modules, dynamics, outversion)
     }#{
-      resolve_dependancies(modules, outversion, {})
+      resolve_dynamic(:optional, modules, dynamics, outversion)
     }#{
-      resolve_dynamic(:after_optional, dynamics, outversion)
+      resolve_dynamic(:after_optional, modules, dynamics, outversion)
     }#{
-      resolve_dynamic(:before_footer, dynamics, outversion)
+      resolve_dynamic(:before_footer, modules, dynamics, outversion)
     }#{
       outversion[:footer]
     }#{
-      resolve_dynamic(:after_footer, dynamics, outversion)
+      resolve_dynamic(:after_footer, modules, dynamics, outversion)
     }"
   end
 
-  def resolve_dynamic(sym, dynamics, version)
-    dynamics[sym].is_a?(Array) ? resolve_dependancies(dynamics[sym], version, {}) : (dynamics[sym] || '')
+  def resolve_dynamic(position, modules, dynamics, version)
+    dynamics[position].is_a?(Array) ? resolve_dependancies(position, dynamics[position] + modules, version, {}) :
+      "#{(dynamics[position] || '')}#{resolve_dependancies(position, modules, version, {})}"
   end
 
   def health
     # return true if no remote info
-    return [true, nil] if !@config[:remote_host] || !@config[:remote_path]
+    return [true, nil, nil] if !@config[:remote_host] || !@config[:remote_path]
     # fetch health_check.txt from remote URL
     host = @config[:remote_host].to_s
     port = @config[:remote_port] ? @config[:remote_port].to_i : 80
@@ -315,12 +349,13 @@ class Quilt
     begin
       res = Net::HTTP.get_response(host, path, port)
       if (res.code != "200")
-        return [false, "Could not fetch heath check file: http://#{host}:#{port}#{path} - status #{res.code}"]
+        return [false, "Could not fetch heath check file: http://#{host}:#{port}#{path} - status #{res.code}",
+                nil]
       end
     rescue Exception => e
-      return [false, "Could not fetch heath check file: http://#{host}:#{port}#{path} - #{e.message}"]
+      return [false, "Could not fetch heath check file: http://#{host}:#{port}#{path} - #{e.message}", e]
     end
-    [true, nil]
+    [true, nil, nil]
   end
 
   def status

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: ruby-quilt
 version: !ruby/object:Gem::Version
-  version: 0.1.10
+  version: 0.2.0
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-06-25 00:00:00.000000000 Z
+date: 2012-06-27 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: json