deluge-api 0.1.0 → 0.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 7e9faac059b0177c915d0ca94ef0de556498441e
-  data.tar.gz: 59d61e6ae269205d9c7db3349c8749d4ecaab409
+  metadata.gz: 1bfb48ae99cefbc2e9af6c2633ab9ad0a00130b4
+  data.tar.gz: 75e047cba2ecf8382b834c36822f85188af9a21a
 SHA512:
-  metadata.gz: a3f922e08b48c0ebe7fdef0b0c0420c0546ad315382e0cf6f979f315058003610bb643ed56f1a4423e71fd8789ee77786e30f0bf0e45e61fb1dd66a2840b81ba
-  data.tar.gz: 1b18c1573281c8ac0e4052cb989d273ac190676fc7d3fab0114391d73b01842b6c82772246aa8c7c8caf8bd54b1287b29cb3149273dd927538dc6da5a0205de0
+  metadata.gz: 64ce08683db0d39a0a4c38526b932713527d57a6f93f8e17c742a04f1d2c2ebb4d8ad6b6174b041a960c4b1d307d44a9ae527516cfb3070402537b0c3fadb423
+  data.tar.gz: 3a91b8b7a1325568ac82b9798d43ea2deb972a2fae178a7bf6c25db10735943ed4485791d35d9cf963192a6fc9faae3cd6f49c502eaacf808884537a50358bd7

data/README.md

@@ -16,10 +16,13 @@ http://deluge.readthedocs.org/en/develop/core/rpc.html#remote-api
 require 'deluge'
 
 # Initialize client
-client = Deluge::Api::Client.new(host: 'localhost', port: 58846, login: 'username', password: 'password')
+client = Deluge::Api::Client.new(
+    host: 'localhost', port: 58846,
+    login: 'username', password: 'password'
+)
 
 # Start connection and authenticate
-client.start
+client.connect
 
 # Get auth level
 client.auth_level
@@ -53,6 +56,55 @@ core.get_config
 client.close
 ```
 
+## Events
+
+Receiving events is dead simple:
+
+```ruby
+client.register_event('TorrentAddedEvent') do |torrent_id|
+    puts "Torrent #{torrent_id} was added! YAY!"
+end
+
+# You can pass symbols as event name,
+# they would be converted to proper camelcase event names aka "EventNameEvent"
+client.register_event(:torrent_removed) do |torrent_id|
+    puts "Torrent #{torrent_id} was removed ;_;"
+end
+```
+
+Unfortunately there is no way to listen ALL events, due to Deluge architecture.  
+You have to register each event you need.
+
+**Keep in mind event blocks would be executed in connection thread, NOT main thread!**  
+Avoid time-consuming code!
+
+### Known events
+
+ Event Name               | Arguments               | Description
+--------------------------|-------------------------|------------------------------------------------------
+``TorrentAddedEvent``         | torrent_id              | New torrent is successfully added to the session.
+``TorrentRemovedEvent``       | torrent_id              | Torrent has been removed from the session.
+``PreTorrentRemovedEvent``    | torrent_id              | Torrent is about to be removed from the session.
+``TorrentStateChangedEvent``  | torrent_id, state       | Torrent changes state.
+``TorrentQueueChangedEvent``  |                    | The queue order has changed.
+``TorrentFolderRenamedEvent`` | torrent_id, old, new    | Folder within a torrent has been renamed.
+``TorrentFileRenamedEvent``   | torrent_id, index, name | File within a torrent has been renamed.
+``TorrentFinishedEvent``      | torrent_id              | Torrent finishes downloading.
+``TorrentResumedEvent``       | torrent_id              | Torrent resumes from a paused state.
+``TorrentFileCompletedEvent`` | torrent_id, index       | File completes.
+``NewVersionAvailableEvent``  | new_release             | More recent version of Deluge is available.
+``SessionStartedEvent``       |                    | Session has started.  This typically only happens once when the daemon is initially started.
+``SessionPausedEvent``        |                    | Session has been paused.
+``SessionResumedEvent``       |                    | Session has been resumed.
+``ConfigValueChangedEvent``   | key, value              | Config value changes in the Core.
+``PluginEnabledEvent``        | name                    | Plugin is enabled in the Core.
+``PluginDisabledEvent``       | name                    | Plugin is disabled in the Core.
+
+This list was extracted from Deluge 1.3.11 sources. Events for your version can be different.  
+There is no official documentation.
+
+Current events could be found here: http://git.deluge-torrent.org/deluge/tree/deluge/event.py
+
 ## Installation
 
 Add this line to your application's Gemfile:

data/lib/deluge/api/client.rb

@@ -15,13 +15,25 @@ module Deluge
       def connect
         @connection.start
 
-        @auth_level = @connection.call('daemon.login', @login, @password)
+        @auth_level = @connection.authenticate(@login, @password)
 
         register_methods!
 
         true
       end
 
+      def register_event(event_name, &block)
+        raise "Provide block for event" unless block
+
+        if event_name.is_a?(Symbol)
+          event_name = "#{event_name}_event"
+          # convert to CamelCase
+          event_name.gsub!(/(?:_|^)(.)/) { |match| $1.upcase }
+        end
+
+        @connection.register_event(event_name, &block)
+      end
+
       def close
         @connection.close
         @auth_level = nil
@@ -35,7 +47,7 @@ module Deluge
       private
 
       def register_methods!
-        methods = @connection.call('daemon.get_method_list')
+        methods = @connection.method_list
 
         methods.each do |method|
           *namespaces, method_name = method.split('.')

data/lib/deluge/api/connection.rb

@@ -11,8 +11,12 @@ module Deluge
   module Api
     class Connection
       class RPCError < StandardError; end
-
       class InvokeTimeoutError < StandardError; end
+      class ConnectionClosedError < StandardError; end
+
+      DAEMON_LOGIN = 'daemon.login'
+      DAEMON_METHOD_LIST = 'daemon.get_method_list'
+      DAEMON_REGISTER_EVENT = 'daemon.set_event_interest'
 
       DEFAULT_CALL_TIMEOUT = 5.0 # seconds
 
@@ -34,6 +38,7 @@ module Deluge
         @running = Concurrent::AtomicBoolean.new
 
         @messages = {}
+        @events = {}
 
         @write_mutex = Mutex.new
       end
@@ -49,6 +54,30 @@ module Deluge
 
         @main_thread = Thread.current
         @thread = Thread.new(&self.method(:read_loop))
+
+        # register present events
+        recover_events! if @events.size > 0
+
+        true
+      end
+
+      def authenticate(login, password)
+        self.call(DAEMON_LOGIN, login, password)
+      end
+
+      def method_list
+        self.call(DAEMON_METHOD_LIST)
+      end
+
+      def register_event(event_name, force = false, &block)
+        unless @events[event_name] # Register event only ONCE!
+          self.call(DAEMON_REGISTER_EVENT, [event_name]) if @connection # Let events be initialized lazily
+        end
+
+        @events[event_name] ||= []
+        @events[event_name] << block
+
+        true
       end
 
       def close
@@ -56,23 +85,19 @@ module Deluge
       end
 
       def call(method, *args)
+        raise "Not connected!" unless @connection
+
         kwargs = {}
         kwargs = args.pop if args.size == 1 && args.last.is_a?(Hash)
 
         future = Concurrent::IVar.new
 
         request_id = @request_id.increment
-        message = [[request_id, method, args, kwargs]]
-
-        raw = Zlib::Deflate.deflate Rencoder.dump(message)
+        @messages[request_id] = future
 
-        @write_mutex.synchronize do
-          @messages[request_id] = future
+        message = [[request_id, method, args, kwargs]]
 
-          if IO.select([], [@connection], nil, nil)
-            @connection.write(raw)
-          end
-        end
+        write_packet(message)
 
         result = future.value!(@call_timeout)
 
@@ -87,39 +112,90 @@ module Deluge
 
       def read_loop
         while(@running.true?)
-          next unless IO.select([@connection], nil, nil, 0.1)
-
-          raw = ""
-          begin
-            buffer = @connection.readpartial(1024)
-            raw += buffer
-          end until(buffer.size < 1024)
+          io_poll = IO.select([@connection], nil, [@connection], 0.1)
 
-          raw = Zlib::Inflate.inflate(raw)
+          next unless io_poll
 
-          parse_packets(raw).each do |packet|
-            type, response_id, value = packet
+          read_sockets, _, error_sockets = io_poll
 
-            var = @messages[response_id]
+          if @connection.eof?
+            # TODO: implement auto-recovery
+            raise ConnectionClosedError
+          end
 
-            next unless var # TODO: Handle unknown messages
+          read_sockets.each do |socket|
+            packets = read_packets(socket)
 
-            case type
-            when RPC_RESPONSE
-              var.set(value)
-            when RPC_ERROR
-              var.fail(RPCError.new(value))
-            # TODO: Add events support
-            else
-              raise "Unknown response type #{type}"
+            packets.each do |packet|
+              dispatch_packet(packet)
             end
           end
         end
-
-        @connection.close if @connection
-        @connection = nil
       rescue => e
         @main_thread.raise(e)
+      ensure
+        @connection.close if @connection
+        @connection = nil
+        @messages.clear
+      end
+
+      def dispatch_packet(packet)
+        type, response_id, value = packet
+
+        case type
+        when RPC_RESPONSE, RPC_ERROR
+          future = @messages[response_id]
+
+          return unless future # TODO: Handle unknown messages
+
+          if type == RPC_RESPONSE
+            future.set(value)
+          else
+            future.fail(RPCError.new(value))
+          end
+        when RPC_EVENT
+          handlers = @events[response_id]
+          return unless handlers # TODO: Handle unknown events
+
+          handlers.each do |block|
+            block.call(*value)
+          end
+        else
+          raise "Unknown packet type #{type.inspect}"
+        end
+      end
+
+      def write_packet(packet)
+        raw = Zlib::Deflate.deflate Rencoder.dump(packet)
+
+        @write_mutex.synchronize do
+          if IO.select([], [@connection], nil, nil)
+            @connection.write(raw)
+          end
+        end
+      end
+
+      def read_packets(socket)
+        raw = ""
+        begin
+          buffer = socket.readpartial(1024)
+          raw += buffer
+        end until(buffer.size < 1024)
+
+        raw = Zlib::Inflate.inflate(raw)
+
+        parse_packets(raw)
+      end
+
+      def recover_events!
+        present_events = @events
+        @events = {}
+
+        present_events.each do |event, handlers|
+          handlers.each do |handler|
+            self.register_event(event, &handler)
+          end
+        end
       end
 
       def create_socket

data/lib/deluge/api/version.rb

@@ -1,5 +1,5 @@
 module Deluge
   module Api
-    VERSION = "0.1.0"
+    VERSION = "0.1.1"
   end
 end

data/spec/deluge/api/client_spec.rb

@@ -5,8 +5,8 @@ describe Deluge::Api::Client do
   let(:connection) do
     double('ApiConnection').tap do |connection|
       allow(connection).to receive(:start)
-      allow(connection).to receive(:call).with('daemon.login', 'test', 'password').and_return(5)
-      allow(connection).to receive(:call).with('daemon.get_method_list').and_return(['test.api.method'])
+      allow(connection).to receive(:authenticate).with('test', 'password').and_return(5)
+      allow(connection).to receive(:method_list).and_return(['test.api.method'])
       allow(connection).to receive(:call).with('test.api.method').and_return('winning')
       allow(connection).to receive(:close)
     end
@@ -28,17 +28,13 @@ describe Deluge::Api::Client do
     end
 
     it 'authenticate' do
-      expect(connection).to have_received(:call).with('daemon.login', 'test', 'password')
+      expect(connection).to have_received(:authenticate).with('test', 'password')
     end
 
     it 'set auth_level' do
       expect(subject.auth_level).to eq(5)
     end
 
-    it 'fetch methods' do
-      expect(connection).to have_received(:call).with('daemon.get_method_list')
-    end
-
     it 'register methods' do
       expect(subject.api_methods).to include('test.api.method')
     end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: deluge-api
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.1.1
 platform: ruby
 authors:
 - Igor Yamolov
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-05-16 00:00:00.000000000 Z
+date: 2015-05-20 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: concurrent-ruby