studio_api 2.3.0

data/README

@@ -0,0 +1,93 @@
+Studio API: Wrapper to STUDIO API
+====================================
+
+Synopsis
+--------
+
+Studio API library is intended to easier access to Studio API from ruby,
+but keep it easily extensible and easy maintanable, so it not need rewritting
+when new attributes introduced to Studio. It leads also that user need to know 
+API documentation, which specify what options you need to use (see http://susestudio.com/help/api/v1 ).
+It has also feature which allows using in multiuser system (like server).
+
+Example
+-------
+
+Example usage ( more in class documentation ). Example show how to clone appliance,
+upload own rpm, select it, find new software and add it, run new build and then print information about appliance.
+Note: All error handling is for simplicity removed. It is same as for ActiveResource so if you want see him, search
+for ActiveResource error handling.
+  
+  require 'rubygems'
+  # If you want use it from git adapt LOAD_PATH
+  # you can load just required parts if you need, but Util loaded all classes to properly set it
+  require 'studio_api'
+
+  # Fill up Studio credentials (user name, API key, API URL)
+  # See https://susestudio.com/user/show_api_key if you are using SUSE Studio online
+  connection = StudioApi::Connection.new('user', 'pwd', 'https://susestudio.com/api/v1/user')
+  # Setup the connection for all ActiveResource based class
+  StudioApi::Util.configure_studio_connection connection
+
+  # Find template with KDE4 for SLE11SP1
+  templates = StudioApi::TemplateSet.find(:all).find {|s| s.name == "default" }.template
+  template = templates.find { |t| t.name == "SLED 11 SP1, KDE 4 desktop" }
+  # clone template to new appliance
+  appliance = StudioApi::Appliance.clone template.appliance_id, :name => "New cool appliance", :arch => "i686" 
+  puts "Created appliance #{appliance.inspect}"
+
+  #add own rpm built agains SLED11_SP1
+  StudioApi::Rpm.upload "/home/jreidinger/rpms/kezboard-1.0-1.60.noarch.rpm", "SLED11_SP1"
+  # and choose it in appliance ( and of course add repository with own rpms)
+  appliance.add_user_repository
+  appliance.add_package "kezboard", :version => "1.0-1.60"
+
+  # find samba package and if it is not found in repositories in appliance, try it in all repos
+  result = appliance.search_software("samba").find { |s| s.name == "samba" }
+  unless result #it is not found in available repos
+    result = appliance.search_software("samba", :all_repos => "true").find { |s| s.name == "samba" }
+    # add repo which contain samba
+    appliance.add_repository result.repository_id
+  end
+  appliance.add_package "samba"
+
+  #check if appliance is OK
+  if appliance.status.state != "ok"
+    raise "appliance is not OK - #{appliance.status.issues.inspect}"
+  end
+  debugger
+  build = StudioApi::RunningBuild.new(:appliance_id => appliance.id, :image_type => "xen")
+  build.save
+  build.reload
+  while build.state != "finished"
+    puts "building (#{build.state}) - #{build.percent}%"
+    sleep 5
+    build.reload
+  end
+
+  final_build = StudioApi::Build.find build.id
+  puts final_build.inspect
+
+  # to clear after playing with appliance if you keep same name, clean remove appliances with:
+  # appliances = StudioApi::Appliance.find :all
+  # appliances.select{ |a| a.name =~ /cool/i }.each{ |a| a.destroy }
+
+Second example contain how to easy mock calling studio stuff without mock server. Using mocha
+
+  require 'mocha'
+  require 'studio_api'
+
+  APPLIANCE_UUID = "68c91080-ccca-4270-a1d3-10e714ddd1c6"
+  APPLIANCE_VERSION = "0.0.1"
+  APPLIANCE_STUDIO_ID = "97216"
+  BUILD_ID = "180420"
+  APPLIANCE_1 = StudioApi::Appliance.new :id => APPLIANCE_STUDIO_ID, :name => "Test", :arch => 'i386',
+                            :last_edited => "2010-10-08 14:46:07 UTC", :estimated_raw_size => "390 MB", :estimated_compressed_size => "140 MB",
+                            :edit_url => "http://susestudio.com/appliance/edit/266657", :icon_url => "http://susestudio.com/api/v1/user/appliance_icon/266657",
+                            :basesystem => "SLES11_SP1", :uuid => APPLIANCE_UUID, :parent => {:id => "202443", :name => "SLES 11 SP1, Just enough OS (JeOS)"},
+                            :builds => [{:id =>BUILD_ID,:version => APPLIANCE_VERSION, :image_type => "vmx", :image_size => "695",
+                            :compressed_image_size => "121",
+                            :download_url => "http://susestudio.com/download/a0f0217f0645099c9e41c42e9bf89976/josefs_SLES_11_SP1_git_test.i686-0.0.1.vmx.tar.gz"}] 
+  
+  #real mocking
+  StudioApi::Appliance.stubs(:find).with(APPLIANCE_STUDIO_ID).returns(APPLIANCE_1)

data/Rakefile

@@ -0,0 +1,64 @@
+require 'rake'
+require 'rake/rdoctask'
+require 'rake/testtask'
+
+task :default => "test"
+
+Rake::TestTask.new do |t|
+  t.libs << "test"
+  t.pattern = 'test/*_test.rb'
+  t.verbose = true
+end
+
+begin
+  require 'yard'
+    YARD::Rake::YardocTask.new do |t|
+      t.files   = ['lib/**/*.rb']   # optional
+      t.options = [] # optional
+    end
+rescue LoadError
+  puts "Yard not available. To generate documentation install it with: gem install yard"
+end
+
+
+begin
+  require 'jeweler'
+    Jeweler::Tasks.new do |s|
+      s.name = %q{studio_api}
+      s.summary = %q{Studio Api Interface.}
+      s.description = %q{Studio Api makes it easier to use Studio via API.
+                Instead of adapting each ActiveResource to its behavior and
+                manually adding multipart file upload it wrapp in in Active
+                Resource like interface. It is possible to define credentials
+                for whole api, or use it per partes, so it allow using it for
+                different studio users together.}
+
+      s.files = FileList['[A-Z]*', 'lib/studio_api/*.rb','lib/studio_api.rb', 'test/**/*.rb']
+      s.require_path = 'lib'
+      s.test_files = Dir[*['test/*_test.rb','test/responses/*.xml']]
+      s.has_rdoc = true
+      s.extra_rdoc_files = ["README.rdoc"]
+      s.rdoc_options = ['--line-numbers', "--main", "README.rdoc"]
+      s.authors = ["Josef Reidinger"]
+      s.email = %q{jreidinger@suse.cz}
+      s.homepage = "http://github.com/jreidinger/studio_api"
+      s.add_dependency "activeresource", ">= 1.3.8"
+      s.add_dependency "xml-simple", ">= 1.0.0"
+      s.platform = Gem::Platform::RUBY
+    end
+    Jeweler::GemcutterTasks.new
+
+  desc "Create package directory containing all things to build RPM"
+  task :package => [:build] do
+    pkg_name = "rubygem-studio_api"
+    include FileUtils::Verbose
+    rm_rf "package"
+    mkdir "package"
+    cp "#{pkg_name}.changes","package/"
+    cp "#{pkg_name}.spec.template","package/#{pkg_name}.spec"
+    sh 'cp pkg/*.gem package/'
+    sh "sed -i \"s:<VERSION>:`cat VERSION`:\" package/#{pkg_name}.spec"
+  end
+rescue LoadError
+  puts "Jeweler not available. To generate gem install it with: gem install jeweler"
+end

data/VERSION

@@ -0,0 +1 @@
+2.3.0

data/lib/studio_api/appliance.rb

@@ -0,0 +1,365 @@
+require "studio_api/studio_resource"
+require "studio_api/generic_request"
+require "studio_api/pattern"
+require "studio_api/package"
+require "xmlsimple"
+require "fileutils"
+require 'cgi'
+
+module StudioApi
+  # Represents appliance in studio
+  # beside information about itself contains also information about its 
+  # relative object like packages, signing keys etc
+  # Each method try to be ActiveResource compatible, so each can throw ConnectionError
+  class Appliance < ActiveResource::Base
+    extend StudioApi::StudioResource
+
+    self.element_name = "appliance"
+
+    # Represents status of appliance
+    # used as output for Appliance#status
+    # @see Appliance#status
+    class Status < ActiveResource::Base
+      extend StudioResource
+      self.element_name = "status"
+    end
+
+    # Represents repository assigned to appliance
+    # supports find :all and deleting from appliance
+    class Repository < ActiveResource::Base
+      extend StudioResource
+      self.prefix = "/appliances/:appliance_id/"
+      self.element_name = "repository"
+      mattr_accessor :appliance
+
+      #for delete repository doesn't work clasic method from ARes
+      # @see StudioApi::Appliance#remove_repository
+      def destroy
+        self.class.appliance.remove_repository id
+      end
+    end
+    
+    # Represents GPGKey assigned to appliance
+    class GpgKey < ActiveResource::Base
+      extend StudioResource
+      self.prefix = "/appliances/:appliance_id/"
+      self.element_name = "gpg_key"
+      mattr_accessor :appliance
+
+      # upload new GPG key to appliance
+      # @param (#to_i) appliance_id id of appliance to which load gpg key
+      # @param (#to_s) name of gpg key
+      # @param (File, String) opened file containing key or key in string
+      # @param (Hash) options additional options keys as it allow studio API
+      # @example Load from file
+      #   File.open ("/etc/my.cert") do |file|
+      #     StudioApi::Appliance::GpgKey.create 1234, "my new cool key", file, :target => "rpm"
+      #   end
+      def self.create (appliance_id, name, key, options={})
+        options[:target] ||= "rpm"
+        data = {}
+        if key.is_a?(IO) && key.respond_to?(:path) #if key is string, that pass it in request, if not pack it in body
+          data[:file] = key
+        else
+          options[:key] = key.to_s
+        end
+        request_str = "/appliances/#{appliance_id.to_i}/gpg_keys?name=#{name}"
+        options.each do |k,v|
+          request_str << "&#{CGI.escape k.to_s}=#{CGI.escape v.to_s}"
+        end
+        response = GenericRequest.new(studio_connection).post request_str, data
+        self.new Hash.from_xml(response)["gpg_key"]
+      end
+    end
+
+    # gets status of appliance
+    # @return [StudioApi::Appliance::Status] resource of status
+    def status
+      my_status = Status#.dup FIXME this doesn't work well with AciveResource :(
+      my_status.studio_connection = self.class.studio_connection
+      #rails is so smart, that it ignores prefix for calls. At least it is good that we don't want to do such things from library users
+      from = Util.join_relative_url( self.class.site.path,"appliances/#{id.to_i}/status")
+      my_status.find :one, :from => from
+    end
+
+    # Gets file content from finished build.
+    # @param [StudioApi::Build, StudioApi::Appliance::Build] build from which download file
+    # @param [#to_s] src_path path in appliance fs to required file
+    # @return [String] content of file
+    def file_content_from_build (build,src_path)
+      rq = GenericRequest.new self.class.studio_connection
+      rq.get "/appliances/#{id.to_i}/image_files?build_id=#{build.id.to_i}&path=#{CGI.escape src_path.to_s}"
+    end
+
+    # Gets all repositories assigned to appliance
+    # @return [StudioApi::Appliance::Repository] assigned repositories
+    def repositories
+      my_repo = Repository.dup
+      my_repo.studio_connection = self.class.studio_connection
+      my_repo.appliance = self
+      my_repo.find :all, :params => { :appliance_id => id }
+    end
+
+    # remove repositories from appliance
+    # @param (#to_s,Array<#to_s>)
+    # @return (Array<StudioApi::Repository>) list of remaining repositories
+    # @example various way to remove repo
+    #   appl = Appliance.find 1234
+    #   appl.remove_repository 5678
+    #   appl.remove_repository [5678,34,56,78,90]
+    #   appl.remove_repository 5678,34,56,78,90
+
+    def remove_repository (*repo_ids)
+      response = nil
+      repo_ids.flatten.each do |repo_id|
+        rq = GenericRequest.new self.class.studio_connection
+        response = rq.post "/appliances/#{id}/cmd/remove_repository?repo_id=#{repo_id.to_i}"
+      end
+      Hash.from_xml(response)["repositories"].collect{ |r| Repository.new r }
+    end
+
+    # adds repositories to appliance
+    # @param (#to_s,Array<#to_s>)
+    # @return (Array<StudioApi::Repository>) list of all repositories including new one
+    # @example various way to add repo
+    #   appl = Appliance.find 1234
+    #   appl.add_repository 5678
+    #   appl.add_repository [5678,34,56,78,90]
+    #   appl.add_repository 5678,34,56,78,90
+    def add_repository (*repo_ids)
+      response = nil
+      repo_ids.flatten.each do |repo_id|
+        rq = GenericRequest.new self.class.studio_connection
+        response = rq.post "/appliances/#{id}/cmd/add_repository?repo_id=#{repo_id.to_i}"
+      end
+      Hash.from_xml(response)["repositories"].collect{ |r| Repository.new r }
+    end
+
+    # adds repository for user rpms
+    def add_user_repository
+      rq = GenericRequest.new self.class.studio_connection
+      rq.post "/appliances/#{id}/cmd/add_user_repository"
+    end
+
+    # clones appliance or template
+    # @see (StudioApi::TemplateSet)
+    # @param (#to_i) source_id id of source appliance
+    # @param (Hash<String,String>) options optional parameters to clone command
+    # @return (StudioApi::Appliance) resulted appliance
+    def self.clone source_id,options={}
+      request_str = "/appliances?clone_from=#{source_id.to_i}"
+      options.each do |k,v|
+        request_str << "&#{CGI.escape k.to_s}=#{CGI.escape v.to_s}"
+      end
+      response = GenericRequest.new(studio_connection).post request_str, options
+      Appliance.new Hash.from_xml(response)["appliance"]
+    end
+
+    # Gets all GPG keys assigned to appliance
+    # @return [Array<StudioApi::Appliance::GpgKey>] included keys
+    def gpg_keys
+      my_key = GpgKey.dup
+      my_key.studio_connection = self.class.studio_connection
+      my_key.find :all, :params => { :appliance_id => id }
+    end
+
+    # Gets GPG key assigned to appliance with specified id
+    # @param (#to_s) key_id id of requested key
+    # @return [StudioApi::Appliance::GpgKey,nil] found key or nil if it is not found
+    def gpg_key( key_id )
+      my_key = GpgKey.dup
+      my_key.studio_connection = self.class.studio_connection
+      my_key.find key_id, :params => { :appliance_id => id }
+    end
+
+    # add GPG key to appliance
+    # @params (see GpgKey#create)
+    # @return [StudioApi::Appliance::GpgKey] created key
+    def add_gpg_key (name, key, options={})
+      my_key = GpgKey.dup
+      my_key.studio_connection = self.class.studio_connection
+      my_key.create id, name, key, options
+    end
+
+    # Gets list of all explicitelly selected software ( package and patterns)
+    # in appliance
+    # @return (Array<StudioApi::Package,StudioApi::Pattern>) list of selected packages and patterns
+    def selected_software
+      request_str = "/appliances/#{id.to_i}/software"
+      response = GenericRequest.new(self.class.studio_connection).get request_str
+      attrs = XmlSimple.xml_in response
+      convert_selectable attrs
+    end
+
+    # Gets list of all installed (include dependencies) software
+    # (package and patterns) in appliance
+    # @param (Hash) hash of options, see studio API
+    # @return (Array<StudioApi::Package,StudioApi::Pattern>) list of installed packages and patterns
+    def installed_software (options = {})
+      request_str = "/appliances/#{id.to_i}/software/installed"
+			unless options.empty?
+				first = true
+				options.each do |k,v|
+					separator = first ? "?" : "&"
+					first = false
+					request_str << "#{separator}#{CGI.escape k.to_s}=#{CGI.escape v.to_s}"
+				end
+			end
+      response = GenericRequest.new(self.class.studio_connection).get request_str
+      attrs = XmlSimple.xml_in response
+			res = []
+			attrs["repository"].each do |repo|
+				options = { "repository_id" => repo["id"].to_i }
+      	res += convert_selectable repo["software"][0], options
+			end
+			res
+    end
+
+    # Search software (package and patterns) in appliance
+    # @param (#to_s) search_string string which is used for search
+    # @param (Hash<#to_s,#to_s>) options optional parameters for search, see api documentation
+    # @return (Array<StudioApi::Package,StudioApi::Pattern>) list of installed packages and patterns
+    def search_software (search_string,options={})
+      request_str = "/appliances/#{id.to_i}/software/search?q=#{CGI.escape search_string.to_s}"
+			options.each do |k,v|
+				request_str << "&#{CGI.escape k.to_s}=#{CGI.escape v.to_s}"
+			end
+      response = GenericRequest.new(self.class.studio_connection).get request_str
+      attrs = XmlSimple.xml_in response
+			res = []
+			attrs["repository"].each do |repo|
+				options = { "repository_id" => repo["id"].to_i }
+      	res += convert_selectable repo["software"][0], options
+			end
+			res
+    end
+
+    # Returns rpm file as String
+    # @param (#to_s) name of rpm
+    # @param (Hash<#to_s,#to_s>) options additional options, see API documentation
+    def rpm_content(name, options={})
+      request_str = "/appliances/#{id.to_i}/cmd/download_package?name=#{CGI.escape name.to_s}"
+      options.each do |k,v|
+        request_str << "&#{CGI.escape k.to_s}=#{CGI.escape v.to_s}"
+      end
+      GenericRequest.new(self.class.studio_connection).get request_str
+    end
+
+    # Select new package to be installed in appliance.
+    #
+    # Dependencies is automatic resolved, but its repository have to be already
+    # included in appliance
+		# @param(#to_s) name of package
+    # @param (Hash<#to_s,#to_s>) options optional parameters for adding packages, see api documentation
+    # @return [Hash<String,String>] return status after software change. It contains
+    #   three keys - state, packages_added and packages_removed
+		def add_package (name, options={})
+			software_command "add_package",{:name => name}.merge(options)
+		end
+
+    # Deselect package from appliance.
+    #
+    # Dependencies is automatic resolved (so unneeded dependencies not installed),
+    # but unused repositories is kept
+		# @param(#to_s) name of package
+    # @return [Hash<String,String>] return status after software change. It contains
+    #   three keys - state, packages_added and packages_removed
+		def remove_package (name)
+			software_command "remove_package",:name => name
+		end
+
+    # Select new pattern to be installed in appliance.
+    #
+    # Dependencies is automatic resolved, but its repositories have to be already
+    # included in appliance
+		# @param(#to_s) name of pattern
+    # @param (Hash<#to_s,#to_s>) options optional parameters for adding patterns, see api documentation
+    # @return [Hash<String,String>] return status after software change. It contains
+    #   three keys - state, packages_added and packages_removed
+		def add_pattern (name, options={})
+			software_command "add_pattern",{:name => name}.merge(options)
+		end
+
+    # Deselect pattern from appliance.
+    #
+    # Dependencies is automatic resolved (so unneeded dependencies not installed),
+    # but unused repositories is kept
+		# @param(#to_s) name of pattern
+    # @return [Hash<String,String>] return status after software change. It contains
+    #   three keys - state, packages_added and packages_removed
+		def remove_pattern (name)
+			software_command "remove_pattern",:name => name
+		end
+
+    # Bans package ( so it cannot be installed even as dependency).
+		# @param(#to_s) name of package
+    # @return [Hash<String,String>] return status after software change. It contains
+    #   three keys - state, packages_added and packages_removed
+		def ban_package(name)
+			software_command "ban_package",:name => name
+		end
+
+    # Unbans package ( so then it can be installed).
+		# @param(#to_s) name of package
+    # @return [Hash<String,String>] return status after software change. It contains
+    #   three keys - state, packages_added and packages_removed
+		def unban_package(name)
+			software_command "unban_package",:name => name
+		end
+
+private
+#internal overwrite of ActiveResource::Base methods
+    def new?
+      false #Appliance has only POST method
+    end
+
+#studio post method for clone is special, as it sometime doesn't have element inside
+    def custom_method_element_url(method_name,options = {})
+      prefix_options, query_options = split_options(options)
+      method_string = method_name.blank? ? "" : "/#{method_name}"
+      "#{self.class.prefix(prefix_options)}#{self.class.collection_name}#{method_string}#{self.class.send :query_string,query_options}"
+    end
+    def self.custom_method_collection_url(method_name,options = {})
+      prefix_options, query_options = split_options(options)
+      "#{prefix(prefix_options)}#{collection_name}#{query_string query_options}"
+    end
+
+    def convert_selectable attrs, preset_options = {}
+      res = []
+      (attrs["pattern"]||[]).each do |pattern|
+        res << create_model_based_on_attrs(Pattern, pattern, preset_options)
+      end
+      (attrs["package"]||[]).each do |package|
+        res << create_model_based_on_attrs( Package, package, preset_options)
+      end
+      res
+    end
+
+#generic factory to create model based on attrs which can be string of hash of options + content which is same as string
+    def create_model_based_on_attrs model, attrs, preset_options
+      case attrs
+      when Hash
+          name = attrs.delete "content"
+          model.new(name, preset_options.merge(attrs))
+      when String
+          model.new(attrs)
+      else
+          raise "Unknown format of element #{model}"
+      end
+    end
+
+		def software_command type, options={}
+      request_str = "/appliances/#{id.to_i}/cmd/#{type}"
+			unless options.empty?
+				first = true
+				options.each do |k,v|
+					separator = first ? "?" : "&"
+					first = false
+					request_str << "#{separator}#{CGI.escape k.to_s}=#{CGI.escape v.to_s}"
+				end
+			end
+      response = GenericRequest.new(self.class.studio_connection).post request_str, options
+      Hash.from_xml(response)["success"]["details"]["status"]
+		end
+  end
+end

data/lib/studio_api/build.rb

@@ -0,0 +1,17 @@
+require "studio_api/studio_resource"
+
+module StudioApi
+  # Represents created build in studio. It allows finding and deleting.
+  # 
+  # @example Delete version 0.0.1 (all types)
+  #   builds = Build.find(:all,:params=>{:appliance_id => 1234})
+  #   versions1 = builds.select { |b| b.version == "0.0.1" }
+  #   versions1.each {|v| v.destroy }
+
+  class Build < ActiveResource::Base
+    extend StudioResource
+
+    self.element_name = "build"
+    undef_method :save
+  end
+end

data/lib/studio_api/connection.rb

@@ -0,0 +1,102 @@
+#
+#  Copyright (c) 2010 Novell, Inc.
+#  All Rights Reserved.
+#
+#  This library is free software; you can redistribute it and/or
+#  modify it under the terms of the GNU Lesser General Public License as
+#  published by the Free Software Foundation; version 2.1 of the license.
+#
+#  This library is distributed in the hope that it will be useful,
+#  but WITHOUT ANY WARRANTY; without even the implied warranty of
+#  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.   See the
+#  GNU Lesser General Public License for more details.
+#
+#  You should have received a copy of the GNU Lesser General Public License
+#  along with this library; if not, contact Novell, Inc.
+#
+#  To contact Novell about this file by physical or electronic mail,
+#  you may find current contact information at www.novell.com
+
+require 'uri'
+require 'openssl'
+require 'studio_api/generic_request'
+
+module StudioApi
+  # Represents information needed for connection to studio.
+  # In common case it is just needed once initialize and then pass it to classes.
+  class Connection
+    # SSL attributes which can be set into ssl attributes. For more details see openssl library
+    SSL_ATTRIBUTES = [ :key, :cert, :ca_file, :ca_path, :verify_mode, :verify_callback, :verify_depth, :cert_store ]
+    # Represents login name for studio API
+    attr_reader :user
+    # Represents API key for studio API
+    attr_reader :password
+    # Represents URI pointing to studio site including path to API
+    # @example
+    #   connection.uri == URI.parse "http://susestudio.com/api/v1/user/"
+    attr_reader :uri
+    # Represents proxy object needed for connection to studio API.
+    # nil represents that no proxy needed
+    attr_reader :proxy
+    # Represents timeout for connection in seconds.
+    attr_reader :timeout
+    # Represents settings for SSL verification in case of uri is https.
+    # It is Hash with keys from SSL_ATTRIBUTES
+    attr_reader :ssl
+
+    # Creates new object
+    # @example
+    #   StudioApi::Connection.new "user","pwd","https://susestudio.com//api/v1/user/",
+    #                             :timeout => 120, :proxy => "http://user:pwd@proxy",
+    #                             :ssl => { :verify_mode => OpenSSL::SSL::VERIFY_PEER,
+    #                                       :ca_path => "/etc/studio.cert"}
+    # @param [String] user login to studio API
+    # @param (String) password API key for studio
+    # @param (String,URI) uri pointing to studio site including path to api
+    # @param (Hash) options hash of additional options. Represents other attributes.
+    # @option options [URI,String] :proxy (nil) see proxy attribute
+    # @option options [String, Fixnum] :timeout (45) see timeout attribute. Specified in seconds
+    # @option options [Hash] :ssl ( {:verify_mode = OpenSSL::SSL::VERIFY_NONE}) see ssl attribute
+    #   
+    def initialize(user, password, uri, options={})
+      @user = user
+      @password = password
+      self.uri = uri
+      self.proxy = options[:proxy] #nil as default is OK
+      @timeout = options[:timeout].to_i || 45
+      @ssl = options[:ssl] || { :verify_mode => OpenSSL::SSL::VERIFY_NONE } # don't verify as default
+    end
+
+    def api_version
+      @version ||= version_detect
+    end
+protected
+    
+    # Overwritte uri object.
+    # @param (String,URI) value new uri to site. If String is passed then it is parsed by URI.parse, which can throw exception
+    def uri=(value)
+      if value.is_a? String
+        @uri = URI.parse value
+      else
+        @uri = value
+      end
+    end
+
+    # Overwritte proxy object.
+    # @param (String,URI,nil) value new proxy to site. If String is passed then it is parsed by URI.parse, which can throw exception. If nil is passed then it means disable proxy.
+    def proxy=(value)
+      if value.is_a? String
+        @proxy = URI.parse value
+      else
+        @proxy = value
+      end
+    end
+
+private
+    def version_detect
+      rq = GenericRequest.new self
+      response = rq.get "/api_version"
+      Hash.from_xml(response)["version"]
+    end
+  end
+end