pione 0.2.1 → 0.2.2

data/lib/pione/location/git-repository-location.rb

@@ -0,0 +1,153 @@
+module Pione
+  module Location
+    # GitRepositoryLocation represents locations of git repository.
+    class GitRepositoryLocation < BasicLocation
+      location_type :git_repository
+
+      attr_reader :tag
+
+      def initialize(address)
+        @address = address[:git].to_s
+        @tag = address[:tag].to_s
+        @branch = address[:branch].to_s
+        @hash_id = address[:hash_id].to_s
+        @address_digest = Digest::SHA1.hexdigest(@address)
+      end
+
+      # Return a new location with the option.
+      def +(option)
+        self.class.new({git: @address, tag: @tag, branch: @branch, hash_id: @hash_id}.merge(option))
+      end
+
+      # Return the local location of repository.
+      def local
+        Global.git_repository_directory + @address_digest
+      end
+
+      # Return true if the local location exists.
+      def has_local?
+        local.exist?
+      end
+
+      # Return a hash id string of the referrence name.
+      def ref(query)
+        clone_to_local unless has_local?
+
+        # parse query
+        type = query.keys.first
+        name = query[type]
+
+        # execute "git show-ref"
+        out = Temppath.create.open("w+")
+        process = ChildProcess.build("git", "show-ref")
+        process.cwd = local.path.to_s
+        process.io.stdout = out
+        process.start
+        process.wait
+
+        if process.crashed?
+          raise GitError.new("The command 'git clone' failed.", @address)
+        end
+
+        # find hash id
+        out.rewind
+        out.readlines.each do |line|
+          hash_id, refname = line.split(" ")
+
+          cond_tag = (type == :tag and "refs/tags/%s" % name == refname)
+          cond_branch = (type == :branch and "refs/remotes/origin/%s" % name == refname)
+
+          return hash_id if cond_tag or cond_branch
+        end
+
+        # the name not found
+        return nil
+      end
+
+      # Return compact version hash id string.
+      def compact_hash_id
+        id = @hash_id if @hash_id
+        id = ref(tag: @tag) if @tag
+        id = ref(branch: @branch) if @branch
+        id = ref(branch: "HEAD") unless id
+        return short_hash_id(id)
+      end
+
+      # Export git repository by hash id.
+      def export(location)
+        clone_to_local unless has_local?
+
+        hash_id = compact_hash_id
+
+        # git archive
+        path = Temppath.mkdir + "archive.zip"
+        ChildProcess.build("git", "archive", "-o", path.to_s, hash_id).tap do |process|
+          process.cwd = local.path
+          process.start
+          process.wait
+          if process.crashed?
+            raise GitError.new(@location, message: "'git archive' failed")
+          end
+        end
+
+        # unzip
+        local = Location[Temppath.mkdir]
+        Util::Zip.uncompress(Location[path], local)
+
+        # update package.yml
+        info = YAML.load((local + "package.yml").read)
+        info["HashID"] = hash_id
+        (local + "package.yml").update(YAML.dump(info))
+
+        # upload
+        local.entries.each {|entry| entry.move(location)}
+      end
+
+      private
+
+      # Call "git clone" from the repository into local location.
+      #
+      # @param path [Pathname]
+      #   the path of cloned repository
+      def clone_to_local
+        out = Temppath.create.open("w+")
+
+        # call git clone
+        process = ChildProcess.build("git", "clone", @address, local.path.to_s)
+        process.io.stdout = out
+        process.start
+        process.wait
+
+        # show debug message
+        out.rewind
+        ErrorReport.debug("git clone: %s" % out.read, self, __FILE__, __LINE__)
+
+        # check the process result
+        if process.crashed?
+          raise GitError.new(self, message: "'git clone' failed")
+        end
+      end
+
+      # Return short hash id.
+      def short_hash_id(hash_id)
+        out = Temppath.create.open("w+")
+
+        # git rev-parse
+        process = ChildProcess.build("git", "rev-parse", "--short", hash_id)
+        process.cwd = local.path.to_s
+        process.io.stdout = out
+        process.start
+        process.wait
+
+        # check the process result
+        if process.crashed?
+          raise GitError.new(self, message: "Hash ID '%s' is unknown or too short" % hash_id)
+        end
+
+        # show debug message
+        out.rewind
+        return out.read.chomp
+      end
+    end
+  end
+end

data/lib/pione/location/http-location.rb

@@ -0,0 +1,65 @@
+module Pione
+  module Location
+    class HTTPLocation < DataLocation
+      set_scheme "http"
+      set_real_appendable false
+      set_writable false
+
+      def read
+        http_get {|res| res.body}
+      end
+
+      def mtime
+        http_head {|res| Time.httpdate(res['last-modified']) }
+      end
+
+      def size
+        http_head {|res| res.content_length } || read.size
+      end
+
+      def exist?
+        http_head {|res| true}
+      rescue
+        false
+      end
+
+      def file?
+        exist?
+      end
+
+      def directory?
+        false
+      end
+
+      def copy(dest)
+        http_get {|rec| dest.write rec.body}
+      end
+
+      private
+
+      # Send a request HTTP Get and evaluate the block with the response.
+      def http_get(&b)
+        http = Net::HTTP.new(@uri.host, @uri.port)
+        req = Net::HTTP::Get.new(@uri.path)
+        res = http.request(req)
+        if res.kind_of?(Net::HTTPSuccess)
+          return b.call(res)
+        else
+          raise NotFound.new(@uri)
+        end
+      end
+
+      # Send a request HTTP Head and evaluate the block with the response.
+      def http_head(&b)
+        http = Net::HTTP.new(@uri.host, @uri.port)
+        req = Net::HTTP::Head.new(@uri.path)
+        res = http.request(req)
+        if res.kind_of?(Net::HTTPSuccess)
+          return b.call(res)
+        else
+          raise NotFound(@uri)
+        end
+      end
+    end
+  end
+end

data/lib/pione/location/https-location.rb

@@ -0,0 +1,37 @@
+module Pione
+  module Location
+    class HTTPSLocation < HTTPLocation
+      set_scheme "https"
+      set_real_appendable false
+      set_writable false
+
+      # Send a request HTTPS Get and evaluate the block with the response.
+      def http_get(&b)
+        http = Net::HTTP.new(@uri.host, @uri.port)
+        http.use_ssl = true
+        http.verify_mode = OpenSSL::SSL::VERIFY_NONE
+        req = Net::HTTP::Get.new(@uri.path)
+        res = http.request(req)
+        if res.kind_of?(Net::HTTPSuccess)
+          return b.call(res)
+        else
+          raise NotFound.new(@uri)
+        end
+      end
+
+      # Send a request HTTPS Head and evaluate the block with the response.
+      def http_head(&b)
+        http = Net::HTTP.new(@uri.host, @uri.port)
+        http.use_ssl = true
+        http.verify_mode = OpenSSL::SSL::VERIFY_NONE
+        req = Net::HTTP::Head.new(@uri.path)
+        res = http.request(req)
+        if res.kind_of?(Net::HTTPSuccess)
+          return b.call(res)
+        else
+          raise NotFound(@uri)
+        end
+      end
+    end
+  end
+end

data/lib/pione/location/local-location.rb

@@ -1,7 +1,7 @@
 module Pione
   module Location
     # LocalLocation represents local disk locations.
-    class LocalLocation < BasicLocation
+    class LocalLocation < DataLocation
       set_scheme "local"
       set_real_appendable true
 
@@ -54,6 +54,10 @@ module Pione
         end
       end
 
+      def mkdir
+        @path.mkpath unless exist?
+      end
+
       def mtime
         @path.exist? ? @path.mtime : (raise NotFound.new(self))
       end
@@ -62,16 +66,31 @@ module Pione
         @path.exist? ? @path.size : (raise NotFound.new(self))
       end
 
-      def entries
-        @path.entries.select do |entry|
-          not(entry.to_s == "." or entry.to_s == "..")
-        end.map do |entry|
+      def entries(option={})
+        rel_entries(option).map do |entry|
           Location["local:%s" % (@path + entry).expand_path]
         end
       rescue Errno::ENOENT
         raise NotFound.new(self)
       end
 
+      def rel_entries(option={})
+        list = []
+        @path.entries.each do |entry|
+          if not(entry.to_s == "." or entry.to_s == "..")
+            list << entry
+            entry_location = self + entry
+            if option[:rec] and entry_location.directory?
+              _list = entry_location.rel_entries(option).map {|subentry| entry + subentry}
+              list = list + _list
+            end
+          end
+        end
+        return list
+      rescue Errno::ENOENT
+        raise NotFound.new(self)
+      end
+
       def file?
         @path.file?
       end

data/lib/pione/parser.rb

@@ -0,0 +1,14 @@
+module Pione
+  # Parser is a namespace for PIONE parsers.
+  module Parser; end
+end
+
+require 'pione/parser/parslet-extension'
+require 'pione/parser/common-parser'
+require 'pione/parser/literal-parser'
+require 'pione/parser/feature-expr-parser'
+require 'pione/parser/expr-parser'
+require 'pione/parser/flow-element-parser'
+require 'pione/parser/block-parser'
+require 'pione/parser/rule-definition-parser'
+require 'pione/parser/document-parser'

data/lib/pione/patch.rb

@@ -0,0 +1,10 @@
+module Pione
+  # Patch is a namespace for patches.
+  module Patch; end
+end
+
+require 'pione/patch/array-patch'
+require 'pione/patch/drb-patch'
+require 'pione/patch/rinda-patch'
+require 'pione/patch/uri-patch'
+require 'pione/patch/monitor-patch'

data/lib/pione/patch/drb-patch.rb

@@ -136,7 +136,7 @@ module DRb
             req_id, succ, result = recv_reply
             DRb.waiter_table.push(req_id, [succ, result])
           end
-        rescue Exception => e
+        rescue => e
           @watcher_mutex.synchronize do
             @watchers.each do |watcher|
               if watcher.alive?
@@ -333,7 +333,7 @@ module DRb
           result = DRbArray.new(result)
         end
         return true, result
-      rescue StandardError, ScriptError, Interrupt => e
+      rescue StandardError, ScriptError => e
         return false, e
       end
 

data/lib/pione/relay.rb

@@ -0,0 +1,11 @@
+module Pione
+  # Relay is a namespace for relay.
+  module Relay; end
+end
+
+require 'pione/relay/transmitter-socket'
+require 'pione/relay/trampoline'
+require 'pione/relay/receiver-socket'
+require 'pione/relay/relay-socket'
+require 'pione/relay/relay-client-db'
+require 'pione/relay/relay-account-db'

data/lib/pione/system/file-cache.rb

@@ -135,7 +135,7 @@ module Pione
         def get(location)
           # cache if record doesn't exist
           unless @table.has_key?(location)
-            cache_location = Location[Temppath.create(nil, @tmpdir)]
+            cache_location = Location[Temppath.create(basedir: @tmpdir)]
             location.turn(cache_location)
             @table[location] = cache_location
           end

data/lib/pione/system/global.rb

@@ -191,6 +191,21 @@ module Pione
         Pathname.new(Dir.mktmpdir(nil, Global.file_cache_directory_root))
       end
 
+      # Git repository directory
+      define_item(:git_repository_directory, false) do
+        Location[Global.dot_pione_dir + "git-repository"]
+      end
+
+      # Git package directory
+      define_item(:git_package_directory, false) do
+        Location[Global.dot_pione_dir] + "git-package"
+      end
+
+      # archive_package_cache_dir
+      define_item(:archive_package_cache_dir, false) do
+        Location[Global.dot_pione_dir + "archive-package-cache"]
+      end
+
       # system front server
       define_item(:front, false)
 

data/lib/pione/tuple-space.rb

@@ -0,0 +1,11 @@
+module Pione
+  # TupleSpace is a namespace for tuple space classes.
+  module TupleSpace; end
+end
+
+require 'pione/tuple-space/tuple-space-server-interface'
+require 'pione/tuple-space/presence-notifier'
+require 'pione/tuple-space/tuple-space-server'
+require 'pione/tuple-space/tuple-space-receiver'
+require 'pione/tuple-space/tuple-space-provider'
+require 'pione/tuple-space/data-finder'

data/lib/pione/tuple-space/tuple-space-server.rb

@@ -151,7 +151,7 @@ module Pione
         @terminated = true
         write(Tuple[:command].new("terminate", nil))
         @client_life_checker.terminate
-        @client_life_checker.running_thread.join
+        @client_life_checker.running_thread.kill
         sleep 1
       end
 

data/lib/pione/util.rb

@@ -17,4 +17,5 @@ require 'pione/util/variable-holdable'
 require 'pione/util/evaluatable'
 require 'pione/util/process-info'
 require 'pione/util/package-parameters-list'
+require 'pione/util/zip'
 

data/lib/pione/util/error-report.rb

@@ -15,6 +15,13 @@ module Pione
         end
       end
       module_function :warn
+
+      def debug(msg, receiver, file, line)
+        if Pione.debug_mode?
+          $stderr.puts "PIONE debug [%s:%i] %s (%s)" % [file, line, msg, receiver]
+        end
+      end
+      module_function :debug
     end
   end
 end