aria2_driver 0.0.4 → 0.0.5

checksums.yaml

@@ -1,15 +1,15 @@
 ---
 !binary "U0hBMQ==":
   metadata.gz: !binary |-
-    NTZiM2QzYWFiODhhNDI3ZjRkYTJhM2FiM2VkNzMwMjUzMmNkNDZhYQ==
+    M2ZlMzFiMDg2MWYxNzA1MGMwMThiZDY5YjdhZDkxYjRlMjVhOGY2MQ==
   data.tar.gz: !binary |-
-    NzdjMjZlMDY0NjAyNDc3Njc5MjM3MjlmOWZlOWJmYjE5NTllMTMzMg==
+    NjhkZWM1OTkwZmJkMGMwMDE1OTJhOGFlNTgwZGJmODMzNDBiODUyZA==
 SHA512:
   metadata.gz: !binary |-
-    YzI0ZDBmZGFlZTQyOTE2MzlmYzA2YWZjZjZkYzM1ZTg5Y2U0ZmZlNjhiYjlm
-    ZmE5NGZkMjkyOTAxYmEyMzA2NDVjYmI5NDY1OWVjNTIyYWVjOTYzNDZlZmM5
-    ZDQxNzU1ZDU1MmExYmYxNTM2NjA5YTk2MTViMWQ1NTE0NDY5M2U=
+    Yjc1MjRkOWM3MGZkNDBhYTZjZDRhODdiMGU0MGY2NTNmZmFlNDZiNzdmMDBk
+    Mjk0YmQ4ZTJiYTRhMThmOTc4NGUwOTk2YWVjYjJhOGY4NDg3OWUzMmM4YjFh
+    MWI3MGJlMzEyOTczZmUzNjRmMzNkOTI4NmI0NTRlNTc3YTM3MTQ=
   data.tar.gz: !binary |-
-    M2Q0OGMxZjE3NjQ1MDY5Nzc4ZTY1ZjZlOWRiZWQ0ZGZkMjRkN2Q4ZTEzNDM4
-    ZWVlM2U4NzVkZDYzOGU0OThhYjZhNWY2YWE2YjJhNTg0MTgyYmM0Nzg0MDI2
-    ZDM0YzdhMWRhZGMwNGVlYjc1NjJlZTUwMWM5ODBjMjVlZTQ3MjQ=
+    NmU0Njk2NTkzYTEyZTVkNTFiNDMzMDY5ZjVmOGVkMjI5ODkzMGMyMDk1YWY5
+    YmUwM2U5MTAzZTU3NTkzNGE5ZDIwNGJmMGJkMDgwNjBkZmI1MzNlODA1MzJj
+    ODk1OTUxY2NhYzI4YmViMjA3Nzk2ZDJiOGJlMzI3YjM1NDNkODI=

data/.yardopts

@@ -0,0 +1,4 @@
+-
+README.md
+LICENSE.md
+lib/**/*.rb

data/README.md

@@ -11,7 +11,7 @@ Simple api to manage aria2c via api
 
 Add this line to your application's Gemfile:
 
-```ruby
+``` ruby
 gem 'aria2_driver'
 ```
 
@@ -25,7 +25,73 @@ Or install it yourself as:
 
 ## Usage
 
-TODO: Write usage instructions here
+
+### Simple aria2 client initialization
+
+
+``` ruby
+aria2 = Aria2Driver::JsonRpc::Client.new 'hostname'
+```
+
+With the previous line of code you can create a client that will make requests to `aria2c` downloader
+running on **hostname** server accepting connections to port **80** with default **http** scheme.
+The client created as is will have a self generated client id (using SecureRandom).
+
+``` ruby
+aria2 = Aria2Driver::JsonRpc::Client.new 'hostname',
+              {port: 9090, scheme: 'https', id: 'my', token: 'abcd-1234'}
+```
+
+With the code described above, you can override default connection parameters specifying also a
+custom **client_id** and a **secret token**. The latter will be used in any of the following requests and
+must match the **--rpc-secret** parameter specified in the aria2c configuration.
+
+
+### Making requests
+
+Aria2Driver allows you to make a generic request, via jsonrpc, in which you have to put the aria2 **method** and
+request parameters, as described below
+
+``` ruby
+response = aria2.request Aria2Driver::JsonRpc::Request.new 'aria2.addUri',
+                         {params: [['http://www.example.com/a.jpg'], {"dir" => "/tmp/"}]}
+```
+
+it's also possible to make the same request as follow
+
+``` ruby
+response = aria2.add_uri {params: [['http://www.example.com/a.jpg'], {"dir" => "/tmp/"}]}
+```
+
+### Response
+
+Aria2Driver request can lead to a valid aria2c response or to an exception (*ResponseException*) in case of
+a connection problem or any other kind of problem occurred in the communication with aria2c.
+You can check if a valid response is an 'error' one or a 'result' one checking the **error?** method as below
+
+``` ruby
+response = aria2.get_version
+response.error?
+```
+
+If a response is an error one, the **error** getter returns you a simple ruby wrapper class of the jsonrpc error
+block, with **code**, **message** and the optional **data**
+
+``` ruby
+
+error = response.error
+
+error.code # => -32700
+error.message # => "Parse error"
+```
+
+If you get a non-error response, you can access the **result** in form of an hash obtained parsing the json result block
+in the aria2c response
+
+``` ruby
+response.result # => {"gid" => "2089b05ecca3d829", "status" => "active"}
+```
+
 
 ## Contributing
 

data/lib/aria2_driver/json_rpc/client.rb

@@ -4,6 +4,7 @@ require 'json'
 require 'aria2_driver/json_rpc/connection'
 require 'aria2_driver/json_rpc/request'
 require 'aria2_driver/json_rpc/response'
+require 'aria2_driver/json_rpc/response_exception'
 
 
 module Aria2Driver
@@ -23,21 +24,21 @@ module Aria2Driver
       def request(request)
         req_hash = request_to_hash(request)
         http = Net::HTTP.new(connection.host, connection.port)
-        http_response = http.request_post(
-            request.path,
-            JSON.generate(req_hash),
-            {
-                'Accept' => 'application/json',
-                'Content-Type' => 'application/json'
-            }
-        )
-        Aria2Driver::JsonRpc::Response.new(JSON.parse(http_response.body))
+        begin
+          http_response = http.request_post(
+              request.path,
+              JSON.generate(req_hash),
+              {
+                  'Accept' => 'application/json',
+                  'Content-Type' => 'application/json'
+              }
+          )
+          Aria2Driver::JsonRpc::Response.new(JSON.parse(http_response.body))
+        rescue Exception => ex
+          raise Aria2Driver::JsonRpc::ResponseException.new "Connection Error"
+        end
       end
 
-      def self.from_url(url, options={})
-        uri = URI.parse(url)
-        new uri.host, options.merge({scheme: uri.scheme, port: uri.port, path: uri.path})
-      end
 
       def method_missing(method, *args)
         if supported_request?(method)
@@ -61,7 +62,7 @@ module Aria2Driver
       end
 
       def snake_lower_camel(snake)
-        snake.gsub(/(_.)/){ $1.upcase[-1] }
+        snake.gsub(/(_.)/) { $1.upcase[-1] }
       end
 
       def generate_uuid

data/lib/aria2_driver/json_rpc/response_exception.rb

@@ -0,0 +1,9 @@
+module Aria2Driver
+  module JsonRpc
+    class ResponseException < StandardError
+      def initialize(message)
+        super(message)
+      end
+    end
+  end
+end

data/lib/aria2_driver/version.rb

@@ -1,3 +1,3 @@
 module Aria2Driver
-  VERSION = "0.0.4"
+  VERSION = "0.0.5"
 end

data/spec/aria2_driver/json_rpc/client_spec.rb

@@ -21,8 +21,12 @@ module Aria2Driver
       end
 
       it 'should create from url' do
-        client = Aria2Driver::JsonRpc::Client.from_url(
-            'https://localhost:9090/jsonrpc', {id: 'my', token: 'abcd-1234'})
+        client = Aria2Driver::JsonRpc::Client.new 'localhost', {
+                                                                 id: 'my',
+                                                                 scheme: 'https',
+                                                                 port: 9090,
+                                                                 token: 'abcd-1234'
+                                                             }
         expect(client.id).to eq('my')
         expect(client.token).to eq('abcd-1234')
         expect(client.connection).to have_attributes({
@@ -32,15 +36,26 @@ module Aria2Driver
                                                      })
       end
 
+
       describe 'requests' do
+
+        let :aria2 do
+          Aria2Driver::JsonRpc::Client.new 'localhost', {
+                                                          id: 'local_client',
+                                                          token: 'abcd-1234'
+                                                      }
+        end
+
         it 'simple successful generic request' do
-          stubbed_request = Mocks::JsonRpc::GetVersionRequest.new('localhost', {port: 80, params: ["token:abcd-1234"]})
+          stubbed_request = Mocks::JsonRpc::GetVersionRequest.new('localhost',
+                                                                  {
+                                                                      port: 80,
+                                                                      params: ["token:abcd-1234"]
+                                                                  })
           mock_response = Mocks::JsonRpc::GetVersionSuccessfulResponse.new
           stubbed_request.with_response(mock_response)
 
-          client = Aria2Driver::JsonRpc::Client.from_url(
-              'http://localhost:80/jsonrpc', {id: 'local_client', token: 'abcd-1234'})
-          response = client.request(Aria2Driver::JsonRpc::Request.new 'aria2.getVersion')
+          response = aria2.request(Aria2Driver::JsonRpc::Request.new 'aria2.getVersion')
 
           expect(response.error?).to be_falsey
           expect(response.result['version']).to eq(mock_response.result['version'])
@@ -52,9 +67,7 @@ module Aria2Driver
           mock_error_response = Mocks::JsonRpc::ErrorResponse.new({code: -32700, message: 'Parse error'})
           stubbed_request.with_response(mock_error_response)
 
-          client = Aria2Driver::JsonRpc::Client.from_url(
-              'http://localhost:80/jsonrpc', {id: 'local_client', token: 'abcd-1234'})
-          response = client.request(Aria2Driver::JsonRpc::Request.new 'aria2.getVersion')
+          response = aria2.request(Aria2Driver::JsonRpc::Request.new 'aria2.getVersion')
 
           expect(response.error?).to be_truthy
           expect(response.error).to have_attributes({
@@ -62,92 +75,91 @@ module Aria2Driver
                                                         message: mock_error_response.message
                                                     })
         end
-      end
 
-      describe 'version' do
-        it 'get_version request' do
-          stubbed_request = Mocks::JsonRpc::GetVersionRequest.new('localhost', {port: 80, params: ["token:abcd-1234"]})
-          mock_response = Mocks::JsonRpc::GetVersionSuccessfulResponse.new
-          stubbed_request.with_response(mock_response)
-
-          aria2 = Aria2Driver::JsonRpc::Client.from_url(
-              'http://localhost:80/jsonrpc', {id: 'local_client', token: 'abcd-1234'})
-
-          expect(aria2.respond_to?(:get_version)).to be true
+        it 'handle connection refused on request' do
+          stub_request(:any, 'http://localhost:80/jsonrpc').to_raise(Errno::ECONNREFUSED)
 
-          response = aria2.get_version
-
-          expect(response.error?).to be_falsey
-          expect(response.result['version']).to eq(mock_response.result['version'])
-          expect(response.result['enabledFeatures']).to eq(mock_response.result['enabledFeatures'])
+          expect{aria2.request(Aria2Driver::JsonRpc::Request.new 'aria2.getVersion')}
+              .to raise_error(Aria2Driver::JsonRpc::ResponseException)
         end
-      end
 
-      describe 'add uri' do
-        it 'add_uri request' do
-          stubbed_request = Mocks::JsonRpc::AddUriRequest.new('localhost',
-                                                              {
-                                                                  port: 80,
-                                                                  params: [
-                                                                      "token:abcd-1234",
-                                                                      ['http://www.example.com/a.jpg'],
-                                                                      {"dir" => "/tmp/"}
-                                                                  ]
-                                                              })
-          mock_response = Mocks::JsonRpc::AddUriSuccessfulResponse.new
-          stubbed_request.with_response(mock_response)
+        describe 'version' do
+          it 'get_version request' do
+            stubbed_request = Mocks::JsonRpc::GetVersionRequest.new('localhost', {port: 80, params: ["token:abcd-1234"]})
+            mock_response = Mocks::JsonRpc::GetVersionSuccessfulResponse.new
+            stubbed_request.with_response(mock_response)
 
-          aria2 = Aria2Driver::JsonRpc::Client.from_url(
-              'http://localhost:80/jsonrpc', {id: 'local_client', token: 'abcd-1234'})
+            expect(aria2.respond_to?(:get_version)).to be true
 
-          response = aria2.add_uri({params: [['http://www.example.com/a.jpg'], {"dir" => "/tmp/"}]})
+            response = aria2.get_version
 
-          expect(response.error?).to be_falsey
-          expect(response.result).to eq(mock_response.result)
+            expect(response.error?).to be_falsey
+            expect(response.result['version']).to eq(mock_response.result['version'])
+            expect(response.result['enabledFeatures']).to eq(mock_response.result['enabledFeatures'])
+          end
         end
-      end
 
-      describe 'status' do
-        it 'tell_status simple request' do
-          stubbed_request = Mocks::JsonRpc::TellStatusRequest.new('localhost',
-                                                              {
-                                                                  port: 80,
-                                                                  params: [
-                                                                      "token:abcd-1234",
-                                                                      "2089b05ecca3d829"
-                                                                  ]
-                                                              })
-          mock_response = Mocks::JsonRpc::TellStatusSuccessfulResponse.new
-          stubbed_request.with_response(mock_response)
-
-          aria2 = Aria2Driver::JsonRpc::Client.new 'localhost', {port: 80, id: 'local_client', token: 'abcd-1234'}
-          response = aria2.tell_status({params: ["2089b05ecca3d829"]})
-
-          expect(response.error?).to be_falsey
-          expect(response.result).to eq(mock_response.result)
+        describe 'add uri' do
+          it 'add_uri request' do
+            stubbed_request = Mocks::JsonRpc::AddUriRequest.new('localhost',
+                                                                {
+                                                                    port: 80,
+                                                                    params: [
+                                                                        "token:abcd-1234",
+                                                                        ['http://www.example.com/a.jpg'],
+                                                                        {"dir" => "/tmp/"}
+                                                                    ]
+                                                                })
+            mock_response = Mocks::JsonRpc::AddUriSuccessfulResponse.new
+            stubbed_request.with_response(mock_response)
+
+            response = aria2.add_uri({params: [['http://www.example.com/a.jpg'], {"dir" => "/tmp/"}]})
+
+            expect(response.error?).to be_falsey
+            expect(response.result).to eq(mock_response.result)
+          end
         end
 
-        it 'tell_status request with selected keys' do
-          stubbed_request = Mocks::JsonRpc::TellStatusRequest.new('localhost',
-                                                                  {
-                                                                      port: 80,
-                                                                      params: [
-                                                                          "token:abcd-1234",
-                                                                          "2089b05ecca3d829",
-                                                                          ["gid", "status"]
-                                                                      ]
-                                                                  })
-          mock_response = Mocks::JsonRpc::TellStatusSuccessfulResponse.new
-          stubbed_request.with_response(mock_response)
-
-          aria2 = Aria2Driver::JsonRpc::Client.new 'localhost', {port: 80, id: 'local_client', token: 'abcd-1234'}
-          response = aria2.tell_status({params: ["2089b05ecca3d829", ['gid', 'status']]})
-
-          expect(response.error?).to be_falsey
-          expect(response.result).to eq({"gid"=>"2089b05ecca3d829", "status"=>"active"})
+        describe 'status' do
+          it 'tell_status simple request' do
+            stubbed_request = Mocks::JsonRpc::TellStatusRequest.new('localhost',
+                                                                    {
+                                                                        port: 80,
+                                                                        params: [
+                                                                            "token:abcd-1234",
+                                                                            "2089b05ecca3d829"
+                                                                        ]
+                                                                    })
+            mock_response = Mocks::JsonRpc::TellStatusSuccessfulResponse.new
+            stubbed_request.with_response(mock_response)
+
+            response = aria2.tell_status({params: ["2089b05ecca3d829"]})
+
+            expect(response.error?).to be_falsey
+            expect(response.result).to eq(mock_response.result)
+          end
+
+          it 'tell_status request with selected keys' do
+            stubbed_request = Mocks::JsonRpc::TellStatusRequest.new('localhost',
+                                                                    {
+                                                                        port: 80,
+                                                                        params: [
+                                                                            "token:abcd-1234",
+                                                                            "2089b05ecca3d829",
+                                                                            ["gid", "status"]
+                                                                        ]
+                                                                    })
+            mock_response = Mocks::JsonRpc::TellStatusSuccessfulResponse.new
+            stubbed_request.with_response(mock_response)
+
+            response = aria2.tell_status({params: ["2089b05ecca3d829", ['gid', 'status']]})
+
+            expect(response.error?).to be_falsey
+            expect(response.result).to eq({"gid" => "2089b05ecca3d829", "status" => "active"})
+          end
         end
-
       end
     end
+
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: aria2_driver
 version: !ruby/object:Gem::Version
-  version: 0.0.4
+  version: 0.0.5
 platform: ruby
 authors:
 - Roberto Ciatti
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-03-05 00:00:00.000000000 Z
+date: 2015-03-12 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -90,8 +90,9 @@ extra_rdoc_files: []
 files:
 - .gitignore
 - .travis.yml
+- .yardopts
 - Gemfile
-- LICENSE
+- LICENSE.md
 - README.md
 - Rakefile
 - aria2_driver.gemspec
@@ -101,6 +102,7 @@ files:
 - lib/aria2_driver/json_rpc/error.rb
 - lib/aria2_driver/json_rpc/request.rb
 - lib/aria2_driver/json_rpc/response.rb
+- lib/aria2_driver/json_rpc/response_exception.rb
 - lib/aria2_driver/version.rb
 - spec/aria2_driver/json_rpc/client_spec.rb
 - spec/aria2_driver/json_rpc/connection_spec.rb