pione 0.1.0

data/lib/pione/relay/trampoline.rb

@@ -0,0 +1,22 @@
+module Pione
+  module Relay
+    class Trampoline
+      def initialize(uri, config)
+        @obj = DRb::DRbObject.new_with_uri(uri)
+        @protocol = TransmitterSocket.open_server(uri, config)
+      end
+
+      undef :to_s
+
+      def method_missing(msg_id, *arg, &b)
+        req_id = @protocol.send_request(@obj, msg_id, arg, b)
+        @protocol.reader_thread
+        succ, result = DRb.waiter_table.take(req_id, msg_id, arg)
+        unless succ
+          raise result
+        end
+        return result
+      end
+    end
+  end
+end

data/lib/pione/relay/transmitter-socket.rb

@@ -0,0 +1,167 @@
+module Pione
+  module Relay
+    # TransmitterSocket is a connection layer from PIONE relay to PIONE client.
+    class TransmitterSocket < DRb::DRbTCPSocket
+      class TransmitterSocketError < Exception; end
+
+      @@receiver_socket = {}
+      @@proxy_socket = {}
+
+      def self.receiver_socket
+        @@receiver_socket
+      end
+
+      def self.proxy_socket
+        @@proxy_socket
+      end
+
+      # Parses special URI for reverse scheme.
+      def self.parse_uri(uri)
+        if uri =~ /^transmitter:\/\/([\w-]+)(\?(.*))?$/
+          transmitter_id = $1
+          option = $3
+          return transmitter_id, option
+        else
+          raise DRb::DRbBadScheme.new(uri) unless uri =~ /^transmitter:/
+          raise DRb::DRbBadURI.new('can\'t parse uri:' + uri)
+        end
+      end
+
+      # Creates a fake connection from proxy to relay transmitter.
+      # @api private
+      def self.open(uri, config)
+        # reverse socket needs URI always
+        raise ArgumentError.new("You should specify transmitter URI.") unless uri
+
+        # get transmitter_id
+        transmitter_id, _ = parse_uri(uri)
+        transmitter_id.untaint
+
+        # get proxy side socket
+        soc = @@proxy_socket[transmitter_id]
+        unless soc
+          msg = "No receiver side socket for %s." % transmitter_id
+          raise TransmitterSocketError.new(msg)
+        end
+        proxy_socket = TCPSocket.new("localhost", soc.addr[1])
+
+        # create instance with proxy socket
+        self.new(uri, nil, proxy_socket, config)
+      end
+
+      # Opens a fake socket.
+      def self.open_server(uri, config)
+        # the method needs URI explicitly
+        raise ArgumentError.new("You should specify transmitter URI.") unless uri
+
+        # get transmitter_id
+        transmitter_id, _ = parse_uri(uri)
+        transmitter_id.untaint
+
+        # get receiver side socket
+        receiver_socket = @@receiver_socket[transmitter_id]
+        unless receiver_socket
+          msg = "No receiver side sockets for %s." % transmitter_id
+          raise TransmitterSocketError.new(msg)
+        end
+
+        # get proxy side socket
+        proxy_socket = @@proxy_socket[transmitter_id]
+        unless proxy_socket
+          msg = "No proxy side sockets for %s." % transmitter_id
+          raise TransmitterSocketError.new(msg)
+        end
+
+        # create instance with receiver and proxy sockets
+        self.new(uri, receiver_socket, proxy_socket, config)
+      end
+
+      def self.uri_option(uri, config)
+        transmitter_id, option = parse_uri(uri)
+        return "transmitter://%s" % transmitter_id, option
+      end
+
+      def initialize(uri, receiver_socket, proxy_socket, config)
+        @uri = uri
+        @receiver_socket = receiver_socket
+        @proxy_socket = proxy_socket
+        @config = config
+        @acl = config[:tcp_acl]
+        @receiver_msg = DRb::DRbMessage.new(config)
+        @proxy_msg = DRb::DRbMessage.new(config)
+        set_sockopt(@receiver_socket) if @receiver_socket
+        set_sockopt(@proxy_socket) if @proxy_socket
+      end
+
+      # Sends a request from transmitter to receiver.
+      # @api private
+      def send_request(ref, msg_id, arg, b)
+        if @receiver_socket
+          ref = DRbObject.new_with_uri("receiver://%s:%s" % ["localhost", Global.relay_port])
+          #p ref.__drburi if ref.kind_of?(DRbObject)
+          #p msg_id
+          #p arg
+          @receiver_msg.send_request(@receiver_socket, ref, msg_id, arg, b)
+        else
+          @proxy_msg.send_request(@proxy_socket, ref, msg_id, arg, b)
+        end
+      end
+
+      # Receives a request from proxy to transmitter.
+      # @api private
+      def recv_request
+        @proxy_msg.recv_request(@proxy_socket)
+      end
+
+      # Sends a reply from transmitter to proxy.
+      # @api private
+      def send_reply(req_id, succ, result)
+        @proxy_msg.send_reply(req_id, @proxy_socket, succ, result)
+      end
+
+      # Receives a reply from receiver to transmitter.
+      # @api private
+      def recv_reply
+        if @receiver_socket
+          @receiver_msg.recv_reply(@receiver_socket)
+        else
+          @proxy_msg.recv_reply(@proxy_socket)
+        end
+      end
+
+      # Closes proxy side socket.
+      def close
+        @proxy_socket.close
+        @proxy_socket = nil
+      end
+
+      # Opens fake connection from proxy to transmitter.
+      # Just returns self.
+      def accept
+        while true
+          soc = @proxy_socket.accept
+          break if (@acl ? @acl.allow_socket?(soc) : true)
+          soc.close
+        end
+
+        if Global.show_communication
+          puts "proxy connects to transmitter"
+        end
+
+        # create instance
+        self.class.new(uri, nil, soc, @config)
+      rescue => e
+        soc.close
+        if Global.show_communication
+          puts "closed transmitter's proxy side socket"
+          puts "%s: %s" % [e.class, e.message]
+          caller.each {|line| puts "    %s" % line}
+        end
+        retry
+      end
+    end
+
+    # install the protocol
+    DRb::DRbProtocol.add_protocol(TransmitterSocket)
+  end
+end

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

@@ -0,0 +1,92 @@
+module Pione
+  # Resource is a module for data resources.
+  module Resource
+    # ResourceError is raised when any resource errors happen.
+    class ResourceError < Exception
+      def initialize(uri)
+        @uri = uri
+      end
+    end
+
+    class NotFound < ResourceError; end
+
+    # @api private
+    @@schemes = {}
+
+    # Returns the resource object corresponding to the uri.
+    # @return [BasicResource]
+    #   resouce object
+    def self.[](uri)
+      uri = uri.kind_of?(::URI::Generic) ? uri : ::URI.parse(uri)
+      @@schemes[uri.scheme].new(uri)
+    end
+
+    # BasicResource is an interface class for all resouce classes.
+    class BasicResource
+      attr_reader :uri
+      attr_reader :path
+
+      # Creates a data resource on URI.
+      # @param [String] data
+      #   data content
+      # @return[void]
+      def create(data)
+        raise NotImplementedError
+      end
+
+      # Reads a resource data from URI.
+      # @return [String]
+      #   data content
+      def read
+        raise NotImplementedError
+      end
+
+      # Updates a resource data on URI.
+      # @param [String] data
+      #   new data content
+      # @return [void]
+      def update(data)
+        raise NotImplementedError
+      end
+
+      # Deletes a resource data on URI.
+      # @return [void]
+      def delete
+        raise NotImplementedError
+      end
+
+      # Returns mtime of the resource.
+      # @return [Time]
+      #   mtime
+      def mtime
+        raise NotImplementedError
+      end
+
+      # Returns entries of the resource path.
+      # @return [Array<Resource>]
+      #   resource entries of the resource path
+      def entries
+        raise NotImplementedError
+      end
+
+      # Returns the basename of resource.
+      # @return [String]
+      #   basename
+      def basename
+        raise NotImplementedError
+      end
+
+      def exist?
+        raise NotImplementedError
+      end
+
+      def link_to(dist)
+        raise NotImplementedError
+      end
+
+      def link_from(dist)
+        raise NotImplementedError
+      end
+    end
+  end
+end

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

@@ -0,0 +1,106 @@
+module Pione
+  module Resource
+    class Dropbox < BasicResource
+      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
+
+      def self.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
+
+      def self.ready?
+        @session.authorized?
+      end
+
+      def self.set_session(session)
+        @session = session
+      end
+
+      def self.session
+        @session
+      end
+
+      def initialize(uri)
+        @uri = uri.kind_of?(URI::Generic) ? uri : URI.parse(uri)
+        raise ArgumentError unless @uri.kind_of?(Pione::URIScheme::DropboxScheme)
+        @path = uri.path
+        @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.delete_file(@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|
+          Resource["dropbox:%s" % entry["path"]]
+        end
+      end
+
+      def basename
+        Pathname.new(@path).basename.to_s
+      end
+
+      def exist?
+        metadata = @client.metadata(@path)
+        return not(metadata["is_deleted"])
+      rescue DropboxError
+        return false
+      end
+
+      def link_to(dist)
+        File.open(dist, "w") do |out|
+          out.write read
+        end
+      end
+
+      def link_from(other)
+        update(File.read(other))
+      end
+
+      def shift_from(other)
+        @client.file_move(other.path, @path)
+      end
+    end
+
+    @@schemes['dropbox'] = Dropbox
+  end
+end

data/lib/pione/resource/ftp.rb

@@ -0,0 +1,84 @@
+module Pione
+  module Resource
+    # FTP represents resources on FTP server.
+    class FTP < BasicResource
+      # Creates a resouce.
+      # @param [String, ::URI] uri
+      #   resource URI
+      def initialize(uri)
+        @uri = uri.kind_of?(::URI::Generic) ? uri : ::URI.parse(uri)
+        raise ArgumentError unless @uri.kind_of?(::URI::FTP)
+        @path = uri.path
+      end
+
+      # (see BasicResource#create)
+      def create(data)
+        Net::FTP.open(@uri.host, @uri.user, @uri.password) do |ftp|
+          pathes = @path.split('/')
+          makedirs(ftp, pathes)
+          t = Tempfile.open("aaa")
+          t.write(data)
+          t.close(false)
+          ftp.put(t.path, @path)
+        end
+      end
+
+      # (see BasicResource#read)
+      def read
+        begin
+          tempfile = Tempfile.new("test")
+          Net::FTP.open(@uri.host, @uri.user, @uri.password) do |ftp|
+            ftp.get(@path, tempfile.path)
+          end
+          File.read(tempfile.path)
+        rescue Net::FTPPermErrro
+          raise NotFound.new(@uri)
+        end
+      end
+
+      # (see BasicResource#update)
+      def update(data)
+        Net::FTP.open(@uri.host, @uri.user, @uri.password) do |ftp|
+          begin
+            ftp.dir(File.dirname(@path))
+            t = Tempfile.open("aaa")
+            t.write(data)
+            t.close(false)
+            ftp.put(t.path, @path)
+          rescue Net::FTPPermErrro
+            raise NotFound.new(@uri)
+          end
+        end
+      end
+
+      # (see BasicResource#delete)
+      def delete
+        Net::FTP.open(@uri.host, @uri.user, @uri.password) do |ftp|
+          ftp.delete(@path)
+        end
+      end
+
+      # (see BasicResource#copy_to)
+      def copy_to(dist)
+        FileUtil.symlink(@path, dist)
+      end
+
+      private
+
+      # @api private
+      def makedirs(ftp, path, size=0)
+        unless path.size == size + 1
+          pa = File.join(*path[0..size])
+          begin
+            ftp.mkdir(pa)
+          rescue Net::FTPPermError
+          ensure
+            makedirs(ftp, path, size+1)
+          end
+        end
+      end
+    end
+
+    @@schemes['ftp'] = FTP
+  end
+end