purest 0.1.0 → 1.0.1

data/lib/purest.rb

@@ -31,7 +31,10 @@ module Purest
   self.root_path = File.expand_path __dir__
   self.lib_path = File.expand_path 'purest', __dir__
 
-  require_libs 'custom_exceptions', 'configuration', 'rest', 'host', 'host_group', 'volume', 'physical_array'
+  require_libs  'rest', 'api_methods', 'configuration', 'alerts', 'app', 'cert',
+                'directory_service', 'dns', 'drive', 'hardware', 'host',
+                'host_group', 'messages', 'network', 'physical_array', 'port',
+                'protection_group', 'snmp', 'subnet', 'users', 'volume'
 
   self.configuration ||= Purest::Configuration.new
 

data/lib/purest/alerts.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module Purest
+  class Alerts < Purest::APIMethods
+    @access_methods = %i[get create update delete]
+
+    GET_PARAMS = [].freeze
+
+    def get(options = nil)
+      super(options, 'alert', GET_PARAMS)
+    end
+
+    def create(options = nil)
+      super(options, 'alert')
+    end
+
+    def update(options = nil)
+      super(options, 'alert')
+    end
+
+    def delete(options = nil)
+      super(options, 'alert')
+    end
+  end
+end

data/lib/purest/api_methods.rb

@@ -0,0 +1,125 @@
+# frozen_string_literal: true
+
+module Purest
+  class APIMethods < Purest::Rest
+    def append_path(url, options)
+      options.each do |path|
+        new_path = path.to_s.gsub('show_', '')
+        url.map! { |u| u + "/#{new_path}" } if !@options.nil? && @options[path]
+      end
+    end
+
+    def get(options = nil, path = nil, params = nil, appended_paths = nil)
+      @options = options
+      create_session unless authenticated?
+
+      raw_resp = @conn.get do |req|
+        url = ["/api/#{Purest.configuration.api_version}/#{path}"]
+
+        # Name is pretty universal, since most endpoints allow you to query
+        # specific items, e.g. /hosts/host1 or /volume/volume1
+        # where host1 and volume1 are names
+        url.map! { |u| u + "/#{@options[:name]}" } if !@options.nil? && @options[:name]
+
+        # Here we append the various paths, based on available GET endpoints
+        append_path(url, appended_paths) unless appended_paths.nil?
+
+        # Generate methods for url building based on
+        # params passed in, e.g. [:pending, :action] becomes
+        # use_pending and use_action
+        params.each do |param|
+          self.class.send(:define_method, :"use_#{param}") do |options|
+            options ? use_named_parameter(param, options[param]) : []
+          end
+        end
+
+        # Generate array, consisting of url parts, to be built
+        # by concat_url method below
+        params.each do |param|
+          url += send(:"use_#{param}", @options)
+        end
+
+        req.url concat_url url
+      end
+
+      JSON.parse(raw_resp.body, symbolize_names: true)
+    end
+
+    # Create a resource, POST
+    # @param options [Hash] options to pass in
+    # @param path [String] the endpoint to send to
+    # @param appended_path [String] additional paths for some endpoints
+    def create(options = nil, path = nil, appended_path = nil)
+      @options = options
+      create_session unless authenticated?
+
+      raw_resp = @conn.post do |req|
+        # Base URL + path
+        url = ["/api/#{Purest.configuration.api_version}/#{path}"]
+
+        # Base URL + path + name, if supplied
+        url.map! { |u| u + "/#{@options[:name]}" } if @options[:name]
+
+        # Base URL + path + appended_path, if supplied
+        url.map! { |u| u + "/#{appended_path}" } if appended_path
+
+        # Turn whatever options we have into JSON
+        req.body = @options.to_json
+
+        # Set the request URL, and finally make the request
+        req.url concat_url url
+      end
+
+      JSON.parse(raw_resp.body, symbolize_names: true)
+    end
+
+    def update(options = nil, path = nil, appended_path = nil)
+      @options = options
+      create_session unless authenticated?
+
+      raw_resp = @conn.put do |req|
+        # Base URL + path
+        url = "/api/#{Purest.configuration.api_version}/#{path}"
+
+        # Base URL + path + name, if supplied
+        url += "/#{@options[:name]}" if @options[:name]
+
+        # Base URL + appended path
+        url += "/#{appended_path}" if appended_path
+
+        # Since :name and :new_name are used the same throughout almost every class
+        # it seems reasonable to do this here
+        @options[:name] = @options.delete(:new_name) if !@options.nil? && @options[:new_name]
+
+        req.body = @options.to_json
+
+        req.url url
+      end
+
+      JSON.parse(raw_resp.body, symbolize_names: true)
+    end
+
+    def delete(options = nil, path = nil, appended_path = nil)
+      @options = options
+
+      raw_resp = @conn.delete do |req|
+        url = "/api/#{Purest.configuration.api_version}/#{path}"
+        url += "/#{@options[:name]}" if @options[:name]
+        url += "/#{appended_path}" if appended_path
+
+        req.url url
+      end
+
+      # Unfortuantely this can't all be done in a single request, so if you
+      # want to eradicate a subsequent request has to be made :(
+      if @options[:eradicate]
+        raw_resp = @conn.delete do |req|
+          req.url "/api/#{Purest.configuration.api_version}/#{path}/#{@options[:name]}"
+          req.body = @options.to_json
+        end
+      end
+
+      JSON.parse(raw_resp.body, symbolize_names: true)
+    end
+  end
+end

data/lib/purest/app.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Purest
+  class App < Purest::APIMethods
+    @access_methods = %i[get]
+
+    GET_PARAMS = [].freeze
+
+    def get(options = nil)
+      super(options, 'app', GET_PARAMS)
+    end
+  end
+end

data/lib/purest/cert.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Purest
+  class Cert < Purest::APIMethods
+    @access_methods = %i[get update]
+
+    GET_PARAMS = %i[certificate common_name country email
+                    intermediate_certificate locality organization
+                    organizational_unit state].freeze
+
+    def get(options = nil)
+      if !options.nil? && options[:csr]
+        super(options, 'cert/certificate_signing_request', GET_PARAMS)
+      else
+        super(options, 'cert', GET_PARAMS)
+      end
+    end
+
+    def update(options = nil)
+      super(options, 'cert')
+    end
+  end
+end

data/lib/purest/directory_service.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Purest
+  class DirectoryService < Purest::APIMethods
+    @access_methods = %i[get update]
+
+    GET_PARAMS = %i[certificate groups].freeze
+
+    def get(options = nil)
+      super(options, 'directoryservice', GET_PARAMS)
+    end
+
+    def update(options = nil)
+      super(options, 'directoryservice')
+    end
+  end
+end

data/lib/purest/dns.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Purest
+  class DNS < Purest::APIMethods
+    @access_methods = %i[get update]
+
+    GET_PARAMS = [].freeze
+
+    def get(options = nil)
+      super(options, 'dns', GET_PARAMS)
+    end
+
+    def update(options = nil)
+      super(options, 'dns')
+    end
+  end
+end

data/lib/purest/drive.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Purest
+  class Drive < Purest::APIMethods
+    @access_methods = %i[get]
+
+    GET_PARAMS = [].freeze
+
+    def get(options = nil)
+      super(options, 'drive', GET_PARAMS)
+    end
+  end
+end

data/lib/purest/hardware.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Purest
+  class Hardware < Purest::APIMethods
+    @access_methods = %i[get update]
+
+    GET_PARAMS = [].freeze
+
+    def get(options = nil)
+      super(options, 'hardware', GET_PARAMS)
+    end
+
+    def update(options = nil)
+      super(options, 'hardware')
+    end
+  end
+end

data/lib/purest/host.rb

@@ -1,89 +1,42 @@
 # frozen_string_literal: true
 
 module Purest
-  class Host < Purest::Rest
+  class Host < Purest::APIMethods
     @access_methods = %i[get create update delete]
 
-    GET_PARAMS = [:action, :all, :chap, :connect, :names, :personality,
-                  :private, :protect, :shared, :space]
+    GET_PARAMS = %i[action all chap connect names personality
+                    private protect shared space].freeze
 
     # Get a list of hosts, GET
     # @param options [Hash] options to pass
     def get(options = nil)
-      @options = options
-      create_session unless authenticated?
-
-      raw_resp = @conn.get do |req|
-        url = ["/api/#{Purest.configuration.api_version}/host"]
-        url.map!{|u| u + "/#{@options[:name]}"} if !@options.nil? && @options[:name]
-        url.map!{|u| u + "/volume"} if !@options.nil? && @options[:show_volumes]
-
-        # Generate array, consisting of url parts, to be built
-        # by concat_url method below
-        GET_PARAMS.each do |param|
-          url += self.send(:"use_#{param}",@options)
-        end
-
-        # Build url from array of parts, send request
-        req.url concat_url url
-      end
-
-      JSON.parse(raw_resp.body, :symbolize_names => true)
+      super(options, 'host', GET_PARAMS, [:show_volume])
     end
 
-    # Create a host, POST
-    # @param options [Hash] options to pass
     def create(options = nil)
-      @options = options
-
-      raise RequiredArgument, ':name required when creating a host' if @options.nil? || @options[:name].nil?
-      create_session unless authenticated?
-
-      raw_resp = @conn.post do |req|
-        url = ["/api/#{Purest.configuration.api_version}/host/#{@options[:name]}"]
-        url.map!{|u| u + "/pgroup/#{@options[:protection_group]}"} if @options[:protection_group]
-        url.map!{|u| u + "/volume/#{@options[:volume]}"} if @options[:volume]
-        req.body = @options.to_json
-
-        req.url concat_url url
+      # The API doesn't accept some of these options in the HTTP body
+      # during a POST, so we remove them from the options hash after
+      # creating a path to append to the base URL in APIMethods.create
+      if options[:name] && options[:volume]
+        appended_path = "#{options.delete(:name)}/volume/#{options.delete(:volume)}"
+      elsif options[:name] && options[:protection_group]
+        appended_path = "#{options.delete(:name)}/pgroup/#{options.delete(:protection_group)}"
       end
-
-      JSON.parse(raw_resp.body, :symbolize_names => true)
+      super(options, 'host', appended_path)
     end
 
-    # Update a host, PUT
-    # @param options [Hash] options to pass
     def update(options = nil)
-      @options = options
-
-      create_session unless authenticated?
-
-      raw_resp = @conn.put do |req|
-        req.url "/api/#{Purest.configuration.api_version}/host/#{@options[:name]}"
-
-        # Repurpose @options[:name] so that it is now set to the new_name
-        # allowing us to rename a volume.
-        @options[:name] = @options.delete(:new_name) if @options[:new_name]
-        req.body = @options.to_json
-      end
-
-      JSON.parse(raw_resp.body, :symbolize_names => true)
+      super(options, 'host')
     end
 
     def delete(options = nil)
-      @options = options
-
-      create_session unless authenticated?
-
-      raw_resp = @conn.delete do |req|
-        url = ["/api/#{Purest.configuration.api_version}/host/#{@options[:name]}"]
-        url.map!{|u| u + "/pgroup/#{@options[:protection_group]}"} if @options[:protection_group]
-        url.map!{|u| u + "/volume/#{@options[:volume]}"} if @options[:volume]
-
-        req.url concat_url url
+      if options[:name] && options[:volume]
+        appended_path = "#{options.delete(:name)}/volume/#{options.delete(:volume)}"
+      elsif options[:name] && options[:protection_group]
+        appended_path = "#{options.delete(:name)}/pgroup/#{options.delete(:protection_group)}"
       end
 
-      JSON.parse(raw_resp.body, :symbolize_names => true)
+      super(options, 'host', appended_path)
     end
 
     private

data/lib/purest/host_group.rb

@@ -1,90 +1,49 @@
 # frozen_string_literal: true
-#
+
 module Purest
-  class HostGroup < Purest::Rest
+  class HostGroup < Purest::APIMethods
     @access_methods = %i[get create update delete]
 
-    GET_PARAMS = [:action, :block_size, :connect, :historical, :length, :names,
-                  :pending, :pending_only, :pgrouplist, :private, :protect,
-                  :shared, :snap, :space]
+    GET_PARAMS = %i[action block_size connect historical length names
+                    pending pending_only pgrouplist private protect
+                    shared snap space].freeze
 
     # Get a list of hostgroups, GET
     # @param options [Hash] options to pass in
     def get(options = nil)
-      @options = options
-      create_session unless authenticated?
-
-      raw_resp = @conn.get do |req|
-        url = ["/api/#{Purest.configuration.api_version}/hgroup"]
-        url.map!{|u| u + "/#{@options[:name]}"} if !@options.nil? && @options[:name]
-        url.map!{|u| u + "/volume"} if !@options.nil? && @options[:name] && @options[:show_volumes]
-
-        # Generate array, consisting of url parts, to be built
-        # by concat_url method below
-        GET_PARAMS.each do |param|
-          url += self.send(:"use_#{param}",@options)
-        end
-
-        req.url concat_url url
-      end
-
-      JSON.parse(raw_resp.body, :symbolize_names => true)
+      super(options, 'hgroup', GET_PARAMS, [:show_volume])
     end
 
     def create(options = nil)
-      @options = options
-      create_session unless authenticated?
-
-      raw_resp = @conn.post do |req|
-        url = ["/api/#{Purest.configuration.api_version}/hgroup/#{@options[:name]}"]
-        url.map!{|u| u + "/pgroup/#{@options[:protection_group]}"} if @options[:protection_group]
-        url.map!{|u| u + "/volume/#{@options[:volume]}"} if @options[:volume]
-
-        req.body = @options.to_json
-        req.url concat_url url
+      # The API doesn't accept some of these options in the HTTP body
+      # during a POST, so we remove them from the options hash after
+      # creating a path to append to the base URL in APIMethods.create
+      if options[:name] && options[:volume]
+        appended_path = "#{options.delete(:name)}/volume/#{options.delete(:volume)}"
+      elsif options[:name] && options[:protection_group]
+        appended_path = "#{options.delete(:name)}/pgroup/#{options.delete(:protection_group)}"
       end
-
-      JSON.parse(raw_resp.body, :symbolize_names => true)
+      super(options, 'hgroup', appended_path)
     end
 
-    # Update a host group, PUT
-    # @param options [Hash] options to pass
     def update(options = nil)
-      @options = options
-
-      create_session unless authenticated?
-
-      raw_resp = @conn.put do |req|
-        req.url "/api/#{Purest.configuration.api_version}/hgroup/#{@options[:name]}"
-
-        # Repurpose @options[:name] so that it is now set to the new_name
-        # allowing us to rename a volume.
-        @options[:name] = @options.delete(:new_name) if @options[:new_name]
-        req.body = @options.to_json
-      end
-
-      JSON.parse(raw_resp.body, :symbolize_names => true)
+      super(options, 'hgroup')
     end
 
     # Delete a host group, DELETE
     # @param options[Hash] options to pass
     def delete(options = nil)
-      @options = options
-
-      create_session unless authenticated?
-
-      raw_resp = @conn.delete do |req|
-        url = ["/api/#{Purest.configuration.api_version}/hgroup/#{@options[:name]}"]
-        url.map!{|u| u + "/pgroup/#{@options[:protection_group]}"} if @options[:protection_group]
-        url.map!{|u| u + "/volume/#{@options[:volume]}"} if @options[:volume]
-
-        req.url concat_url url
+      if options[:name] && options[:volume]
+        appended_path = "#{options.delete(:name)}/volume/#{options.delete(:volume)}"
+      elsif options[:name] && options[:protection_group]
+        appended_path = "#{options.delete(:name)}/pgroup/#{options.delete(:protection_group)}"
       end
 
-      JSON.parse(raw_resp.body, :symbolize_names => true)
+      super(options, 'hgroup', appended_path)
     end
 
     private
+
     # Dynamic method generation, e.g. use_all, use_action, etc
     GET_PARAMS.each do |param|
       define_method :"use_#{param}" do |options|