hpe3par_sdk 1.0.0

data/lib/Hpe3parSdk/volume_manager.rb

@@ -0,0 +1,292 @@
+# (c) Copyright 2016-2017 Hewlett Packard Enterprise Development LP
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software distributed
+# under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
+# CONDITIONS OF ANY KIND, either express or implied. See the License for the
+# specific language governing permissions and limitations under the License.
+
+require_relative 'util'
+require_relative 'constants'
+require_relative 'exceptions'
+require_relative 'task_manager'
+require_relative 'ssh'
+require_relative 'volume_set_manager'
+require_relative 'models'
+
+module Hpe3parSdk
+  class VolumeManager
+    def initialize(http, ssh, app_type)
+      @http = http
+      @ssh = ssh
+      @task = TaskManager.new(http)
+      @volume_set = VolumeSetManager.new(http)
+      @app_type = app_type
+    end
+
+    def get_volumes(volume_type)
+      volumes = Array[]
+      response = @http.get('/volumes')
+      response[1]['members'].each do |member|
+        volumes.push(VirtualVolume.new(member)) if member['copyType'] == volume_type
+      end
+      volumes
+    end
+
+    def get_volume(name)
+      if name.nil? || name.strip.empty?
+        raise 'Volume name cannot be nil or empty'
+      else
+        VirtualVolume.new(@http.get("/volumes/#{name}")[1])
+      end
+    end
+
+    def get_volume_by_wwn(wwn)
+      response = @http.get("/volumes?query=\"wwn EQ #{wwn}\"")
+      if response[1].key?('members') && !response[1]['members'].empty?
+        return VirtualVolume.new(response[1]['members'][0])
+      else
+        raise HTTPNotFound.new(nil, "Volume with WWN #{wwn} does not exist", nil, 404)
+      end
+    end
+
+    def create_volume(name, cpg_name, size_mib, optional = nil)
+      info = { 'name' => name, 
+               'cpg' => cpg_name, 
+               'sizeMiB' => size_mib, 
+               #Adding information related to telemetry
+               'objectKeyValues' => [ 
+                 { 
+                   'key' => 'type' , 
+                   'value' => @app_type 
+                 } 
+               ] 
+             }
+      
+      info = Util.merge_hash(info, optional) if optional
+      volumes_url = '/volumes'
+      @http.post(volumes_url, body: info)
+    end
+
+    def get_volume_snapshot_names(name)
+      snapshots = []
+      headers, body = @http.get("/volumes?query=\"copyOf EQ #{name}\"")
+      for member in body['members']
+        snapshots.push(member['name'])
+      end
+      snapshots
+    end
+
+    def get_volume_snapshots(name)
+      response = @http.get("/volumes?query=\"copyOf EQ #{name}\"")
+      volume_snapshots = []
+      response[1]['members'].each do |snapshot|
+        volume_snapshots.push(VirtualVolume.new(snapshot))
+      end
+      volume_snapshots
+    end
+
+    def delete_volume(name)
+      response = @http.delete("/volumes/#{name}")
+      response[1]
+    end
+
+    def modify_volume(name, volume_mods)
+      @http.put("/volumes/#{name}", body: volume_mods)
+      if volume_mods.key? ('newName') && !volume_mods['newName'].nil?
+        name = volume_mods['newName']
+      end
+      setVolumeMetaData(name, 'type', @app_type)     
+    end
+
+    def grow_volume(name, amount)
+      info = { 'action' => VolumeCustomAction::GROW_VOLUME, 'sizeMiB' => amount }
+      response = @http.put("/volumes/#{name}", body: info)
+      response[1]
+    end
+
+    def create_physical_copy(src_name, dest_name, dest_cpg, optional = nil)
+      parameters = { :destVolume => dest_name, :destCPG => dest_cpg }
+      parameters = Util.merge_hash(parameters, optional) if optional
+
+      
+      if !parameters.key?(:online) || !((parameters[:online]))
+        # 3Par won't allow destCPG to be set if it's not an online copy.
+        parameters.delete(:destCPG)
+      end
+      
+      info = { :action => 'createPhysicalCopy', :parameters => parameters }
+
+      response = @http.post("/volumes/#{src_name}", body: info)
+      response[1]
+    end
+    
+    def stop_offline_physical_copy(volume_name)
+      _sync_physical_copy(volume_name, VolumeCustomAction::STOP_PHYSICAL_COPY)
+    end
+    
+    def is_online_physical_copy(name)
+      task = _find_task(name, active=true)
+      if task.nil?
+        false
+      else
+        true
+      end
+    end
+    
+    def stop_online_physical_copy(name)
+      task = _find_task(name, active=false)
+      unless task.nil?
+        task_id = task[0].split(",")[0]
+        unless task_id.nil?
+          cmd = ['canceltask', '-f', task_id]
+          command = cmd.join(" ")
+          result = @ssh.run(command)
+          unless result.include? "is not active"        
+            ready = false
+            while ready == false
+              sleep(1)
+              task = _find_task(name, false)
+              if task.nil?
+                ready = true
+              end
+            end
+          end
+        end
+      end
+    end
+    
+    def _find_task(name, active=false) 
+      cmd = ['showtask']
+      if active
+        cmd.push('-active')
+      end
+      cmd.push(name)
+      command = cmd.join(" ")
+      
+      result = @ssh.run(command).split("\n")
+      if result[0].gsub("\n",'') =='No tasks.'
+        return nil
+      end
+      result
+    end
+    
+    def resync_physical_copy(volume_name)
+      _sync_physical_copy(volume_name, VolumeCustomAction::RESYNC_PHYSICAL_COPY)
+    end
+    
+    def _sync_physical_copy(volume_name, action)
+      info = { 'action' => action }
+      response = @http.put("/volumes/#{volume_name}", body: info)
+      response[1]
+    end
+      
+    def get_online_physical_copy_status(name)
+      status = nil
+      tasks = @task.get_all_tasks
+      tasks.each do |task|
+        status = task['status'] if task['name'] == name &&
+                                   task['type'] == TaskType::ONLINE_COPY
+      end
+      raise HPE3PARException.new(nil, 'Volume not an online physical copy') if status.nil?
+      status
+    end
+
+    def tune_volume(name, tune_operation, optional = nil)
+      info = { 'action' => VolumeCustomAction::TUNE_VOLUME,
+               'tuneOperation' => tune_operation }
+      info = Util.merge_hash(info, optional) if optional
+      response = @http.put("/volumes/#{name}", body: info)
+      response[1]
+    end
+    
+  
+
+    def create_snapshot(name, copy_of_name, optional = nil)
+      parameters = { 'name' => name }
+      parameters = Util.merge_hash(parameters, optional) if optional
+      info = { 'action' => 'createSnapshot',
+               'parameters' => parameters }
+
+      response = @http.post("/volumes/#{copy_of_name}", body: info)
+      response[1]
+    end
+
+    def restore_snapshot(name, optional = nil)
+      info = { 'action' => VolumeCustomAction::PROMOTE_VIRTUAL_COPY }
+      info = Util.merge_hash(info, optional) if optional
+
+      response = @http.put("/volumes/#{name}", body: info)
+      response[1]
+    end
+    
+    def setVolumeMetaData(name, key, value)
+      key_exists = false
+      info = {
+          'key' => key,
+          'value' => value
+      }
+      
+      begin
+        response = @http.post("/volumes/#{name}/objectKeyValues", body: info)
+      rescue  Hpe3parSdk::HTTPConflict => ex
+        key_exists = true
+      rescue
+      end
+      
+      if key_exists
+        info = {
+            'value' => value
+        }
+        begin
+          response = @http.put("/volumes/#{name}/objectKeyValues/#{key}", body: info)
+        rescue; end
+      end
+    end
+    
+    def volume_exists?(name)
+      begin
+        get_volume(name)
+        return true
+      rescue Hpe3parSdk::HTTPNotFound => ex
+        return false
+      end
+    end
+
+    def volume_set_exists?(name)
+      begin
+        get_volume_set(name)
+        return true
+      rescue Hpe3parSdk::HTTPNotFound => ex
+        return false
+      end
+    end
+  
+    def online_physical_copy_exists?(src_name, phy_copy_name)
+      begin
+        if volume_exists?(src_name) and volume_exists?(phy_copy_name) and !_find_task(phy_copy_name,true).nil?
+          return true
+        else
+          return false 
+        end
+      rescue Hpe3parSdk::HTTPNotFound => ex
+        return false
+      end
+    end
+
+    def offline_physical_copy_exists?(src_name, phy_copy_name)
+      begin
+        if volume_exists?(src_name) and volume_exists?(phy_copy_name) and !_find_task(src_name + "->" + phy_copy_name,true).nil?
+           return true
+        else
+           return false 
+        end
+      rescue Hpe3parSdk::HTTPNotFound => ex
+        return false
+      end
+    end
+  end
+end

data/lib/Hpe3parSdk/volume_set_manager.rb

@@ -0,0 +1,126 @@
+# (c) Copyright 2016-2017 Hewlett Packard Enterprise Development LP
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software distributed
+# under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
+# CONDITIONS OF ANY KIND, either express or implied. See the License for the
+# specific language governing permissions and limitations under the License.
+
+require_relative 'util'
+require_relative 'constants'
+require_relative 'models'
+
+module Hpe3parSdk
+  class VolumeSetManager
+    def initialize(http, host_and_vv_set_filter_supported = false)
+      @http = http
+      @vv_set_filter_supported = host_and_vv_set_filter_supported
+    end
+
+    def find_all_volume_sets(name)
+      vv_sets = []
+      if @vv_set_filter_supported
+        query = %("setmembers EQ #{name}")
+        response = @http.get("/volumesets?query=#{query}")
+        volume_sets = response[1]['members']
+        volume_sets.each do |volume_set|
+          vv_sets.push(VolumeSet.new(volume_set))
+        end
+      else
+        volume_sets = get_volume_sets
+        volume_sets.each do |volume_set|
+          if !volume_set.setmembers.nil? && !volume_set.setmembers.empty? && volume_set.setmembers.include?(name)
+            vv_sets.push(volume_set)
+          end
+        end
+      end
+      vv_sets
+    end
+
+    def get_volume_sets
+      response = @http.get('/volumesets')
+      volume_set_members = []
+      response[1]['members'].each do |volume_set_member|
+        volume_set_members.push(VolumeSet.new(volume_set_member))
+      end
+      volume_set_members
+    end
+
+    def get_volume_set(name)
+      if name.nil? || name.strip.empty?
+        raise 'Volume set name cannot be nil or empty'
+      else
+        response = @http.get('/volumesets/' + name)
+        VolumeSet.new(response[1])
+      end
+    end
+
+    def create_volume_set(name, domain = nil, comment = nil, setmembers = nil)
+      info = { 'name' => name }
+
+      info['domain'] = domain if domain
+
+      info['comment'] = comment if comment
+
+      if setmembers
+        members = { 'setmembers' => setmembers }
+        info = Util.merge_hash(info, members)
+      end
+      @http.post('/volumesets', body: info)
+    end
+
+    def delete_volume_set(name)
+      @http.delete("/volumesets/#{name}")[1]
+    end
+
+    def modify_volume_set(name, action = nil, newName = nil, comment = nil, flash_cache_policy = nil, setmembers = nil)
+      info = {}
+
+      info['action'] = action if action
+
+      info['newName'] = newName if newName
+
+      info['comment'] = comment if comment
+
+      info['flashCachePolicy'] = flash_cache_policy if flash_cache_policy
+
+      if setmembers
+        members = { 'setmembers' => setmembers }
+        info = Util.merge_hash(info, members)
+      end
+
+      @http.put("/volumesets/#{name}", body: info)[1]
+    end
+
+    # QoS Priority Optimization methods
+    def add_volumes_to_volume_set(set_name, setmembers)
+      modify_volume_set(set_name, SetCustomAction::MEM_ADD, nil, nil, nil, setmembers)
+    end
+
+    def remove_volumes_from_volume_set(set_name, setmembers)
+      modify_volume_set(set_name, SetCustomAction::MEM_REMOVE, nil, nil, nil, setmembers)
+    end
+
+    def create_snapshot_of_volume_set(name, copy_of_name, optional = nil)
+      parameters = { 'name' => name }
+      parameters = Util.merge_hash(parameters, optional) if optional
+
+      info = { 'action' => 'createSnapshot', 'parameters' => parameters }
+
+      response = @http.post("/volumesets/#{copy_of_name}", body: info)
+      response[1]
+    end
+
+    def volume_set_exists?(name)
+      begin
+        get_volume_set(name)
+        return true
+      rescue Hpe3parSdk::HTTPNotFound => ex
+        return false
+      end
+    end
+  end
+end

data/lib/Hpe3parSdk/wsapi_version.rb

@@ -0,0 +1,73 @@
+# (c) Copyright 2016-2017 Hewlett Packard Enterprise Development LP
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software distributed
+# under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
+# CONDITIONS OF ANY KIND, either express or implied. See the License for the
+# specific language governing permissions and limitations under the License.
+
+module Hpe3parSdk
+  class WSAPIVersion
+    include Comparable
+    attr_accessor :major, :minor, :revision
+
+    def self.parse(version)
+      version_parts = version.split('.')
+      validate_version(version, version_parts)
+
+      @major = version_parts[0].to_i
+      @minor = version_parts[1].to_i
+      @revision = version_parts[2].to_i
+      obj_version = WSAPIVersion.new(@major, @minor, @revision)
+      return obj_version
+    end
+
+    def initialize(major, minor, revision)
+      @major = major
+      @minor = minor
+      @revision = revision
+    end
+
+    def <=>(other_version)
+      if major < other_version.major
+        return -1
+      end
+
+      if major > other_version.major
+        return 1
+      end
+
+      if minor < other_version.minor
+        return -1
+      end
+
+      if minor > other_version.minor
+        return 1
+      end
+
+      if revision < other_version.revision
+        return -1
+      end
+
+      if revision > other_version.revision
+        return 1
+      end
+
+      return 0
+    end
+
+    def to_s
+      major.to_s + '.' + minor.to_s + '.' + revision.to_s
+    end
+
+    private
+    def self.validate_version(version, version_parts)
+      if version_parts.length != 3
+        raise 'Invalid Version detected ' + version
+      end
+    end
+  end
+end