deluge 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 621e509656351a32651a96cca7575b275f5c42ed
+  data.tar.gz: 10b04f90dcfd5b5b9b3457138a868289a284be8c
+SHA512:
+  metadata.gz: 603a6c8ac060f091897379b867b11edc52fc71477ffb2df708bad52693a3d8b9abd4abdb545a1e22101585f8b5f399e0e0c5f33dd501ab6c0e282f28388217b1
+  data.tar.gz: 1c989baf119615cf58072f27ec645f23ad22f9a57ad341ebf6742099710e95169fb5512f235d921b8aabe82d308e1dcd9e3fcda43cfd55cbd9ff59240136b998

data/Gemfile

@@ -0,0 +1,8 @@
+source 'https://rubygems.org'
+
+gem 'turn'
+gem 'shoulda'
+gem 'rake'
+gem 'rencode'
+
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+The MIT License (MIT)
+
+Copyright (c) 2014 Mikael Wikman
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+

data/README.md

@@ -0,0 +1,25 @@
+## Deluge Ruby Client
+
+This is a client library written in Ruby for communicating with Deluge daemon process. This implementation currently only supports V3 of the protocol (any version with major number 3, e.g. Deluge 3.3).
+
+It has all core and daemon RPC functions defined, and you can access any plugin exported functions through the Deluge#call method. 
+
+### Usage
+
+```ruby
+gem install deluge
+
+# defaults are 'localhost', '58846'
+d = Deluge.new '192.168.1.11', '58800'
+
+d.login 'user', 'pass'
+
+d.add_torrent_url 'http://some-evil-tracker.com/juicy.torrent'
+
+# example of the dynamic Deluge#call method
+d.call 'webui.get_config', {}
+```
+
+### Methods
+
+See _lib/deluge_ for all defined methods.

data/app.gemspec

@@ -0,0 +1,15 @@
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |gem|
+  gem.authors       = ['Mikael Wikman']
+  gem.email         = ['mikael@wikman.me']
+  gem.description   = %q{}
+  gem.summary       = %q{Ruby implementation of the Deluge RPC API}
+  gem.files         = `git ls-files`.split($\)
+  gem.homepage      = 'https://github.com/mikaelwikman/deluge-ruby'
+  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  gem.test_files    = gem.files.grep(%r{^(test|features)/})
+  gem.name          = "deluge"
+  gem.require_paths = ["lib"]
+  gem.version       = '1.0.0'
+end

data/lib/deluge.rb

@@ -0,0 +1,265 @@
+require 'deluge/protocol'
+require 'base64'
+
+class Deluge
+
+  def initialize host='localhost', port='58846', protocol=3
+    @protocol = protocol
+
+    if protocol == 3
+      @con = Protocol::V3.new(host, port)
+    else
+      raise "Unsupported protocol #{protocol}"
+    end
+  end
+
+  def call *args
+    @con.call *args
+  end
+
+  def login username, password
+    @con.call 'daemon.login', username, password
+  end
+
+  def shutdown args, kwargs={}
+    args = [args] unless args.is_a?(Array)
+    @con.call 'daemon.shutdown', args, kwargs
+  end
+
+  def info
+    @con.call 'daemon.info'
+  end
+
+  def get_method_list
+    @con.call 'daemon.get_method_list'
+  end
+
+  # Available options:
+  # max_connections max_upload_slots max_upload_speed max_download_speed prioritize_first_last_pieces file_priorities compact_allocation download_location auto_managed stop_at_ratio stop_ratio remove_at_ratio move_completed move_completed_path add_paused
+  def add_torrent_file filename, filedump, options={}
+    filedump_enc = Base64.encode64(filedump)
+    @con.call 'core.add_torrent_file', filename, filedump_enc, options, {}
+  end
+
+  # Available options:
+  # max_connections max_upload_slots max_upload_speed max_download_speed prioritize_first_last_pieces file_priorities compact_allocation download_location auto_managed stop_at_ratio stop_ratio remove_at_ratio move_completed move_completed_path add_paused
+  def add_torrent_url url, options={}
+    @con.call 'core.add_torrent_url', url, options, {}
+  end
+
+  # Available options:
+  # max_connections max_upload_slots max_upload_speed max_download_speed prioritize_first_last_pieces file_priorities compact_allocation download_location auto_managed stop_at_ratio stop_ratio remove_at_ratio move_completed move_completed_path add_paused
+  def add_torrent_magnet uri, options={}
+    @con.call 'core.add_torrent_magnet', uri, options, {}
+  end
+
+  def remove_torrent torrent_id, remove_data: false
+    @con.call 'core.remove_torrent', torrent_id, remove_data
+  end
+
+  
+  # Gets the session status values for 'keys', these keys are taking
+  # from libtorrent's session status.
+
+  # See: http://www.rasterbar.com/products/libtorrent/manual.html#status
+  def get_session_status keys
+    @con.call 'core.get_session_status', keys, {}
+  end
+
+  def get_cache_status
+    @con.call 'core.get_cache_status', {}
+  end
+
+  def force_reannounce *torrent_ids
+    @con.call 'core.force_reannounce', torrent_ids, {}
+  end
+
+  def pause_torrent *torrent_ids
+    @con.call 'core.pause_torrent', torrent_ids, {}
+  end
+
+  def connect_peer torrent_id, ip, port
+    @con.call 'core.connect_peer', torrent_id, ip, port, {}
+  end
+
+  def move_storage *torrent_ids, dest
+    @con.call 'core.move_storage', torrent_ids, dest, {}
+  end
+
+  def pause_all_torrents
+    @con.call 'core.pause_all_torrents', {}
+  end
+
+  def resume_all_torrents
+    @con.call 'core.resume_all_torrents', {}
+  end
+
+  def resume_torrent *torrent_ids
+    @con.call 'core.resume_torrent', torrent_ids, {}
+  end
+
+  def get_torrent_status torrent_id, keys, diff=false
+    @con.call 'core.get_torrent_status', torrent_id, keys, diff, {}
+  end
+
+  def get_filter_tree show_zero_hits=true, hide_cat=nil
+    @con.call 'core.get_filter_tree', show_zero_hits, hide_cat, {}
+  end
+
+  def get_session_state
+    @con.call 'core.get_session_state', {}
+  end
+
+  def get_config
+    @con.call 'core.get_config', {}
+  end
+
+  def get_config_values *keys
+    @con.call 'core.get_config_values', keys, {}
+  end
+
+  def set_config config
+    @con.call 'core.set_config', config, {}
+  end
+
+  def get_listen_port
+    @con.call 'core.get_listen_port', {}
+  end
+
+  def get_num_connections
+    @con.call 'core.get_num_connections', {}
+  end
+
+  def get_available_plugins
+    @con.call 'core.get_available_plugins', {}
+  end
+
+  def get_enabled_plugins
+    @con.call 'core.get_enabled_plugins', {}
+  end
+
+  def enable_plugin plugin
+    @con.call 'core.enable_plugin', plugin, {}
+  end
+
+  def disable_plugin plugin
+    @con.call 'core.disable_plugin', plugin, {}
+  end
+
+  def force_recheck *torrent_ids
+    @con.call 'core.force_recheck', torrent_ids, {}
+  end
+
+  def set_torrent_options torrent_ids, options={}
+    torrent_ids = [torrent_ids] unless torrent_ids.kind_of?(Array)
+    @con.call 'core.set_torrent_options',torrent_ids, options, {}
+  end
+
+  def set_torrent_trackers torrent_id, *trackers
+    @con.call 'core.set_torrent_trackers', torrent_id, trackers, {}
+  end
+
+  def set_torrent_max_connections torrent_id, value
+    @con.call 'core.set_torrent_max_connections', torrent_id, value, {}
+  end
+
+  def set_torrent_max_upload_slots torrent_id, value
+    @con.call 'core.set_torrent_max_upload_stats', torrent_id, value, {}
+  end
+
+  def set_torrent_max_upload_speed torrent_id, value
+    @con.call 'core.set_torrent_max_upload_speed', torrent_id, value, {}
+  end
+  
+  def set_torrent_max_download_speed torrent_id, value
+    @con.call 'core.set_torrent_max_download_speed', torrent_id, value, {}
+  end
+
+  def set_torrent_file_priorities torrent_id, priorities
+    @con.call 'core.set_torrent_file_priorities', torrent_id, priorities, {}
+  end
+
+  def set_torrent_prioritize_first_last torrent_id, value
+    @con.call 'core.set_torrent_prioritize_first_last', torrent_id, value, {}
+  end
+
+  def set_torrent_auto_managed torrent_id, value
+    @con.call 'core.set_torrent_auto_managed', torrent_id, value, {}
+  end
+
+  def set_torrent_stop_at_ratio torrent_id, value
+    @con.call 'core.set_torrent_stop_at_ratio', torrent_id, value, {}
+  end
+
+  def set_torrent_stop_ratio torrent_id, value
+    @con.call 'core.set_torrent_stop_ratio', torrent_id, value, {}
+  end
+
+  def set_torrent_remove_at_ratio torrent_id, value
+    @con.call 'core.set_torrent_remove_at_ratio', torrent_id, value, {}
+  end
+
+  def set_torrent_move_completed torrent_id, value
+    @con.call 'core.set_torrent_move_completed', torrent_id, value, {}
+  end
+
+  def set_torrent_move_completed_path torrent_id, value
+    @con.call 'core.set_torrent_move_completed_path', torrent_id, value, {}
+  end
+
+  def get_path_size path
+    @con.call 'core.get_path_size', path, {}
+  end
+
+  def create_torrent path, tracker, piece_length, comment, target, webseeds, privat, created_by, trackers, add_to_session
+    @con.call 'core.create_torrent', path, tracker, piece_length, comment, target, webseeds, privat, created_by, trackers, add_to_session, {}
+  end
+
+  def upload_plugin filename, filedump
+    @con.call 'core.upload_plugin', filename, filedump, {}
+  end
+
+  def rescan_plugins
+    @con.call 'core.rescan_plugins', {}
+  end
+
+  def rename_files torrent_id, filenames
+    @con.call 'core.rename_files', torrent_id, filenames, {}
+  end
+
+  def rename_folder torrent_id, folder, new_folder
+    @con.call 'core.rename_folder', torrent_id, folder, new_folder, {}
+  end
+
+  def queue_top *torrent_ids
+    @con.call 'core.queue_top', torrent_ids, {}
+  end
+
+  def queue_up *torrent_ids
+    @con.call 'core.queue_up', torrent_ids, {}
+  end
+
+  def queue_down *torrent_ids
+    @con.call 'core.queue_down', torrent_ids, {}
+  end
+
+  def queue_bottom *torrent_ids
+    @con.call 'core.queue_bottom', torrent_ids, {}
+  end
+
+  def glob path
+    @con.call 'core.glob', path, {}
+  end
+
+  def test_listen_port
+    @con.call 'core.test_listen_port', {}
+  end
+
+  def get_free_space path=nil
+    @con.call 'core.get_free_space', path, {}
+  end
+
+  def get_libtorrent_version
+    @con.call 'core.get_libtorrent_version'
+  end
+end

data/lib/deluge/protocol.rb

@@ -0,0 +1,3 @@
+class Protocol
+  require 'deluge/protocol/v3'
+end

data/lib/deluge/protocol/v3.rb

@@ -0,0 +1,166 @@
+require 'rencode'
+require 'zlib'
+require 'socket'
+require 'thread'
+require 'openssl'
+
+class Deluge
+  class Protocol::V3
+    # Data messages are transfered using very a simple protocol.
+    # Data messages are transfered with a header containing
+    # the length of the data to be transfered (payload).
+
+    def initialize host, port
+      @buffer = []
+      @message_length = 0
+      @messages = []
+      @mutex = Mutex.new
+      @host = host
+      @port = port
+      @counter = 0
+
+      connection = TCPSocket.new(host, port)
+      ctx = OpenSSL::SSL::SSLContext.new
+      ctx.set_params(verify_mode: OpenSSL::SSL::VERIFY_NONE)
+      ctx.ssl_version = :SSLv3
+
+      @con = OpenSSL::SSL::SSLSocket.new(connection, ctx)
+      @con.connect
+
+      Thread.new do
+        loop do
+          begin
+            data = @con.readpartial(1024)
+
+            if data.length == 0
+              puts "We lost the connection!"
+              break
+            end
+
+            handle_new_data(data.bytes)
+
+          rescue Exception => e
+            puts e.message
+            p e.backtrace
+            sleep 1
+          end
+        end
+      end
+    end
+
+    def call method, *args
+      kwargs = if args.last.is_a?(Hash)
+                 args.delete_at(-1)
+               else
+                 {}
+               end
+
+      request_id = @counter+=1
+
+      send([request_id, method, args, kwargs])
+
+      response = nil
+
+      sleep 0.01 until response = @messages.find{|m| m[1] == request_id}
+      @messages.delete(response)
+
+      if response[0] == 1
+        return response[2]
+      else
+        raise response.inspect
+      end
+    end
+
+    # Transfer the data.
+
+    # The data will be serialized and compressed before being sent.
+    # First a header is sent - containing the length of the compressed payload
+    # to come as a signed integer. After the header, the payload is transfered.
+    # :param msg: data to be transfered in a data structure serializable by rencode.
+    def send msg
+      rencoded = REncode.dump([msg]).pack('C*')
+      #rencoded = [193, 196, 1, 139, 100, 97, 101, 109, 111, 110, 46, 105, 110, 102, 111, 192, 102].pack('C*')
+      compressed = Zlib::Deflate.deflate(rencoded)
+      raw = compressed.bytes
+
+      # all commented out stuff is for version 4, which we do not yet support
+      # Store length as a signed integer (using 4 bytes), network byte order
+  #    header = [raw.length].pack('N').bytes
+
+      #every message begins with an ASCII 'D'
+  #    header.insert(0, 'D'.ord)
+
+  #    header_str = header.pack('C*')
+      message_str = raw.pack('C*')
+
+  #    puts "Writing header:"
+  #    p header_str.bytes
+  #    puts
+  #    puts "Writing message:"
+  #    p rencoded.bytes
+  #    puts
+
+
+  #    @con.write(header_str)
+      @con.write(message_str)
+      @con.flush
+
+      nil
+    end
+
+    def read
+      @mutex.synchronize do
+        @messages.shift
+      end
+    end
+
+    def count
+      @mutex.synchronize do
+        @messages.count
+      end
+    end
+
+    private
+
+    def handle_new_data data, &block
+      # commented code is for version 4, not yet supported
+  #    @buffer.concat(data)
+  #
+  #    while @buffer.length >= 5 # 'D' + 4 byte integer
+  #      if @message_length == 0
+  #        handle_new_message
+  #      end
+  #
+  #      if @buffer.length >= @message_length
+  #        message = @buffer.shift(@message_length)
+  #        @message_length = 0
+  #
+          message = data
+          handle_complete_message(message)
+  #      end
+  #    end
+    end
+
+  #  def handle_new_message
+  #    header = @buffer.shift(5)
+  #    verify_d = header.shift(1)
+  #
+  #    unless verify_d == 'D'.ord
+  #      raise "Invalid header format, First byte is #{verify_d}"
+  #    else
+  #      @message_length = header.pack('C*').unpack('N')[0]
+  #      raise "Message length is negative: #{@message_length}" if @message_length < 0
+  #    end
+  #  end
+
+    def handle_complete_message data
+      decompressed = Zlib::Inflate.inflate(data.pack('C*'))
+      derencoded = REncode.parse(decompressed)
+
+      @mutex.synchronize do
+        @messages << derencoded
+      end
+    end
+
+  end
+end

data/test/test_helper.rb

@@ -0,0 +1,10 @@
+require 'bundler/setup'
+require 'test/unit'
+require 'turn/autorun'
+require 'shoulda'
+
+$LOAD_PATH << 'lib'
+
+class TestCase < Test::Unit::TestCase
+end
+

metadata

@@ -0,0 +1,52 @@
+--- !ruby/object:Gem::Specification
+name: deluge
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- Mikael Wikman
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-05-13 00:00:00.000000000 Z
+dependencies: []
+description: ''
+email:
+- mikael@wikman.me
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- Gemfile
+- LICENSE.txt
+- README.md
+- app.gemspec
+- lib/deluge.rb
+- lib/deluge/protocol.rb
+- lib/deluge/protocol/v3.rb
+- test/test_helper.rb
+homepage: https://github.com/mikaelwikman/deluge-ruby
+licenses: []
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.2.2
+signing_key: 
+specification_version: 4
+summary: Ruby implementation of the Deluge RPC API
+test_files:
+- test/test_helper.rb