trans-api 0.0.4 → 0.0.5

data/lib/trans-api/connect.rb

@@ -8,6 +8,7 @@ module Trans
       require 'json'
       require 'nokogiri'
       require 'net/http'
+      require 'timeout'
 
 
       METHODS = {
@@ -58,209 +59,120 @@ module Trans
 
       # handles
 
-      #TODO: need to refactor these redundant functions!!
-
       def session_get
-        data = METHODS[:session_get]
-        ret = self.do(:post, data)
-        # a little dirty, but works great :)
-        session = JSON.parse ret[:response].body.gsub("-","_"), {symbolize_names: true}
-        raise session[:result] unless valid? session, data[:tag]
-        session[:arguments]
+        self.get_method(:session_get) {|b| b.gsub("-","_")}
       end
 
       def session_stats
-        data = METHODS[:session_stats]
-        ret = self.do(:post, data)
-        session = JSON.parse ret[:response].body.gsub("-","_"), {symbolize_names: true}
-        raise session[:result] unless valid? session, data[:tag]
-        session[:arguments]
+        self.get_method(:session_stats) {|b| b.gsub("-","_")}
       end
 
       def session_set(arguments={})
-        data = METHODS[:session_set]
-        data[:arguments] = argument_name_to_api arguments
-        ret = self.do :post, data
-        session = JSON.parse ret[:response].body, {symbolize_names: true}
-        raise session[:result] unless valid? session, data[:tag]
-        session[:arguments]
+        self.get_method(:session_set, arguments)
       end
 
       def session_close
-        data = METHODS[:session_close]
-        ret = self.do :post, data
-        session = JSON.parse ret[:response].body, {symbolize_names: true}
-        raise session[:result] unless valid? session, data[:tag]
-        session[:arguments]
+        self.get_method(:session_close)
       end
 
       def torrent_get(fields = [:id, :name, :status], ids = [])
         arguments = { fields: fields }
         arguments[:ids] = ids unless ids.empty?
-        data = METHODS[:torrent_get]
-        data[:arguments] = argument_name_to_api arguments
-        ret = self.do(:post, data)
-        torrents = JSON.parse ret[:response].body, {symbolize_names: true}
-        raise torrents[:result] unless valid? torrents, data[:tag]
-        torrents[:arguments][:torrents]
+        args = self.get_method(:torrent_get, arguments)
+        args[:torrents]
       end
 
       def torrent_set(arguments={}, ids = [])
         arguments[:ids] = ids unless ids.empty?
-        data = METHODS[:torrent_set]
-        data[:arguments] = argument_name_to_api arguments
-        ret = self.do(:post, data)
-        torrents = JSON.parse ret[:response].body, {symbolize_names: true}
-        raise torrents[:result] unless valid? torrents, data[:tag]
-        torrents[:arguments][:torrents]
+        args = self.get_method(:torrent_set, arguments)
+        args[:torrents]
       end
 
       def torrent_start(ids = [])
         arguments = {}
         arguments[:ids] = ids unless ids.empty?
-        data = METHODS[:torrent_start]
-        data[:arguments] = argument_name_to_api arguments
-        ret = self.do(:post, data)
-        torrents = JSON.parse ret[:response].body, {symbolize_names: true}
-        raise torrents[:result] unless valid? torrents, data[:tag]
-        torrents[:arguments][:torrents]
+        args = self.get_method(:torrent_start, arguments)
+        args[:torrents]
       end
 
       def torrent_start_now(ids = [])
         arguments = {}
         arguments[:ids] = ids unless ids.empty?
-        data = METHODS[:torrent_start_now]
-        data[:arguments] = argument_name_to_api arguments
-        ret = self.do(:post, data)
-        torrents = JSON.parse ret[:response].body, {symbolize_names: true}
-        raise torrents[:result] unless valid? torrents, data[:tag]
-        torrents[:arguments][:torrents]
+        args = self.get_method(:torrent_start_now, arguments)
+        args[:torrents]
       end
 
       def torrent_stop(ids = [])
         arguments = {}
         arguments[:ids] = ids unless ids.empty?
-        data = METHODS[:torrent_stop]
-        data[:arguments] = argument_name_to_api arguments
-        ret = self.do(:post, data)
-        torrents = JSON.parse ret[:response].body, {symbolize_names: true}
-        raise torrents[:result] unless valid? torrents, data[:tag]
-        torrents[:arguments][:torrents]
+        args = self.get_method(:torrent_stop, arguments)
+        args[:torrents]
       end
 
       def torrent_add(arguments={})
-        data = METHODS[:torrent_add]
-        data[:arguments] = argument_name_to_api arguments
-        ret = self.do(:post, data)
-        # puts JSON.parse(ret[:response].body).inspect
-        torrents = JSON.parse ret[:response].body.gsub("-","_"), {symbolize_names: true}
-        raise torrents[:result] unless valid? torrents, data[:tag]
+        args = self.get_method(:torrent_add, arguments) {|b| b.gsub("-","_")}
         # omiting BUG: https://trac.transmissionbt.com/ticket/5614
-        return torrents[:arguments][:torrent_duplicate] if torrents[:arguments].include?(:torrent_duplicate)
-        torrents[:arguments][:torrent_added]
+        return args[:torrent_duplicate] if args.include?(:torrent_duplicate)
+        args[:torrent_added]
       end
 
       def torrent_remove(arguments={}, ids=[])
         arguments[:ids] = ids unless ids.empty?
-        data = METHODS[:torrent_remove]
-        data[:arguments] = argument_name_to_api arguments
-        ret = self.do(:post, data)
-        torrents = JSON.parse ret[:response].body.gsub("-","_"), {symbolize_names: true}
-        raise torrents[:result] unless valid? torrents, data[:tag]
-        torrents[:arguments]
+        self.get_method(:torrent_remove, arguments) {|b| b.gsub("-","_")}
       end
 
       def torrent_verify(ids = [])
         arguments = {}
         arguments[:ids] = ids unless ids.empty?
-        data = METHODS[:torrent_verify]
-        data[:arguments] = argument_name_to_api arguments
-        ret = self.do(:post, data)
-        torrents = JSON.parse ret[:response].body, {symbolize_names: true}
-        raise torrents[:result] unless valid? torrents, data[:tag]
-        torrents[:arguments]
+        self.get_method(:torrent_verify, arguments)
       end
 
       def torrent_reannounce(ids=[])
         arguments = {}
         arguments[:ids] = ids unless ids.empty?
-        data = METHODS[:torrent_reannounce]
-        data[:arguments] = argument_name_to_api arguments
-        ret = self.do(:post, data)
-        torrents = JSON.parse ret[:response].body, {symbolize_names: true}
-        raise torrents[:result] unless valid? torrents, data[:tag]
-        torrents[:arguments]
+        self.get_method(:torrent_reannounce, arguments)
       end
 
       def torrent_set_location(arguments={}, ids=[])
         arguments[:ids] = ids unless ids.empty?
-        data = METHODS[:torrent_set_location]
-        data[:arguments] = argument_name_to_api arguments
-        ret = self.do(:post, data)
-        torrents = JSON.parse ret[:response].body.gsub("-","_"), {symbolize_names: true}
-        raise torrents[:result] unless valid? torrents, data[:tag]
-        torrents[:arguments]
+        self.get_method(:torrent_set_location, arguments) {|b| b.gsub("-","_")}
       end
 
       def blocklist_update
-        data = METHODS[:blocklist_update]
-        ret = self.do(:post, data)
-        torrents = JSON.parse ret[:response].body.gsub("-","_"), {symbolize_names: true}
-        raise torrents[:result] unless valid? torrents, data[:tag]
-        torrents[:arguments]
+        tm = @conn[:timeout]
+        @conn[:timeout] = (@conn[:timeout] + 5) * 3
+        arg = self.get_method(:blocklist_update) {|b| b.gsub("-","_")}
+        @conn[:timeout] = tm
+        arg
       end
 
       def port_test
-        data = METHODS[:port_test]
-        ret = self.do(:post, data)
-        torrents = JSON.parse ret[:response].body.gsub("-","_"), {symbolize_names: true}
-        raise torrents[:result] unless valid? torrents, data[:tag]
-        torrents[:arguments]
+        self.get_method(:port_test) {|b| b.gsub("-","_")}
       end
 
 
       def queue_move_top(ids=[])
         arguments = {}
         arguments[:ids] = ids unless ids.empty?
-        data = METHODS[:queue_move_top]
-        data[:arguments] = argument_name_to_api arguments
-        ret = self.do(:post, data)
-        torrents = JSON.parse ret[:response].body.gsub("-","_"), {symbolize_names: true}
-        raise torrents[:result] unless valid? torrents, data[:tag]
-        torrents[:arguments]
+        self.get_method(:queue_move_top, arguments) {|b| b.gsub("-","_")}
       end
 
       def queue_move_up(ids=[])
         arguments = {}
         arguments[:ids] = ids unless ids.empty?
-        data = METHODS[:queue_move_up]
-        data[:arguments] = argument_name_to_api arguments
-        ret = self.do(:post, data)
-        torrents = JSON.parse ret[:response].body.gsub("-","_"), {symbolize_names: true}
-        raise torrents[:result] unless valid? torrents, data[:tag]
-        torrents[:arguments]
+        self.get_method(:queue_move_up, arguments) {|b| b.gsub("-","_")}
       end
 
       def queue_move_down(ids=[])
         arguments = {}
         arguments[:ids] = ids unless ids.empty?
-        data = METHODS[:queue_move_down]
-        data[:arguments] = argument_name_to_api arguments
-        ret = self.do(:post, data)
-        torrents = JSON.parse ret[:response].body.gsub("-","_"), {symbolize_names: true}
-        raise torrents[:result] unless valid? torrents, data[:tag]
-        torrents[:arguments]
+        self.get_method(:queue_move_down, arguments) {|b| b.gsub("-","_")}
       end
 
       def queue_move_bottom(ids=[])
         arguments = {}
         arguments[:ids] = ids unless ids.empty?
-        data = METHODS[:queue_move_bottom]
-        data[:arguments] = argument_name_to_api arguments
-        ret = self.do(:post, data)
-        torrents = JSON.parse ret[:response].body.gsub("-","_"), {symbolize_names: true}
-        raise torrents[:result] unless valid? torrents, data[:tag]
-        torrents[:arguments]
+        self.get_method(:queue_move_bottom, arguments) {|b| b.gsub("-","_")}
       end
 
 
@@ -268,21 +180,42 @@ module Trans
 
       # request
 
+
+      protected
+
+      def get_method(method_name, arguments=nil, &block)
+        data = METHODS[method_name]
+        data[:arguments] = argument_name_to_api(arguments) unless arguments.nil?
+        ret = self.do(:post, data)
+        body = ret[:response].body
+        # call block with body data (for gsub etc.)
+        body = block.call(body) if block.is_a?(Proc)
+        session = JSON.parse(body, {symbolize_names: true})
+        # puts session
+        raise session[:result] unless valid? session, data[:tag]
+        session[:arguments]
+      end
+
       def do(method = :get, data = nil)
         headers = @conn[:headers]
-
         uri = URI.parse "http://localhost/"
         uri.scheme = @conn[:scheme]
         uri.host = @conn[:host]
         uri.port = @conn[:port]
         uri.path = @conn[:path]
-
         # request
         http = Net::HTTP.new uri.host, uri.port
-        resp = http.get(uri.request_uri, data.to_json, headers) if method == :get
-        resp = http.post(uri.request_uri, data.to_json, headers) if method == :post
-        raise "not implemented #{method} request!!" if method != :get && method != :post
-
+        resp = nil
+        Timeout::timeout(@conn[:timeout]) do
+          # sleep 5
+          if method == :get
+            resp = http.get(uri.request_uri, data.to_json, headers)
+          elsif method == :post
+            resp = http.post(uri.request_uri, data.to_json, headers)
+          else
+            raise "not implemented #{method} request!!"
+          end
+        end
         # authorize via session id
         if resp.code.to_i == 409
           tmp = Nokogiri::HTML resp.body
@@ -291,15 +224,11 @@ module Trans
           # recursion!!!!
           return self.do(:post, data)
         end
-
         ret = {request: http, response: resp}
         handle_request_error(ret, data)
         ret
       end
 
-
-      private
-
       def valid?(body, tag)
         body[:result] == "success" && body[:tag] == tag
       end
@@ -314,12 +243,10 @@ module Trans
       end
 
       # error handling
-
       def handle_request_error(ret, data)
         raise "error handling: #{data[:method]}, #{request_str ret[:response]}" if ret[:response].code.to_i != 200
       end
 
-
       def request_str(response)
         ret = []
         ret << "[code: #{response.code}]"
@@ -327,7 +254,6 @@ module Trans
         ret.join "\n"
       end
 
-
     end
 
   end

data/lib/trans-api/session.rb

@@ -81,6 +81,14 @@ module Trans
         @client.connect.blocklist_update
       end
 
+      def connected?
+        begin
+          s = self.stats!
+          return s.is_a?(Hash)
+        rescue StandardError
+          false
+        end
+      end
 
       # blocklist-update
 

data/lib/trans-api/torrent.rb

@@ -53,6 +53,10 @@ module Trans
         self.attach_methods!
       end
 
+      def last_error
+        @last_error
+      end
+
       # placeholder for fields
       def metaclass
         class << self; self; end
@@ -75,6 +79,7 @@ module Trans
           @client.connect.torrent_set changed, [self.id]
           @old_fields = @fields.clone
         end
+        nil
       end
 
       # get registered fields
@@ -97,9 +102,14 @@ module Trans
 
       # reload current object
       def reset!
-        @fields = @client.connect.torrent_get( @fields.map{|k,v| k}, [self.id]).first
-        @old_fields = @fields.clone
-        @last_error = {error: "", message: ""}
+        begin
+          @fields = @client.connect.torrent_get( @fields.map{|k,v| k}, [self.id]).first
+          @old_fields = @fields.clone unless @fields.nil?
+          @last_error = {error: "", message: ""}
+        rescue Exception => e
+          @last_error = {error: "reset_exception", message: "cannot reset torrent (probably removed)"}
+        end
+        nil
       end
 
       def start!
@@ -213,6 +223,21 @@ module Trans
           Torrent.new torrent: torrent
         end
 
+        def add_magnet(uri, options={})
+          #TODO: urlencode &amp; dn= in name not checked
+          uri_match = uri.match(/dn=([\S]+)[&]/)
+          raise "no name found" if uri_match.size != 2
+          filename = uri_match[1]
+          # filter duplicates
+          find = Trans::Api::Torrent.find_by_field_value(:name, ::File.basename(filename, ".*"))
+          return find unless find.nil?
+          client = Client.new
+          options[:filename] = uri
+          torrent = client.connect.torrent_add options
+          torrent = client.connect.torrent_get( @@default_fields, [torrent[:id]]).first
+          Torrent.new torrent: torrent
+        end
+
         def add_metainfo(metainfo, name, options={})
           raise "name empty" if name.nil? || name == ""
           options[:metainfo] = metainfo
@@ -287,7 +312,7 @@ module Trans
       def method_missing(method, *args)
 
         unless args.empty?
-          @target_object.send method, args
+          @target_object.send method, *args
         else
           @target_object.send method
         end
@@ -297,11 +322,16 @@ module Trans
       end
 
       def wait
-        # keep trying task (and refreshing the torrent file)
-        while true do
-          @target_object.reset!
-          t = @task.call @target_object
-          break if t # task achieved!
+        begin
+          # keep trying task (and refreshing the torrent file)
+          while true do
+            @target_object.reset!
+            t = @task.call @target_object
+            break if t # task achieved!
+          end
+        rescue Exception => e
+          # some error has occured ()
+          @@last_error = {error: "wait_exception", message: e.message}
         end
       end
 

data/lib/trans-api/version.rb

@@ -1,5 +1,5 @@
 module Trans
   module Api
-    VERSION = "0.0.4"
+    VERSION = "0.0.5"
   end
 end

data/lib/trans-api.rb

@@ -6,7 +6,9 @@ require File.expand_path(File.dirname(__FILE__) + "/trans-api/torrent")
 require File.expand_path(File.dirname(__FILE__) + "/trans-api/file")
 
 # boolean helper
-if Boolean.nil?
+begin
+  Boolean.nil?
+rescue NameError
   module Boolean; end
   class TrueClass; include Boolean; end
   class FalseClass; include Boolean; end

data/test/test_helper.rb

@@ -0,0 +1,6 @@
+require 'rubygems'
+require 'test/unit'
+require File.expand_path(File.dirname(__FILE__) + "/../lib/trans-api")
+
+# require 'coveralls'
+# Coveralls.wear!