pione 0.1.2 → 0.1.3

data/lib/pione/location.rb

@@ -0,0 +1,10 @@
+module Pione
+  # Location is a name space for all location classes.
+  module Location; end
+end
+
+require 'pione/location/basic-location'
+require 'pione/location/local-location'
+require 'pione/location/ftp-location'
+require 'pione/location/dropbox-location'
+

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

@@ -0,0 +1,272 @@
+module Pione
+  module Location
+    # LocationError is raised when any resource errors happen.
+    class LocationError < Exception
+      def initialize(location)
+        @location = location
+      end
+    end
+
+    # ExistAlready is raised when there is data on the location already.
+    class ExistAlready < LocationError; end
+
+    # NotFound is raised when there isn't data on the location.
+    class NotFound < LocationError
+      def message
+        "%s not found" % @location.inspect
+      end
+    end
+
+    # known schemes table
+    SCHEMES = {}
+
+    # Return the location object corresponding to the URI.
+    #
+    # @param uri [URI,String]
+    #   URI or location representing string
+    # @return [BasicLocation]
+    #   location object
+    def self.[](uri)
+      uri = URI.parse(uri.to_s)
+      uri = uri.scheme ? uri : URI.parse("local:%s" % Pathname.new(uri.path).expand_path)
+      if location_class = SCHEMES[uri.scheme]
+        location_class.new(uri)
+      else
+        raise ArgumentError.new(uri)
+      end
+    end
+
+    # BasicLocation is a class for all location classes.
+    class BasicLocation
+      class << self
+        # @return [String]
+        #   location's scheme name
+        attr_reader :scheme
+
+        # Declare the name as location scheme.
+        #
+        # @param name [String]
+        #   scheme name
+        def set_scheme(name)
+          @scheme = name
+          SCHEMES[name] = self
+        end
+      end
+
+      forward :class, :scheme
+      forward :@uri, :host
+
+      # @return [URI]
+      #   URI of the location
+      attr_reader :uri
+
+      # @return [Pathname]
+      #   path of the location
+      attr_reader :path
+
+      # Create a location with the URI.
+      #
+      # @param uri [URI]
+      #   location URI
+      def initialize(uri)
+        @uri = uri.kind_of?(URI::Generic) ? uri : URI.parse(uri)
+        @path = Pathname.new(uri.path)
+        raise ArgumentError.new(uri) unless @uri.scheme = scheme
+      end
+
+      # Create new location appended the name.
+      #
+      # @param name [String]
+      #   filename or directory name
+      # @return [BasicLocation]
+      #   new location
+      def +(name)
+        self.class.new(@uri.as_directory + name)
+      end
+
+      # Create new location that has URI as a directory.
+      #
+      # @return [BasicLocation]
+      #   new location
+      def as_directory
+        self.class.new(@uri.as_directory)
+      end
+
+      # Return the basename of the location.
+      #
+      # @param suffix [String]
+      #   suffix name
+      # @return [String]
+      #   basename
+      def basename(suffix="")
+        File.basename(@path, suffix)
+      end
+
+      # Rebuild location with the path.
+      #
+      # @param path [Pathname]
+      #   new path
+      # @return [Location]
+      #   location with new path
+      def rebuild(path)
+        scheme = @uri.scheme
+        auth = "%s:%s@" % [@uri.user, @uri.password] if @uri.user and @uri.password
+        host = @uri.host
+        port = ":%i" % @uri.port
+        path = path.expand_path("/").to_s
+        Location["%s://%s%s%s%s" % [scheme, auth, host, port, path]]
+      end
+
+      # Return true if the location is cached.
+      #
+      # @return [Boolean]
+      #   true if the location is cached
+      def cached?
+        System::FileCache.cached?(self)
+      end
+
+      # Creates a location.
+      #
+      # @param data [String]
+      #   data content
+      # @return[void]
+      def create(data)
+        raise NotImplementedError
+      end
+
+      # Append data to the location data.
+      #
+      # @param data [String]
+      #   data content
+      # @return [void]
+      def append(data)
+        raise NotImplmentedError
+      end
+
+      # Read location data.
+      #
+      # @return [String]
+      #   data content
+      def read
+        raise NotImplementedError
+      end
+
+      # Update with the data.
+      #
+      # @param data [String]
+      #   new data content
+      # @return [void]
+      def update(data)
+        raise NotImplementedError
+      end
+
+      # Delete data of the location.
+      #
+      # @return [void]
+      def delete
+        raise NotImplementedError
+      end
+
+      # Return last modification time of the location.
+      #
+      # @return [Time]
+      #   last modification time
+      def mtime
+        raise NotImplementedError
+      end
+
+      # Return byte size of data in the location.
+      #
+      # @return [Integer]
+      #   byte size of data
+      def size
+        raise NotImplementedError
+      end
+
+      # Return entries of the resource path.
+      #
+      # @return [Array<Location>]
+      #   entries of the location path
+      def entries
+        raise NotImplementedError
+      end
+
+      # Return true if there is data in the location.
+      #
+      # @return [Boolean]
+      #   if there is data in the location
+      def exist?
+        raise NotImplementedError
+      end
+
+      # Return true if data in the location is a file.
+      #
+      # @return [Boolean]
+      #   true if data in the location is a file
+      def file?
+        raise NotImplementedError
+      end
+
+      # Return true if data in the location is a directory.
+      #
+      # @return [Boolean]
+      #   true if data in the location is a directory
+      def directory?
+        raise NotImplementedError
+      end
+
+      # Move to the destination.
+      #
+      # @param dest [BasicLocation]
+      #   destination
+      # @return [void]
+      def move(dest)
+        raise NotImplementedError
+      end
+
+      # Copy location's content to the destination.
+      #
+      # @param dest [BasicLocation]
+      #   destination
+      # @return [void]
+      def copy(dest)
+        raise NotImplementedError
+      end
+
+      # Link to the destination.
+      #
+      # @param dest [BasicLocation]
+      #   destination
+      # @return [void]
+      def link(dest)
+        raise NotImplementedError
+      end
+
+      # Move data to the destination and link self to it.
+      #
+      # @param dest [BasicLocation]
+      #   destination
+      # @return [void]
+      def turn(dest)
+        raise NotImplementedError
+      end
+
+      # @api private
+      def inspect
+        "#<%s %s:%s>" % [self.class, scheme, @path.to_s]
+      end
+
+      # @api private
+      def ==(other)
+        return false unless other.kind_of?(self.class)
+        @uri == other.uri
+      end
+      alias :eql? :"=="
+
+      # @api private
+      def hash
+        @uri.hash
+      end
+    end
+  end
+end

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

@@ -0,0 +1,139 @@
+module Pione
+  module Location
+    # DropboxLocation represents locations on Dropbox server.
+    class DropboxLocation < BasicLocation
+      set_scheme "dropbox"
+
+      class << self
+        attr_reader :session
+
+        # Initialize dropbox settings.
+        #
+        # @param tuple_space_server [TupleSpaceServer]
+        #   tuple space server
+        # @return [void]
+        def self.init(tuple_space_server)
+          tuple_consumer_key = Tuple[:attribute].new("dropbox_consumer_key", nil)
+          tuple_consumer_secret = Tuple[:attribute].new("dropbox_consumer_secret", nil)
+          tuple_access_token_key = Tuple[:attribute].new("dropbox_access_token_key", nil)
+          tuple_access_token_secret = Tuple[:attribute].new("dropbox_access_token_secret", nil)
+
+          consumer_key = tuple_space_server.read(tuple_consumer_key, 0).value rescue nil
+          consumer_secret = tuple_space_server.read(tuple_consumer_secret, 0).value rescue nil
+          access_token_key = tuple_space_server.read(tuple_access_token_key, 0).value rescue nil
+          access_token_secret = tuple_space_server.read(tuple_access_token_secret, 0).value rescue nil
+
+          @session = DropboxSession.new(consumer_key, consumer_secret)
+          @session.set_access_token(access_token_key, access_token_secret)
+        end
+
+        # Share dropbox's access token with PIONE agents.
+        #
+        # @param tuple_space_server [TupleSpaceServer]
+        #   tuple space server
+        # @param consumer_key [String]
+        #   consumer key
+        # @param consumer_secret [String]
+        #   consumer secret
+        # @return [void]
+        def share_access_token(tuple_space_server, consumer_key, consumer_secret)
+          access_token = session.get_access_token
+          [ Tuple[:attribute].new("dropbox_consumer_key", consumer_key),
+            Tuple[:attribute].new("dropbox_consumer_secret", consumer_secret),
+            Tuple[:attribute].new("dropbox_access_token_key", access_token.key),
+            Tuple[:attribute].new("dropbox_access_token_secret", access_token.secret)
+          ].each {|tuple| tuple_space_server.write(tuple) }
+        end
+
+        # Return true if dropbox session is authorized.
+        #
+        # @return [Boolean]
+        #   true if dropbox session is authorized
+        def ready?
+          @session.authorized?
+        end
+
+        # Set the session.
+        #
+        # @param session [String]
+        #    dropbox session
+        # @return [void]
+        def self.set_session(session)
+          @session = session
+        end
+      end
+
+      def initialize(uri)
+        super(uri)
+        @client = DropboxClient.new(self.class.session, "app_folder")
+      end
+
+      def create(data)
+        @client.put_file(@path, StringIO.new(data))
+      end
+
+      def read
+        @client.get_file(@path)
+      end
+
+      def update(data)
+        @client.put_file(@path, StringIO.new(data), true)
+      end
+
+      def delete
+        @client.file_delete(@path)
+      end
+
+      def mtime
+        metadata = @client.metadata(@path)
+        Time.parse(metadata["modified"])
+      end
+
+      def entries
+        metadata = @client.metadata(@path)
+        if not(metadata["is_dir"]) or metadata["is_deleted"]
+          raise NotFound.new(self)
+        end
+        metadata["contents"].select{|entry| not(entry["is_dir"]) and not(entry["is_deleted"])}.map do |entry|
+          Location["dropbox:%s" % entry["path"]]
+        end
+      end
+
+      def exist?
+        metadata = @client.metadata(@path)
+        return not(metadata["is_deleted"])
+      rescue DropboxError
+        return false
+      end
+
+      def move(dest)
+        if dest.scheme == scheme
+          @client.file_move(@path, dest.path)
+        else
+          copy(dest)
+          delete
+        end
+      end
+
+      def copy(dest)
+        if dest.scheme == scheme
+          @client.file_copy(@path, dest.path)
+        else
+          dest.update(read)
+        end
+      end
+
+      def link(orig)
+        if orig.scheme == scheme
+          orig.copy(link)
+        else
+          update(orig.read)
+        end
+      end
+
+      def turn(dest)
+        copy(dest)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,156 @@
+module Pione
+  module Location
+    # FTPLocation represents locations on FTP server.
+    class FTPLocation < BasicLocation
+      set_scheme "ftp"
+
+      def rebuild(path)
+        scheme = @uri.scheme
+        auth = "%s:%s@" % [@uri.user, @uri.password] if @uri.user and @uri.password
+        host = @uri.host
+        port = ":%i" % @uri.port
+        path = Pathname.new(path).expand_path("/").to_s
+        Location["%s://%s%s%s%s" % [scheme, auth, host, port, path]]
+      end
+
+      def create(data)
+        if exist?
+          raise ExistAlready.new(self)
+        else
+          connect do |ftp|
+            makedirs(ftp, @path.dirname)
+            file = Temppath.create
+            file.open("w") {|f| f.write(data)}
+            ftp.put(file.to_s, @path.to_s)
+          end
+        end
+      end
+
+      def append(data)
+        exist? ? update(read + data) : create(data)
+      end
+
+      def read
+        begin
+          data = nil
+          file = Temppath.create
+          connect {|ftp| ftp.get(@path, file.to_s)}
+          data = File.read(file.to_s)
+          return data
+        rescue Net::FTPPermError
+          raise NotFound.new(@uri)
+        end
+      end
+
+      def update(data)
+        connect do |ftp|
+          begin
+            ftp.dir(@path.dirname.to_s)
+            src = Temppath.create.tap{|x| x.open("w") {|f| f.write(data)}}.to_s
+            ftp.put(src, @path.to_s)
+          rescue Net::FTPPermError
+            raise NotFound.new(@uri)
+          end
+        end
+      end
+
+      def delete
+        connect {|ftp| ftp.delete(@path.to_s)} if exist?
+      end
+
+      def mtime
+        connect {|ftp| exist? ? ftp.mtime(@path.to_s) : (raise NotFound.new(self))}
+      end
+
+      def size
+        connect {|ftp| exist? ? ftp.size(@path.to_s) : (raise NotFound.new(self))}
+      end
+
+      def entries
+        connect do |ftp|
+          ftp.nlst(@path.to_s).map do |entry|
+            rebuild(@path + entry)
+          end.select {|entry| entry.file?}
+        end
+      end
+
+      def exist?
+        file? or directory?
+      end
+
+      def file?
+        begin
+          connect {|ftp| ftp.size(@path.to_s) > -1}
+        rescue
+          false
+        end
+      end
+
+      def directory?
+        connect do |ftp|
+          begin
+            ftp.chdir(@path.to_s)
+            return true
+          rescue
+            return false
+          end
+        end
+      end
+
+      def copy(dest)
+        dest.create(read)
+      end
+
+      def link(orig)
+        orig.copy(self)
+      end
+
+      def move(dest)
+        if dest.scheme == scheme and dest.host == host
+          ftp.rename(@path.to_s, dest.path.to_s)
+        else
+          copy(dest)
+          delete
+        end
+      end
+
+      def turn(dest)
+        copy(dest)
+      end
+
+      def inspect
+        scheme = @uri.scheme
+        auth = "%s:%s@" % [@uri.user, @uri.password] if @uri.user and @uri.password
+        host = @uri.host
+        port = ":%i" % @uri.port
+        path = @path.expand_path("/").to_s
+        "#<%s %s://%s%s%s%s>" % [self.class, scheme, auth, host, port, path]
+      end
+
+      private
+
+      # Connect to FTP server with the block.
+      def connect(&b)
+        3.times do
+          begin
+            ftp = Net::FTP.new
+            ftp.connect(@uri.host, @uri.port)
+            ftp.passive = true
+            ftp.login(@uri.user, @uri.password) if @uri.user
+            return yield ftp
+          rescue Errno::ECONNREFUSED
+            sleep 1
+          end
+        end
+        raise
+      end
+
+      # @api private
+      def makedirs(ftp, path, size=0)
+        path.descend do |dpath|
+          ftp.mkdir(dpath.to_s) unless rebuild(dpath).exist?
+        end
+      end
+    end
+  end
+end