transmission-rpc-ruby-ext 0.1.0

data/lib/transmission/fields/torrent_get.rb

@@ -0,0 +1,76 @@
+module Transmission
+  class Fields
+    class TorrentGet < Transmission::Fields
+      ATTRIBUTES = [
+        { field: 'id' },
+        { field: 'activityDate' },
+        { field: 'addedDate' },
+        { field: 'bandwidthPriority' },
+        { field: 'comment' },
+        { field: 'corruptEver' },
+        { field: 'creator' },
+        { field: 'dateCreated' },
+        { field: 'desiredAvailable' },
+        { field: 'doneDate' },
+        { field: 'downloadDir' },
+        { field: 'downloadedEver' },
+        { field: 'downloadLimit' },
+        { field: 'downloadLimited' },
+        { field: 'error' },
+        { field: 'errorString' },
+        { field: 'eta' },
+        { field: 'etaIdle' },
+        { field: 'files' },
+        { field: 'fileStats' },
+        { field: 'hashString' },
+        { field: 'haveUnchecked' },
+        { field: 'haveValid' },
+        { field: 'honorsSessionLimits' },
+        { field: 'isFinished' },
+        { field: 'isPrivate' },
+        { field: 'isStalled' },
+        { field: 'leftUntilDone' },
+        { field: 'magnetLink' },
+        { field: 'manualAnnounceTime' },
+        { field: 'maxConnectedPeers' },
+        { field: 'metadataPercentComplete' },
+        { field: 'name' },
+        { field: 'peer-limit' },
+        { field: 'peers' },
+        { field: 'peersConnected' },
+        { field: 'peersFrom' },
+        { field: 'peersGettingFromUs' },
+        { field: 'peersSendingToUs' },
+        { field: 'percentDone' },
+        { field: 'pieces' },
+        { field: 'pieceCount' },
+        { field: 'pieceSize' },
+        { field: 'priorities' },
+        { field: 'queuePosition' },
+        { field: 'rateDownload' },
+        { field: 'rateUpload' },
+        { field: 'recheckProgress' },
+        { field: 'secondsDownloading' },
+        { field: 'secondsSeeding' },
+        { field: 'seedIdleLimit' },
+        { field: 'seedIdleMode' },
+        { field: 'seedRatioLimit' },
+        { field: 'seedRatioMode' },
+        { field: 'sizeWhenDone' },
+        { field: 'startDate' },
+        { field: 'status' },
+        { field: 'trackers' },
+        { field: 'trackerStats' },
+        { field: 'totalSize' },
+        { field: 'torrentFile' },
+        { field: 'uploadedEver' },
+        { field: 'uploadLimit' },
+        { field: 'uploadLimited' },
+        { field: 'uploadRatio' },
+        { field: 'wanted' },
+        { field: 'webseeds' },
+        { field: 'webseedsSendingToUs' }
+      ].freeze
+    end
+  end
+end

data/lib/transmission/model.rb

@@ -0,0 +1,8 @@
+require_relative 'model/torrent'
+require_relative 'model/session'
+require_relative 'model/session_stats'
+
+module Transmission
+  module Model
+  end
+end

data/lib/transmission/model/session.rb

@@ -0,0 +1,48 @@
+module Transmission
+  module Model
+    class Session
+      class SessionError < StandardError; end
+
+      attr_accessor :attributes, :connector
+
+      def initialize(session_object, connector)
+        @attributes = session_object
+        @connector = connector
+      end
+
+      def save!
+        filtered = Transmission::Arguments::SessionSet.filter @attributes
+        connector.set_session filtered
+      end
+
+      def to_json
+        @attributes
+      end
+
+      def method_missing(symbol, *args)
+        string = symbol.to_s
+        if string[-1] == '='
+          string = string[0..-2]
+          key = Transmission::Arguments::SessionSet.real_key string
+          return @attributes[key] = args.first unless key.nil?
+        else
+          key = Transmission::Fields::SessionGet.real_key string
+          return @attributes[key] unless key.nil?
+        end
+        super
+      end
+
+      class << self
+        def get(options = {})
+          rpc = options[:connector] || connector
+          body = rpc.get_session options[:fields]
+          Session.new body, rpc
+        end
+
+        def connector
+          Transmission::Config.get_connector
+        end
+      end
+    end
+  end
+end

data/lib/transmission/model/session_stats.rb

@@ -0,0 +1,28 @@
+module Transmission
+  module Model
+    class SessionStats
+      attr_accessor :attributes, :connector
+
+      def initialize(session_object, connector)
+        @attributes = session_object
+        @connector = connector
+      end
+
+      def to_json
+        @attributes
+      end
+
+      class << self
+        def get(options = {})
+          rpc = options[:connector] || connector
+          body = rpc.get_session_stats options[:fields]
+          SessionStats.new body, rpc
+        end
+
+        def connector
+          Transmission::Config.get_connector
+        end
+      end
+    end
+  end
+end

data/lib/transmission/model/torrent.rb

@@ -0,0 +1,152 @@
+module Transmission
+  module Model
+    class Torrent
+      class TorrentError < StandardError; end
+      class TorrentNotFoundError < StandardError; end
+      class MissingAttributesError < StandardError; end
+      class DuplicateTorrentError < StandardError; end
+
+      attr_accessor :attributes, :deleted, :connector, :torrents, :ids
+
+      def initialize(torrent_object, connector)
+        if torrent_object.is_a? Array
+          is_single = torrent_object.size == 1
+          @attributes = is_single ? torrent_object.first : {}
+          @ids = is_single ? [@attributes['id'].to_i] : []
+          @torrents = torrent_object.inject([]) do |torrents, torrent|
+            @ids << torrent['id'].to_i
+            torrents << Torrent.new([torrent], connector)
+          end unless is_single
+        end
+        @connector = connector
+      end
+
+      def delete!(remove_local_data = false)
+        connector.remove_torrent @ids, remove_local_data
+        @deleted = true
+      end
+
+      def save!
+        filtered = Transmission::Arguments::TorrentSet.filter @attributes
+        connector.set_torrent @ids, filtered
+      end
+
+      def move_up!
+        connector.move_up_torrent @ids
+      end
+
+      def move_down!
+        connector.move_down_torrent @ids
+      end
+
+      def move_top!
+        connector.move_top_torrent @ids
+      end
+
+      def move_bottom!
+        connector.move_bottom_torrent @ids
+      end
+
+      def start!
+        connector.start_torrent @ids
+      end
+
+      def start_now!
+        connector.start_torrent_now @ids
+      end
+
+      def stop!
+        connector.stop_torrent @ids
+      end
+
+      def verify!
+        connector.verify_torrent @ids
+      end
+
+      def re_announce!
+        connector.re_announce_torrent @ids
+      end
+
+      def set_location(new_location, move = false)
+        connector.torrent_set_location @ids,  location: new_location, move: move
+      end
+
+      def is_multi?
+        @ids.size > 1
+      end
+
+      # Note: this is overidden by extensions.
+      # def finished?
+      #   percent_done == 1
+      # end
+
+      def reload!
+        torrents = Torrent.find @ids, connector: @connector
+        @ids = torrents.ids
+        @attributes = torrents.attributes
+        @torrents = torrents.torrents
+        self
+      end
+
+      def to_json
+        if is_multi?
+          @torrents.inject([]) do |torrents, torrent|
+            torrents << torrent.to_json
+          end
+        else
+          @attributes
+        end
+      end
+
+      def method_missing(symbol, *args)
+        string = symbol.to_s
+        if string[-1] == '='
+          string = string[0..-2]
+          key = Transmission::Arguments::TorrentSet.real_key string
+          return @attributes[key] = args.first unless key.nil?
+        else
+          key = Transmission::Fields::TorrentGet.real_key string
+          return @attributes[key] unless key.nil?
+        end
+        super
+      end
+
+      class << self
+        def all(options = {})
+          rpc = options[:connector] || connector
+          body = rpc.get_torrent nil, options[:fields]
+          Torrent.new body['torrents'], rpc
+        end
+
+        def find(id, options = {})
+          rpc = options[:connector] || connector
+          ids = id.is_a?(Array) ? id : [id]
+          body = rpc.get_torrent ids, options[:fields]
+          raise TorrentNotFoundError if body['torrents'].size.zero?
+          Torrent.new body['torrents'], rpc
+        end
+
+        def add(options = {})
+          rpc = options[:connector] || connector
+          body = rpc.add_torrent options[:arguments]
+          raise DuplicateTorrentError if body['torrent-duplicate']
+          find body['torrent-added']['id'], options
+        end
+
+        def start_all!(options = {})
+          rpc = options[:connector] || connector
+          rpc.start_torrent nil
+        end
+
+        def stop_all!(options = {})
+          rpc = options[:connector] || connector
+          rpc.stop_torrent nil
+        end
+
+        def connector
+          Transmission::Config.get_connector
+        end
+      end
+    end
+  end
+end

data/lib/transmission/rpc.rb

@@ -0,0 +1,116 @@
+require_relative 'rpc/connector'
+
+module Transmission
+  class RPC
+    attr_accessor :session, :connector
+
+    def initialize(options = {})
+      @connector = Connector.new options
+    end
+
+    def get_session(fields = nil)
+      fields = Transmission::Fields::SessionGet.new(fields)
+      arguments = { fields: fields.to_fields }
+      @connector.post method: 'session-get', arguments: arguments
+    end
+
+    def get_session_stats(fields = nil)
+      fields = Transmission::Fields::SessionStats.new(fields)
+      arguments = { fields: fields.to_fields }
+      @connector.post method: 'session-stats', arguments: arguments
+    end
+
+    def close_session
+      @connector.post method: 'session-close'
+    end
+
+    def test_port
+      @connector.post method: 'port-test'
+    end
+
+    def blocklist
+      @connector.post method: 'blocklist-update'
+    end
+
+    def free_space
+      @connector.post method: 'free-space'
+    end
+
+    def get_torrent(ids, fields = nil)
+      fields = Transmission::Fields::TorrentGet.new(fields)
+      arguments = { fields: fields.to_fields }
+      arguments[:ids] = ids if ids.is_a? Array
+      @connector.post method: 'torrent-get', arguments: arguments
+    end
+
+    def set_torrent(ids, arguments)
+      arguments[:ids] = ids
+      arguments = Transmission::Arguments::TorrentSet.new(arguments)
+      @connector.post method: 'torrent-set', arguments: arguments.to_arguments
+    end
+
+    def set_session(arguments)
+      arguments = Transmission::Arguments::SessionSet.new(arguments)
+      @connector.post method: 'session-set', arguments: arguments.to_arguments
+    end
+
+    def add_torrent(arguments)
+      arguments = Transmission::Arguments::TorrentAdd.new(arguments)
+      @connector.post method: 'torrent-add', arguments: arguments.to_arguments
+    end
+
+    def torrent_set_location(ids, arguments)
+      arguments[:ids] = ids
+      arguments = Transmission::Arguments::LocationSet.new(arguments)
+      @connector.post method: 'torrent-set-location', arguments: arguments.to_arguments
+    end
+
+    def remove_torrent(ids, delete_local_data = false)
+      @connector.post method: 'torrent-remove', arguments: { ids: ids, 'delete-local-data' => delete_local_data }
+    end
+
+    def start_torrent(ids)
+      @connector.post method: 'torrent-start', arguments: id_arguments(ids)
+    end
+
+    def start_torrent_now(ids)
+      @connector.post method: 'torrent-start-now', arguments: id_arguments(ids)
+    end
+
+    def stop_torrent(ids)
+      @connector.post method: 'torrent-stop', arguments: id_arguments(ids)
+    end
+
+    def verify_torrent(ids)
+      @connector.post method: 'torrent-verify', arguments: id_arguments(ids)
+    end
+
+    def re_announce_torrent(ids)
+      @connector.post method: 'torrent-reannounce', arguments: id_arguments(ids)
+    end
+
+    def move_up_torrent(ids)
+      @connector.post method: 'queue-move-up', arguments: id_arguments(ids)
+    end
+
+    def move_down_torrent(ids)
+      @connector.post method: 'queue-move-down', arguments: id_arguments(ids)
+    end
+
+    def move_top_torrent(ids)
+      @connector.post method: 'queue-move-top', arguments: id_arguments(ids)
+    end
+
+    def move_bottom_torrent(ids)
+      @connector.post method: 'queue-move-bottom', arguments: id_arguments(ids)
+    end
+
+    private
+
+    def id_arguments(ids)
+      arguments = {}
+      arguments[:ids] = ids if ids.is_a? Array
+      arguments
+    end
+  end
+end

data/lib/transmission/rpc/connector.rb

@@ -0,0 +1,67 @@
+require 'faraday'
+require 'json'
+
+module Transmission
+  class RPC
+    class Connector
+      class AuthError < StandardError; end
+      class ConnectionError < StandardError; end
+
+      attr_accessor :host, :port, :ssl, :credentials, :path, :session_id, :response
+
+      def initialize(options = {})
+        @host = options[:host] || 'localhost'
+        @port = options[:port] || 9091
+        @ssl  = options[:ssl] || false
+        @credentials = options[:credentials] || nil
+        @path = options[:path] || '/transmission/rpc'
+        @session_id = options[:session_id] || ''
+      end
+
+      def post(params = {})
+        response = connection.post do |req|
+          req.url @path
+          req.headers['X-Transmission-Session-Id'] = @session_id
+          req.headers['Content-Type'] = 'application/json'
+          req.body = JSON.generate(params)
+        end
+        handle_response response, params
+      end
+
+      private
+
+      def json_body(response)
+        JSON.parse response.body
+      rescue
+        {}
+      end
+
+      def handle_response(response, params)
+        @response = response
+        if response.status == 409
+          @session_id = response.headers['x-transmission-session-id']
+          return post(params)
+        end
+        body = json_body response
+        raise AuthError if response.status == 401
+        raise ConnectionError, body['result'] unless response.status == 200 && body['result'] == 'success'
+        body['arguments']
+      end
+
+      def connection
+        @connection ||= begin
+          connection = Faraday.new(url: "#{scheme}://#{@host}:#{@port}", ssl: { verify: false }) do |faraday|
+            faraday.request  :url_encoded
+            faraday.adapter  Faraday.default_adapter
+          end
+          connection.basic_auth(@credentials[:username], @credentials[:password]) if @credentials
+          connection
+        end
+      end
+
+      def scheme
+        @ssl ? 'https' : 'http'
+      end
+    end
+  end
+end