ultravault 1.0.2.0

data/.gitignore

@@ -0,0 +1,15 @@
+coverage/
+doc/
+Gemfile.lock
+old/
+pkg/
+*.gem
+*.rbc
+.DS_Store
+.bundle
+.rvmrc
+Gemfile.lock
+.yardoc/checksums
+.yardoc/objects/root.dat
+.yardoc/proxy_types
+.yardopts

data/Gemfile

@@ -0,0 +1,2 @@
+source :rubygems
+gemspec

data/README.md

@@ -0,0 +1,88 @@
+# UltraVault
+
+A simple wrapper gem for the UltraVault API allowing users to retrieve information about their agents, disk safes and recovery points.
+
+## Installing with Bundler
+
+Add this to your Gemfile:
+
+```ruby
+gem 'ultravault', :git => "git@github.com:melbourne/ultravault.git", :branch => :master
+```
+
+Run
+
+    $ bundle install
+
+## Intended usage
+
+See test/integration/client_code.rb for an executable example.
+
+### Inclusion
+
+```ruby   
+require 'ultravault'
+```            
+
+### Configure
+
+```ruby   
+UltraVault.configure do |config|
+   config.host = 'foo.bar.baz'
+   config.port = 9080
+   config.api_version = 1
+   config.ssl = false
+   config.username = 'foo'
+   config.password = 'bar'
+   config.debug = false
+end   
+```
+
+or
+
+```ruby   
+UltraVault.config = { host: 'baz.bar.foo' }
+```
+ 
+### Retrieving data
+
+```ruby   
+# Retrieving an agent
+agent = UltraVault::Agent.find_by_id("e9bd701b-dac1-4921-ab1c-467f35209e21")
+
+# Retrieve all agents
+agents = UltraVault::Agent.all
+
+# Retrieving a disk safe
+disk_safe = agent.disk_safes.first
+
+# Retrieving recovery points
+recovery_point = disk_safe.recovery_points.first  
+```
+
+### Creating, editing, removing objects
+
+```ruby
+# Creating an agent
+agent = UltraVault::Agent.create(
+          :hostname => 'foo', :port_number => 1234,
+          :description => 'A new agent',
+          :os_type => 'linux'
+        )
+
+# Updating an agent
+updated_agent = agent.update(:hostname => 'bazbar')
+
+# Deleting an agent
+destroyed_agent = agent.destroy
+```
+
+## Authoring changes
+
+### Testing
+
+Make sure you run the test suite in full before pushing changes. Write new tests as you add new features.
+
+    $ rake unit        # run unit tests
+    $ rake integration # run integration tests
+

data/Rakefile

@@ -0,0 +1,17 @@
+require 'bundler'
+Bundler::GemHelper.install_tasks
+
+require 'rake/testtask'
+
+Rake::TestTask.new("unit") do |t|
+  t.libs << 'test'
+  t.pattern = "#{File.dirname(__FILE__)}/test/all.rb"
+end
+
+Rake::TestTask.new("integration") do |t|
+  t.libs << 'test'
+  t.pattern = "#{File.dirname(__FILE__)}/test/integration/client_code.rb"
+end
+
+desc "Run tests"
+task :default => :unit

data/lib/ultravault.rb

@@ -0,0 +1,17 @@
+module UltraVault
+
+  require 'savon'
+  require 'ostruct'
+  require_relative "ultravault/config"
+  
+  autoload :Agent,                "ultravault/data_objects/agent"
+  autoload :AgentService,         "ultravault/soap_service/agent_service"
+  autoload :ApiRequest,           "ultravault/api_request"
+  autoload :Client,               "ultravault/client"
+  autoload :DiskSafe,             "ultravault/data_objects/disk_safe"
+  autoload :DiskSafeService,      "ultravault/soap_service/disk_safe_service"
+  autoload :RecoveryPoint,        "ultravault/data_objects/recovery_point" 
+  autoload :RecoveryPointService, "ultravault/soap_service/recovery_point_service" 
+  autoload :SoapService,          "ultravault/soap_service"
+  
+end

data/lib/ultravault/api_request.rb

@@ -0,0 +1,26 @@
+module UltraVault
+  # @private  
+  class ApiRequest
+    def initialize(params)
+      @host = params[:host]
+      @port = params[:port]
+      @service = params[:service]
+      @ssl = params.fetch(:ssl) { true }
+    end
+    
+    def endpoint
+      "#{protocol}://#{@host}:#{@port}/#{@service}"
+    end
+    
+    def namespace
+      "http://#{@service.downcase}.api.server.backup.r1soft.com/"
+    end
+    
+    private
+    
+    def protocol
+      @ssl ? "https" : "http"
+    end
+  end
+  
+end

data/lib/ultravault/client.rb

@@ -0,0 +1,19 @@
+module UltraVault
+  # @private
+  class Client
+    def initialize(params)
+      
+      @client = Savon::Client.new do
+        wsdl.endpoint = params[:endpoint] 
+        wsdl.namespace = params[:namespace]
+        http.auth.basic params[:username], params[:password]
+      end
+    end
+    
+    def request(action, args={})
+      @client.request action, :body => args
+    end
+  end
+  
+end
+

data/lib/ultravault/config.rb

@@ -0,0 +1,55 @@
+module UltraVault
+  def self.configure
+    yield(config)
+  end
+  
+  def self.config
+    @config ||= Config.new
+  end
+  
+  def self.config=(hash)
+    self.config.update(hash)
+  end
+  
+  private
+  
+  class Config
+    attr_accessor :host, :port, :api_version,
+                  :ssl, :username, :password,
+                  :debug
+
+    def initialize(params={})
+      params = defaults.merge(params)
+      update(params)
+    end
+
+    def update(params)
+      params.each do |k,v|
+        instance_variable_set("@#{k}", v)
+      end
+      set_debug(@debug)
+    end
+    
+    def debug=(state)
+      set_debug(state) 
+    end
+    
+    def set_debug(state)
+      Savon.configure do |config| 
+        config.log = state
+        HTTPI.log = state
+      end
+      @debug = state
+    end
+    
+    private
+    
+    def defaults
+      { 
+        host: '', port: 0, api_version: 1,
+        ssl: false, username: '', password:'',
+        debug: false
+      }
+    end
+  end 
+end

data/lib/ultravault/data_objects/agent.rb

@@ -0,0 +1,104 @@
+module UltraVault
+  class Agent < OpenStruct
+    attr_reader :description, :hostname, :id, :os_type, :port_number
+    
+    def initialize(params)
+      @description = params[:description]
+      @hostname = params[:hostname]
+      @id = params[:id]
+      @os_type = params[:os_type]
+      @port_number = params[:port_number]
+      super(params)
+    end
+
+    # Disksafes belonging to this agent.
+    # 
+    # @return [[UltraVault::DiskSafe]] disk safes for this agent
+    # @raise [Savon::SOAP::Fault] errors from the soap transaction    
+    def disk_safes
+      @disk_safes ||= UltraVault::DiskSafe.find_all_by_agent_id(id)
+    end
+    
+    # Returns an agent, if found.
+    # 
+    # @param [String] agent_id the UUID of the agent 
+    # @return [UltraVault::Agent] the agent matching the agent_id
+    # @raise [Savon::SOAP::Fault] errors from the soap transaction
+    def self.find_by_id(agent_id)
+      UltraVault::AgentService.new.find_agent_by_id(agent_id)
+    end
+
+    # Returns all agents for the current user.
+    # 
+    # @return [[UltraVault::Agent]] current user's agents
+    # @raise [Savon::SOAP::Fault] errors from the soap transaction    
+    def self.all
+      UltraVault::AgentService.new.all_agents
+    end
+    
+    # Returns a newly created agent with the given params.
+    #
+    # @return [UltraVault::Agent] new agent
+    # @raise [Savon::SOAP::Fault] errors from the soap transaction
+    def self.create(params)
+      Agent.check_params_strict(params)
+      UltraVault::AgentService.new.create_agent(params)
+    end
+    
+    # Update the current agent
+    #
+    # @return [UltraVault::Agent] updated agent
+    # @raise [Savon::SOAP::Fault] errors from the soap transaction
+    def update(params)
+      Agent.check_params(params)
+      self.marshal_load(self.marshal_dump.merge(params))
+      UltraVault::AgentService.new.update_agent(self.marshal_dump)
+    end
+    
+    # Destroy the current agent
+    # @ return [UltraVault::Agent] deleted agent
+    # @raise [Savon::SOAP::Fault] errors from the soap transaction
+    def destroy
+      UltraVault::AgentService.new.destroy_agent(self.id)
+      self
+    end
+
+    class << self
+    
+      USAGE = "Valid arguments - :hostname, :port_number, :description, :os_type"
+      USE_ALL = "All arguments required."
+      REQUIRED_PARAMS = [:hostname, :port_number, :description, :os_type]
+    
+      def check_params(params)
+        do_check_params(false, params)
+      end
+    
+      def check_params_strict(params)
+        do_check_params(true, params)
+      end
+    
+      def do_check_params(strict, params)
+        check_params_are_legal(params)
+        check_all_params_are_present(params) if strict
+        true
+      end
+    
+      def check_params_are_legal(params)
+        params.keys.each do |key|
+          unless REQUIRED_PARAMS.include?(key)
+            raise ArgumentError.new(USAGE)
+          end
+        end
+      end
+    
+      def check_all_params_are_present(params)
+        REQUIRED_PARAMS.each do |key|
+          unless params.keys.include?(key)
+            raise ArgumentError.new("#{USAGE}. #{USE_ALL}") 
+          end
+        end
+      end
+    end
+    
+  end
+end

data/lib/ultravault/data_objects/disk_safe.rb

@@ -0,0 +1,64 @@
+module UltraVault
+  class DiskSafe < OpenStruct
+    attr_reader :agent_id, :compression_level, :compression_type,
+                  :description, :device_count, :device_list,
+                  :id, :open, :recovery_point_count,
+                  :volume_id, :size, :size_of_deltas
+    
+    def initialize(params)
+      @agent_id = params[:agent_id]
+      @compression_level = params[:compression_level]
+      @compression_type = params[:compression_type]
+      @description = params[:description]
+      @device_count = params[:device_count].to_i
+      @device_list = [params[:device_list]].flatten.collect do |device| 
+        DeviceList.new(device)
+      end
+      @id = params[:id]      
+      @open = params[:open]                        
+      @recovery_point_count = params[:recovery_point_count].to_i
+      @size = params[:size].to_i  
+      @size_of_deltas = params[:size_of_deltas_in_disk_safe].to_i
+      @volume_id = params[:volume_id]
+      extract_attributes params[:disk_safe_attribute_map]
+    end
+    
+    def recovery_points
+      @recovery_points ||= UltraVault::RecoveryPointService.new.find_recovery_points_by_disk_safe_id(id)
+    end
+    
+    # Returns an array of disk safes, if found.
+    # 
+    # @param [String] agent_id the UUID of the agent 
+    # @return [[UltraVault::DiskSafe]] the matching disk safes for the agent
+    # @raise [Savon::SOAP::Fault] errors from the soap transaction
+    def self.find_all_by_agent_id(agent_id)
+      UltraVault::DiskSafeService.new.find_disksafes_by_agent_id agent_id
+    end                      
+  
+  private
+  
+    def extract_attributes(params)
+      params[:entry].each do |entry|
+        self.instance_variable_set "@#{entry[:key]}".downcase.to_sym, entry[:value]
+        self.class.send(:attr_reader, entry[:key].downcase.to_sym)
+      end
+    end
+  
+    class DeviceList
+      attr_reader :content_type, :path, :enabled,
+                  :mount_point, :mounted, :capacity
+      
+      def initialize(params)
+        @capacity = params[:capacity].to_i
+        @content_type = params[:device_content_type]
+        @path = params[:device_path] 
+        @enabled = params[:enabled]
+        @mount_point = params[:mount_point]
+        @mounted = params[:mounted]
+      end
+      
+      
+    end
+  end
+end

data/lib/ultravault/data_objects/recovery_point.rb

@@ -0,0 +1,24 @@
+module UltraVault
+  class RecoveryPoint < OpenStruct
+    attr_reader :agent_id, :created_at, :disk_safe_id,
+                  :id, :state
+    
+    def initialize(params)
+      @agent_id = params[:agent_id]
+      @created_at = Time.at(params[:created_on_timestamp_in_millis].to_i / 1000.0)
+      @disk_safe_id = params[:disk_safe_id]
+      @id = params[:recovery_point_id]
+      @state = params[:recovery_point_state].downcase
+    end
+    
+    # Returns an array of recovery points, if found.
+    # 
+    # @param [String] disk_safe_id the UUID of the disk safe
+    # @return [[UltraVault::RecoveryPoint]] the matching recovery points for the agent
+    # @raise [Savon::SOAP::Fault] errors from the soap transaction    
+    def self.find_all_by_disk_safe_id(disk_safe_id)
+      UltraVault::RecoveryPointService.new.find_recovery_points_by_disk_safe_id(disk_safe_id)
+    end
+    
+  end
+end