purest 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: '0061492805748e646a06d9f5077446336d985ea40ff8ed76a3f9a5d8b60ff74d'
+  data.tar.gz: f58236ea14ff460b5698f0f348540c8c7fe87db762200fd37e8cb7ccfea3f505
+SHA512:
+  metadata.gz: e51d88129e1f4807334c14ee3f9787e79bbcce33254dc83fa21450d63d67f1cdf3a687b84210df13b5eb5fad51ee5d30de71a2149e7e59672243036e287f0cea
+  data.tar.gz: c5f9532c491299d10b1c8e7add8bcefe1905534ca6496f84a5cf7ac5450726e2175d7fa6bdf8530e6da5cf761e61447273c623b8562c09313546a5817314dcac

data/README.md

@@ -0,0 +1,284 @@
+# Purest (or Pure Rest, if you will) -- a simple gem for interacting with Pure Storage's REST API
+
+A simple to use library for Ruby, inspired by the WeAreFarmGeek's Diplomat gem (seriously, those guys are awesome), allowing for easy interaction with Pure Storage's REST API.
+
+## Disclaimer
+This started as sort of a labor of love/learning exercise, and sort of blossomed into this. That being said, it means a few things:
+
+1) I may have made some stupid mistakes in here, if so..so be it. Raise them in issues or submit PRs, and I'll gladly fix/merge if I feel the code submitted carries the spirit of my little project. Odds are I won't reject a PR unless you try to rewrite everything for some obtuse reason I don't agree with.
+
+2) I am not affiliated with Pure Storage, beyond the fact that my company uses their product.
+
+3) This isn't done. What I think of as the 'core' functionality is there- you can manipulate volumes, hosts, and host groups, along with the array itself. I still need to add in classes for ProtectionGroups, Alerts/Messages, SNMP Manager Connections, SSL, Network Interfaces, Hardware, Apps, and Users.
+
+## Requirements
+
+To be captain obvious, this does require you have access to a Pure Storage array.
+
+This library requires you use Ruby 2.3 or above.
+
+# Usage
+
+## Configuration
+
+```
+require 'purest'
+
+Purest.configure do |config|
+  config.url = "https://purehost.yourdomain.com"
+  config.options = {ssl: { verify: true }}
+  config.api_version = '1.11'
+  config.username = 'api-enabled-user'
+  config.password = 'password'
+end
+```
+
+## API options
+The various class methods of this gem turn the provided options into HTTP parameters, and are
+named accordingly. For instance, ```Purest::Volume.get({:snap => true})``` translates
+to http://purehost.yourdomain.com/api/1.11/volume?snap=true. For a full list
+of options for a given class, Pure provides good documentation at:
+https://purehost.yourdomain.com/static/0/help/rest/.
+
+Below I'll provide a large group of examples, but I won't be detailing every single method call with all of its possible options, for that I will again refer you to Pure's REST API docs.
+
+# Examples
+## Volumes
+Getting volumes:
+```ruby
+# Get the full list of volumes
+Purest::Volume.get
+
+# Get a single volume
+Purest::Volume.get(:name => 'volume1')
+
+# Get monitoring information about a volume
+Purest::Volume.get(:name => 'volume1', :action => 'monitor')
+
+# Get multiple volumes
+Purest::Volume.get(:names => ['volume1', 'volume2'])
+
+# Get a list of snapshots
+Purest::Volume.get(:snap => true)
+
+# Get a single snapshot
+Purest::Volume.get(:name => 'volume1', :snap => true)
+
+# Get multiple snapshots
+Purest::Volume.get(:names => ['volume1', 'volume2'], :snap => true)
+
+# List block differences for the specified snapshot
+Purest::Volume.get(:name => 'volume1.snap', :show_diff => true, :block_size => 512, :length => '2G')
+
+# List shared connections for a specified volume
+Purest::Volume.get(:name => 'volume1', :show_hgroup => true)
+
+# List private connections for a specified volume
+Purest::Volume.get(:name => 'volume1', :show_host => true)
+```
+
+Creating volumes:
+
+```ruby
+# Creating a new volume
+Purest::Volume.create(:name => 'volume', :size => '10G')
+
+# Creating a new volume by copying another
+Purest::Volume.create(:name => 'volume, ':source => 'other_vol')
+
+# Overwriting a volume by copying another
+Purest::Volume.create(:name => 'volume', :source => 'other_vol', :overwrite => true)
+
+# Add a volume to a protection group
+Purest::Volume.create(:name => 'volume', :pgroup => 'protection-group')
+```
+
+Updating volumes
+```ruby
+# Growing a volume
+Purest::Volume.update(:name => 'volume', :size => "15G")
+
+# Truncate (shrink) a volume
+Purest::Volume.update(:name => 'volume', :size => "10G", :truncate => true)
+
+# Rename a volume
+Purest::Volume.update(:name => 'volume', :new_name => 'volume_renamed')
+```
+
+Deleting volumes
+
+```ruby
+# Delete a volume
+Purest::Volume.delete(:name => 'volume_to_delete')
+
+# Eradicating a volume
+Purest::Volume.delete(:name => 'volume_to_delete', :eradicate => true)
+
+# Deleting a volume from a protection group
+Purest::Volume.delete(:name => 'volume', :pgroup => 'pgroup1')
+```
+
+## Hosts
+Getting hosts:
+```ruby
+# Get a list of all the hosts on an array
+Purest::Host.get
+
+# Get a list of hosts with performance data
+Purest::Host.get(:action => 'monitor')
+
+# Get a single host on an array
+Purest::Host.get(:name => 'host123')
+
+# Get a list of hosts, by name, on an array
+Purest::Host.get(:names => ['host123', 'host456'])
+```
+
+Creating hosts:
+```ruby
+# Create a host
+Purest::Host.create({:name => 'host123'})
+
+# Create a host and set ISCSI IQNs
+Purest::Host.create(:name => 'host123', :iqnlist => ['iqnstuff-1', 'iqnstuff-2'])
+
+# Add a host to a protection group
+Purest::Host.create(:name => 'host123', :protection_group => 'pgroup123')
+
+# Connect a volume to a host
+Purest::Host.create(:name => 'host123', :volume => 'volume123')
+```
+
+Updating hosts:
+```ruby
+# Rename a host
+Purest::Host.update(:name => 'host123', :new_name => 'host456')
+
+# Set the host username/password for CHAP
+Purest::Host.update(:name => 'host123', :host_user => 'username', :host_password => 'supersecretpassword')
+```
+
+Deleting hosts:
+```ruby
+# Delete a host
+Purest::Host.delete(:name => 'host123')
+
+# Remove a host from a protection group
+Purest::Host.delete(:name => 'host123', :protection_group => 'pgroup123')
+
+# Remove the connection between a host and a volume
+Purest::Host.delete(:name => 'host123', :volume => 'volume123')
+```
+
+# Physical Arrays
+
+List the attributes on an array:
+```ruby
+# List all the attributes
+Purest::PhysicalArray.get
+
+# List connected arrays
+Purest::PhysicalArray.get(:connection => true)
+```
+
+Create a connection between two arrays:
+```ruby
+Purest::PhysicalArray.create(:connection_key => '<key>', :management_address => 'hostname', :type => ['replication'])
+```
+
+Update the attributes on an array:
+```ruby
+# rename an array
+Purest::PhysicalArray.update(:new_name => 'new_name')
+```
+
+Disconnect the current array from a specified array:
+```ruby
+# Given that your pure is purehost.yourdomain.com, as defined in the config block above
+# Disconnect purehost2.yourdomain.com from yours
+Purest::PhysicalArray.delete(:name => 'purehost2.yourdomain.com')
+```
+
+# Host Groups
+Getting information about host groups
+```ruby
+# Get a list of host groups
+Purest::HostGroup.get
+
+# Get a single host group
+Purest::HostGroup.get(:name => 'hgroup1')
+
+# Get a list of host groups, with monitoring information
+Purest::HostGroup.get(:names => ['hgroup1', 'hgroup2'], :action => 'monitor')
+
+# Get a list of volumes associated with a specified host
+Purest::HostGroup.get(:name => 'hgroup1', :show_volumes => true)
+```
+
+Creating host groups
+```ruby
+# Create a host group with a specified name
+Purest::HostGroup.create(:name => 'hgroup1')
+
+# Create a host group and supply its host members
+Purest::HostGroup.create(:name => 'hgroup1', :hostlist => ['host1', 'host2'])
+
+# Add a host group to a protection group
+Purest::HostGroup.create(:name => 'hgroup1', :protection_group => 'pgroup1')
+
+# Connect a volume to all hosts in a specified host group
+Purest::HostGroup.create(:name => 'hgroup1', :volume => 'v3')
+```
+
+Updating host groups
+```ruby
+# Renaming a host group
+Purest::HostGroup.update(:name => 'hgroup1', :new_name => 'hgroup1-renamed')
+
+# Replace the list of member hosts
+Purest::HostGroup.update(:name => 'hgroup1', :hostlist => ['host1', 'host2'])
+
+# Add a list of hosts to existing host list
+Purest::HostGroup.update(:name => 'hgroup1', :addhostlist => ['host3', 'host4'])
+
+# Remove a list of hosts from a host list
+Purest::HostGroup.update(:name => 'hgroup1', :remhostlist => ['host1'])
+```
+
+Deleting host groups
+```ruby
+# Delete a host group
+Purest::HostGroup.delete(:name => 'hgroup1')
+
+# Remove a host group member from a protection group
+Purest::HostGroup.delete(:name => 'hgroup1', :protection_group => 'pgroup1')
+
+# Break the connection between a host group and a volume
+Purest::HostGroup.delete(:name => 'hgroup1', :volume => 'volume1')
+```
+
+# Specs
+This library is tested with rspec, to execute the specs merely run
+```
+rspec
+```
+
+This project also supports an integration test suite. However, you must have API access to a pure array for this integration test suite to work.
+
+Create an .integration.yaml inside the project, containing your pure array URL and credentials like so:
+```
+$ cat ~/ruby/purest/.integration.yaml
+---
+username: 'api-user'
+password: 'api-password'
+url: 'https://yoursuperawesomepurehost.com'
+```
+
+Execute integration tests:
+```
+rspec -t integration
+```
+
+By default, this will run against version 1.1 to 1.11 of the API. This is useful for ensuring functionality added/subtracted to this project is programmatically tested against all versions of the API. I mostly did this as an exercise, that being said I think it provides a lot of usefulness and if it can be improved let me know (or submit a PR).
+
+It is worth mentioning, this generates a fair bit of work for your Pure array so...you've been warned.

data/lib/purest.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+require 'time'
+require 'json'
+require 'faraday'
+require 'faraday_middleware'
+require 'faraday-cookie_jar'
+require 'pry'
+require 'psych'
+
+module Purest
+  class << self
+    attr_accessor :root_path
+    attr_accessor :lib_path
+    attr_accessor :configuration
+
+    # Internal: Requires internal Faraday libraries.
+    # @param *libs One or more relative String names to Faraday classes.
+    # @return [nil]
+    def require_libs(*libs)
+      libs.each do |lib|
+        require "#{lib_path}/#{lib}"
+      end
+    end
+
+    alias require_lib require_libs
+  end
+
+  raise 'Purest only supports ruby >= 2.3.0' unless RUBY_VERSION.to_f >= 2.3
+
+  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'
+
+  self.configuration ||= Purest::Configuration.new
+
+  class << self
+    # Build optional configuration by yielding a block to configure
+    # @yield [Purest::Configuration]
+    def configure
+      self.configuration ||= Purest::Configuration.new
+      yield(configuration)
+    end
+  end
+end

data/lib/purest/configuration.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module Purest
+  # Methods for configuring Purest
+  class Configuration
+    attr_accessor :api_version, :url, :username, :password, :options
+
+    # Override defaults for configuration
+    # @param api_version [String] the API version to interact with
+    # @param url [String] pure's connection URL
+    # @param username [String] username to authenticate with
+    # @param password [String] password to authenticate with
+    # @param options [Hash] extra options to configure Faraday::Connection
+    def initialize(api_version = '1.11', url = nil, username = nil, password = nil, options = {})
+      @api_version = api_version
+      @url = url
+      @username = username
+      @password = password
+      @options = options
+    end
+  end
+end

data/lib/purest/custom_exceptions.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module Purest
+  class CustomExceptions
+    class ConflictingArguments < StandardError
+    end
+
+    class RequiredArgument < StandardError
+    end
+
+    class ArgumentMismatch < StandardError
+    end
+  end
+end

data/lib/purest/host.rb

@@ -0,0 +1,98 @@
+# frozen_string_literal: true
+
+module Purest
+  class Host < Purest::Rest
+    @access_methods = %i[get create update delete]
+
+    GET_PARAMS = [:action, :all, :chap, :connect, :names, :personality,
+                  :private, :protect, :shared, :space]
+
+    # 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)
+    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
+      end
+
+      JSON.parse(raw_resp.body, :symbolize_names => true)
+    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)
+    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
+      end
+
+      JSON.parse(raw_resp.body, :symbolize_names => true)
+    end
+
+    private
+
+    # Dynamic method generation, e.g. use_all, use_action, etc
+    GET_PARAMS.each do |param|
+      define_method :"use_#{param}" do |options|
+        options ? use_named_parameter(param, options[param]) : []
+      end
+    end
+  end
+end

data/lib/purest/host_group.rb

@@ -0,0 +1,95 @@
+# frozen_string_literal: true
+#
+module Purest
+  class HostGroup < Purest::Rest
+    @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 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)
+    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
+      end
+
+      JSON.parse(raw_resp.body, :symbolize_names => true)
+    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)
+    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
+      end
+
+      JSON.parse(raw_resp.body, :symbolize_names => true)
+    end
+
+    private
+    # Dynamic method generation, e.g. use_all, use_action, etc
+    GET_PARAMS.each do |param|
+      define_method :"use_#{param}" do |options|
+        options ? use_named_parameter(param, options[param]) : []
+      end
+    end
+  end
+end

data/lib/purest/physical_array.rb

@@ -0,0 +1,110 @@
+# frozen_string_literal: true
+
+module Purest
+  class PhysicalArray < Purest::Rest
+    @access_methods = %i[get create update delete]
+
+    GET_PARAMS = [:action, :banner, :connection_key, :controllers, :historical,
+      :idle_timeout, :ntpserver, :phonehome, :proxy, :relayhost, :scsi_timeout,
+      :senderdomain, :space, :syslogserver, :throttle]
+
+    # 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}/array"]
+
+        # Map /connection, /console_lock, /phonehome, /remoteassist
+        # depending on what was passed in
+        [:connection, :console_lock, :phonehome, :remoteassist].each do |path|
+          url.map!{|u| u + "/#{path.to_s}"} if !@options.nil? && @options[path]
+        end
+
+        # 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)
+    end
+
+    # Create a connection between two arrays
+    # @param options [Hash] options to pass
+    def create(options = nil)
+      @options = options
+
+      raw_resp = @conn.post do |req|
+        req.url "/api/#{Purest.configuration.api_version}/array/connection"
+        req.body = @options.to_json
+      end
+
+      JSON.parse(raw_resp.body, :symbolize_names => true)
+    end
+
+    # Update attributes on an array, PUT
+    # @param options [Hash] options to pass in
+    def update(options = nil)
+      @options = options
+
+      raw_resp = @conn.put do |req|
+        url = ["/api/#{Purest.configuration.api_version}/array"]
+
+        if !@options.nil? && @options[:connected_array]
+          url.map!{|u| u + "/connection/#{@options[:connected_array]}"}
+        end
+
+        # Small conditional to ease remote assistance connecting/disconnecting
+        if !@options.nil? && @options[:remote_assist]
+          url.map!{|u| u + "/remoteassist"}
+          @options[:action] = @options.delete(:remote_assist)
+        end
+
+        # Small loop to ease console locking and home phoning
+        [:console_lock, :phonehome].each do |path|
+          if !@options.nil? && @options[path]
+            url.map!{|u| u + "/#{path.to_s}"}
+            @options[:enabled] = @options.delete(path)
+          end
+        end
+
+        # Keeping things consistent
+        @options[:name] = @options.delete(:new_name) if @options[:new_name]
+
+        # Don't send this as part of the JSON body if it's present
+        # in the options hash, as it's not a valid param
+        @options.delete(:connected_array)
+        req.body = @options.to_json
+
+        req.url concat_url url
+      end
+
+      JSON.parse(raw_resp.body, :symbolize_names => true)
+    end
+
+    # Disconnect one array from another
+    # @param options [Hash] options to pass in
+    def delete(options = nil)
+      @options = options
+
+      raw_resp = @conn.delete do |req|
+        req.url "/api/#{Purest.configuration.api_version}/array/connection/#{@options[:connected_array]}"
+      end
+    end
+
+    private
+
+    GET_PARAMS.each do |attribute|
+      define_method :"use_#{attribute}" do |options|
+        options ? use_named_parameter(attribute, options[attribute]) : []
+      end
+    end
+  end
+end

data/lib/purest/rest.rb

@@ -0,0 +1,120 @@
+# frozen_string_literal: true
+
+module Purest
+  # Base class for interacting with PURE storage REST API
+  class Rest < Purest::CustomExceptions
+    @access_methods = []
+    @get_params = []
+
+    # Initialize the fadaray connection, create session unless one exists
+    def initialize
+      establish_connection
+      create_session unless authenticated?
+    end
+
+    # Check if session exists, and whether or not it's expired
+    def authenticated?
+      if defined? @session_expire
+        if Time.now.utc < @session_expire
+          true
+        else
+          false
+        end
+      else
+        false
+      end
+    end
+
+    # Assemble a url from an array of parts.
+    # @param parts [Array] the url chunks to be assembled
+    # @return [String] the resultant url string
+    def concat_url(parts)
+      if parts.length > 1
+        parts.first + '?' + parts.drop(1).join('&')
+      else
+        parts.first
+      end
+    end
+
+    # Format url parameters into strings correctly
+    # @param name [String] the name of the parameter
+    # @param value [String] the value of the parameter
+    # @return [Array] the resultant parameter string inside an array.
+    def use_named_parameter(name, value)
+      if value.is_a? Array
+        ["#{name}=#{value.join(',')}"]
+      else
+        value ? ["#{name}=#{value}"] : []
+      end
+    end
+
+    # Logout current session
+    def logout
+      raw_resp = @conn.delete do |req|
+        req.url "/api/#{Purest.configuration.api_version}/auth/session"
+      end
+      remove_instance_variable(:@session_expire)
+    end
+
+    class << self
+      def access_method?(meth_id)
+        @access_methods.include? meth_id
+      end
+
+      def method_missing(meth_id, *args)
+        if access_method?(meth_id)
+          new.send(meth_id, *args)
+        else
+
+          # See https://bugs.ruby-lang.org/issues/10969
+          begin
+            super
+          rescue NameError => err
+            raise NoMethodError, err
+          end
+        end
+      end
+    end
+
+    private
+
+    def get_token
+      raw_resp = @conn.post do |req|
+        req.url "/api/#{Purest.configuration.api_version}/auth/apitoken"
+        req.params = {
+          "username": Purest.configuration.username.to_s,
+          "password": Purest.configuration.password.to_s
+        }
+      end
+
+      JSON.parse(raw_resp.body)['api_token']
+    end
+
+    def create_session
+      raw_resp = @conn.post do |req|
+        req.url "/api/#{Purest.configuration.api_version}/auth/session"
+        req.params = {
+          "api_token": get_token
+        }
+      end
+
+      # Man they really tuck that away, don't they?
+      @session_expire = Time.parse(raw_resp.env.response_headers['set-cookie'].split(';')[1].split(',')[1].strip).utc
+
+      raw_resp
+    end
+
+    # Build the API Client
+    def establish_connection
+      @conn = build_connection
+    end
+
+    def build_connection
+      Faraday.new(Purest.configuration.url, Purest.configuration.options) do |faraday|
+        faraday.request :json
+        faraday.use :cookie_jar
+        faraday.adapter Faraday.default_adapter
+      end
+    end
+  end
+end

data/lib/purest/volume.rb

@@ -0,0 +1,117 @@
+# frozen_string_literal: true
+
+module Purest
+  class Volume < Purest::Rest
+    @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 a list of volumes, GET
+    # @param options [Hash] options to pass
+    def get(options = nil)
+      @options = options
+      create_session unless authenticated?
+
+      # Build up a url from parts, allowing for dynamic http calls
+      # by simply passing in params accepted by Pure's API
+      raw_resp = @conn.get do |req|
+        url = ["/api/#{Purest.configuration.api_version}/volume"]
+
+        url.map!{|u| u + "/#{@options[:name]}"} if !@options.nil? && @options[:name]
+
+        # Map /diff, /hgroup, or /host depending on option passed
+        [:show_diff, :show_hgroup, :show_host].each do |path|
+          new_path = path.to_s.gsub('show_', '')
+          url.map!{|u| u + "/#{new_path}"} if !@options.nil? && @options[path]
+        end
+
+        # 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)
+    end
+
+    # Create a volume, POST
+    # @param options [Hash] options to pass
+    def create(options = nil)
+      @options = options
+
+      raw_resp = @conn.post do |req|
+        url = "/api/#{Purest.configuration.api_version}/volume"
+        url += "/#{@options[:name]}" if @options[:name]
+        url += "/pgroup/#{@options[:pgroup]}" if @options[:pgroup]
+        req.body = @options.to_json
+
+        req.url url
+      end
+
+      JSON.parse(raw_resp.body, :symbolize_names => true)
+    end
+
+    # Update a volume, PUT
+    # @param options [Hash] options to pass
+    def update(options = nil)
+      @options = options
+
+      raw_resp = @conn.put do |req|
+        # Here we construct the url first, because the options hash
+        # may have to be manipulated below
+        req.url "/api/#{Purest.configuration.api_version}/volume/#{@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]
+
+        # Remove name from @options which is sent in the body,
+        # if size is passed in, because those two cannot be sent together.
+        @options.delete(:name) if @options[:size]
+
+        req.body = @options.to_json
+      end
+
+      JSON.parse(raw_resp.body, :symbolize_names => true)
+    end
+
+    # Delete a volume, DELETE
+    # @param options [Hash] options to pass
+    def delete(options = nil)
+      @options = options
+
+      raw_resp = @conn.delete do |req|
+        url = "/api/#{Purest.configuration.api_version}/volume/#{@options[:name]}"
+        url += "/pgroup/#{@options[:pgroup]}" if @options[:pgroup]
+
+        req.url url
+      end
+
+      if @options[:eradicate]
+        raw_resp = @conn.delete do |req|
+          url = ["/api/#{Purest.configuration.api_version}/volume/#{@options[:name]}"]
+          req.body = @options.to_json
+
+          req.url concat_url url
+        end
+      end
+
+      JSON.parse(raw_resp.body, :symbolize_names => true)
+    end
+
+    private
+
+    # Dynamic method generation, e.g. use_connect, use_eradicate, etc
+    GET_PARAMS.each do |param|
+      define_method :"use_#{param}" do |options|
+        options ? use_named_parameter(param, options[param]) : []
+      end
+    end
+  end
+end

metadata

@@ -0,0 +1,178 @@
+--- !ruby/object:Gem::Specification
+name: purest
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Sean McKinley
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2018-06-29 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: cucumber
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+- !ruby/object:Gem::Dependency
+  name: pry
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.11.3
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.11.3
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 3.7.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 3.7.0
+- !ruby/object:Gem::Dependency
+  name: fakes-rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.1'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.1'
+- !ruby/object:Gem::Dependency
+  name: rubocop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.57.2
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.57.2
+- !ruby/object:Gem::Dependency
+  name: webmock
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 3.4.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 3.4.0
+- !ruby/object:Gem::Dependency
+  name: faraday
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.15.2
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.15.2
+- !ruby/object:Gem::Dependency
+  name: faraday_middleware
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.12.2
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.12.2
+- !ruby/object:Gem::Dependency
+  name: faraday-cookie_jar
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.0.6
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.0.6
+description: 
+email: sean.mckinley@outlook.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- README.md
+- lib/purest.rb
+- lib/purest/configuration.rb
+- lib/purest/custom_exceptions.rb
+- lib/purest/host.rb
+- lib/purest/host_group.rb
+- lib/purest/physical_array.rb
+- lib/purest/rest.rb
+- lib/purest/volume.rb
+homepage: 
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.7.6
+signing_key: 
+specification_version: 4
+summary: A ruby gem for interacting with PURE storage's REST API
+test_files: []