brocade_api_client 0.1.1

data/lib/BrocadeAPIClient/events.rb

@@ -0,0 +1,35 @@
+# 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 'exceptions'
+
+module BrocadeAPIClient
+  # Evens REST API methods
+  class Events
+    def initialize(http_client)
+      @http_client = http_client
+      @base_url = '/resourcegroups/All/events'
+    end
+
+    def syslog_events(count = '10')
+      api_url = @base_url + '?startindex=0&count=' + count + '&specialEvent=true&origin=syslog'
+      _response, _body = @http_client.get(api_url)
+    end
+
+    def trap_events(count = '10')
+      api_url = @base_url + '?startindex=0&count=' + count + '&specialEvent=true&origin=trap'
+      _response, _body = @http_client.get(api_url)
+    end
+
+    def custom_events(startindex = '0', count = '10', origin = 'syslog', severity = 'INFO')
+      api_url = @base_url + '?startindex=' + startindex + '&count=' + count + '&specialEvent=true' + '&origin=' + origin + '&severity=' + severity
+      _response, _body = @http_client.get(api_url)
+    end
+  end
+end

data/lib/BrocadeAPIClient/exceptions.rb

@@ -0,0 +1,79 @@
+# 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 'static'
+module BrocadeAPIClient
+  # Brocade Exception Classes
+  class BrocadeException < StandardError
+    attr_reader :message, :code, :ref, :http_status
+    def initialize(code: nil, message: nil, ref: nil, http_status: nil)
+      @code = code
+      @message = message
+      @ref = ref
+      @http_status = http_status
+      formatted_string = 'Error: '
+      formatted_string += format(' (HTTP %s)', @http_status) if @http_status
+      formatted_string += format(' API code: %s', @code) if @code
+      formatted_string += format(' - %s', @message) if @message
+      formatted_string += format(' - %s', @ref) if @ref
+      super(formatted_string)
+    end
+  end
+  exceptions_map = [{ name: 'UnsupportedOption', message: 'Unsupported Zoning Option, supported ALL is without zonename' },
+                    { name: 'UnsupportedAction', message: 'Unsupported Action, only ADD/Remove allowed' },
+                    { name: 'UnsupportedVersion', message: "Unsupported Brocade Network Advisor version, min supported version is, #{BrocadeAPIClient::BNASupport::BNA_MIN_SUPPORTED}" },
+                    { name: 'UnsupportedSeverityOption' },
+                    { name: 'InvalidPeerzoneOptions', message: 'Use principal and members as hash keys' },
+                    { name: 'InvalidVersion', message: 'Invalid API Version Detected' },
+                    { name: 'RequestException' },
+                    { name: 'ConnectionError', message: 'Connection Error to Brocade Network Advisor version' },
+                    { name: 'HTTPError' },
+                    { name: 'URLRequired' },
+                    { name: 'TooManyRedirects' },
+                    { name: 'Timeout' },
+                    { name: 'SSLCertFailed' },
+                    { name: 'HTTPBadRequest', http_status: 400, message: 'Bad request' },
+                    { name: 'HTTPUnauthorized', http_status: 401, message: 'Unauthorized' },
+                    { name: 'HTTPForbidden', http_status: 403, message: 'Forbidden' },
+                    { name: 'HTTPNotFound', http_status: 404, message: 'Not found' },
+                    { name: 'HTTPMethodNotAllowed', http_status: 405, message: 'Method Not Allowed' },
+                    { name: 'HTTPNotAcceptable', http_status: 406, message: 'Method Not Acceptable' },
+                    { name: 'HTTPProxyAuthRequired', http_status: 407, message: 'Proxy Authentication Required' },
+                    { name: 'HTTPRequestTimeout', http_status: 408, message: 'Request Timeout' },
+                    { name: 'HTTPConflict', http_status: 409, message: 'Conflict' },
+                    { name: 'HTTPGone', http_status: 410, message: 'Gone' },
+                    { name: 'HTTPLengthRequired', http_status: 411, message: 'Length Required' },
+                    { name: 'HTTPPreconditionFailed', http_status: 412, message: 'Over limit' },
+                    { name: 'HTTPRequestEntityTooLarge', http_status: 413, message: 'Request Entity Too Large' },
+                    { name: 'HTTPRequestURITooLong', http_status: 414, message: 'Request URI Too Large' },
+                    { name: 'HTTPUnsupportedMediaType', http_status: 415, message: 'Unsupported Media Type' },
+                    { name: 'HTTPRequestedRangeNotSatisfiable', http_status: 416, message: 'Requested Range Not Satisfiable' },
+                    { name: 'HTTPExpectationFailed', http_status: 417, message: 'Expectation Failed' },
+                    { name: 'HTTPTeaPot', http_status: 418, message: 'I\'m A Teapot. (RFC 2324)' },
+                    { name: 'HTTPInternalServerError', http_status: 500, message: 'Internal Server Error' },
+                    { name: 'HTTPNotImplemented', http_status: 501, message: 'Not Implemented' },
+                    { name: 'HTTPBadGateway', http_status: 502, message: 'Bad Gateway' },
+                    { name: 'HTTPServiceUnavailable', http_status: 503, message: 'Service Unavailable' },
+                    { name: 'HTTPGatewayTimeout', http_status: 504, message: 'Gateway Timeout' },
+                    { name: 'HTTPVersionNotSupported', http_status: 505, message: 'Version Not Supported' }]
+
+  exceptions_map.each { |x| BrocadeAPIClient.const_set(x[:name], BrocadeException.new(http_status: x[:http_status], message: x[:message])) }
+
+  attr_accessor :code_map
+  @@code_map = Hash.new('BrocadeException')
+  exceptions_map.each do |c|
+    inst = BrocadeAPIClient.const_get(c[:name])
+    @@code_map[inst.http_status] = c
+  end
+  def self.exception_from_response(response, _body)
+    # Return an instance of an ClientException
+    cls = @@code_map[response.code]
+    BrocadeAPIClient.const_get(cls[:name])
+  end
+end

data/lib/BrocadeAPIClient/fabrics.rb

@@ -0,0 +1,28 @@
+# 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 'client'
+require_relative 'httpclient'
+module BrocadeAPIClient
+  # Fabrics REST API Methods
+  class Fabrics
+    def initialize(http_client)
+      @http_client = http_client
+      @fabrics_url = '/resourcegroups/All/fcfabrics'
+    end
+
+    def fabrics
+      _response, _body = @http_client.get(@fabrics_url)
+    end
+
+    def fabric(fabricid)
+      _response, _body = @http_client.get(@fabrics_url + '/' + fabricid.upcase)
+    end
+  end
+end

data/lib/BrocadeAPIClient/httpclient.rb

@@ -0,0 +1,149 @@
+# 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 'httparty'
+require 'json'
+require 'logger'
+require_relative 'exceptions'
+
+module BrocadeAPIClient
+  # Class for talking to API
+  class JSONRestClient
+    USER_AGENT = 'ruby-brocadeclient'.freeze
+    ACCEPT_TYPE = 'application/vnd.brocade.networkadvisor+json;version=v1'.freeze
+    SESSION_COOKIE_NAME = 'WStoken'.freeze
+    CONTENT_TYPE = 'application/vnd.brocade.networkadvisor+json;version=v1'.freeze
+    attr_accessor :http_log_debug, :api_url, :session_key, :timeout, :secure,
+                  :logger, :log_level
+    @username = nil
+    @password = nil
+    def initialize(api_url, secure = false, http_log_debug = false,
+                   client_logger = nil)
+      @api_url = api_url
+      @secure = secure
+      @http_log_debug = http_log_debug
+      @session_key = nil
+      @client_logger = client_logger
+      @httparty_log_level = :info
+      @httparty_log_format = :logstash
+      set_debug_flag
+    end
+
+    # This turns on/off http request/response debugging output to console
+    def set_debug_flag
+      if @http_log_debug
+        @httparty_log_level = :debug
+        @httparty_log_format = :curl
+      end
+    end
+
+    def authenticate(user, password, _optional = nil)
+      @username = user
+      @pasword = password
+      @session_key = nil
+      auth_url = '/login'
+      headers, body = post(auth_url)
+      @session_key = headers['WStoken']
+      JSON.parse(body)
+    rescue StandardError
+      raise BrocadeAPIClient::ConnectionError
+    end
+
+    def url(api_url)
+      # should be http://<Server:Port>/rest
+      @api_url = api_url.chomp('/')
+    end
+
+    def get(url, **kwargs)
+      headers, _payload = headers_payload(kwargs)
+      response = HTTParty.get(api_url + url,
+                              headers: headers,
+                              verify: false, logger: @client_logger,
+                              log_level: @httparty_log_level,
+                              log_format: @client_logger)
+      validate_answer(response)
+    end
+
+    def post(url, **kwargs)
+      headers, payload = headers_payload(kwargs)
+      response = HTTParty.post(api_url + url,
+                               headers: headers,
+                               body: payload,
+                               verify: false,
+                               logger: @client_logger,
+                               log_level: @httparty_log_level,
+                               log_format: @httparty_log_format)
+      validate_answer(response)
+    end
+
+    def put(url, **kwargs)
+      headers, payload = headers_payload(kwargs)
+      response = HTTParty.put(api_url + url,
+                              headers: headers,
+                              body: payload,
+                              verify: false, logger: @client_logger,
+                              log_level: @httparty_log_level,
+                              log_format: @httparty_log_format)
+      validate_answer(response)
+    end
+
+    def delete(url, **kwargs)
+      headers, _payload = headers_payload(kwargs)
+      response = HTTParty.delete(api_url + url,
+                                 headers: headers,
+                                 verify: false, logger: @client_logger,
+                                 log_level: @httparty_log_level,
+                                 log_format: @httparty_log_format)
+      validate_answer(response)
+    end
+
+    def validate_answer(response)
+      headers = response.headers
+      body = response.parsed_response
+      code_array = %w[200 204]
+      unless code_array.include?(response.code.to_s)
+        if body.nil?
+          exception = BrocadeAPIClient.exception_from_response(response, body)
+          @client_logger.error(exception)
+          raise exception
+        end
+      end
+      [headers, body]
+    end
+
+    def unauthenticate
+      # delete the session on the brocade network advisor
+      unless @session_key.nil?
+        post('/logout')
+        @session_key = nil
+      end
+    end
+
+    def headers_payload(**kwargs)
+      kwargs['headers'] = kwargs.fetch('headers', {})
+      if session_key
+        kwargs['headers'] = kwargs.fetch('headers', {})
+        kwargs['headers'][SESSION_COOKIE_NAME] = session_key
+      else
+        kwargs['headers']['WSUsername'] = @username
+        kwargs['headers']['WSPassword'] = @username
+      end
+      kwargs['headers']['User-Agent'] = USER_AGENT
+      kwargs['headers']['Accept'] = ACCEPT_TYPE
+      if kwargs.key?(:body)
+        kwargs['headers']['Content-Type'] = CONTENT_TYPE
+        kwargs[:body] = kwargs[:body].to_json
+        payload = kwargs[:body]
+      else
+        payload = nil
+      end
+      [kwargs['headers'], payload]
+    end
+  end
+end

data/lib/BrocadeAPIClient/ports.rb

@@ -0,0 +1,52 @@
+# 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 BrocadeAPIClient
+  # Ports REST API Methods
+  class Ports
+    def initialize(http_client)
+      @http_client = http_client
+      @base_url = '/resourcegroups/All'
+    end
+
+    def allports
+      api_url = @base_url + '/fcports'
+      _response, _body = @http_client.get(api_url)
+    end
+
+    def change_portstates(switchwwn, state, *portwwns)
+      payload = {}
+      portwwns.map!(&:upcase)
+      api_url = @base_url + '/fcswitches/' + switchwwn.upcase + '/fcports/fcportstate'
+      payload['fcPortState'] = state
+      payload['fcPortWWNs'] = portwwns
+      _response, _body = @http_client.post(api_url, body: payload)
+    end
+
+    def change_persistentportstates(switchwwn, state, *portwwns)
+      payload = {}
+      api_url = @base_url + '/fcswitches/' + switchwwn.upcase + '/fcports/fcportpersistentstate'
+      portwwns.map!(&:upcase)
+      payload['fcPortState'] = state
+      payload['fcPortWWNs'] = portwwns
+      _response, _body = @http_client.post(api_url, body: payload)
+    end
+
+    def set_portname(switchwwn, portwwn, portname)
+      porthash = {}
+      portarray = []
+      api_url = @base_url + '/fcswitches/' + switchwwn.upcase + '/fcports/fcportnames'
+      porthash['fcPortWWN'] = portwwn.upcase
+      porthash['fcPortName'] = portname
+      portarray.push(porthash)
+      payload = { 'fcPortNameChangeReqEntry' => portarray }
+      _response, _body = @http_client.post(api_url, body: payload)
+    end
+  end
+end

data/lib/BrocadeAPIClient/static.rb

@@ -0,0 +1,16 @@
+# 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 BrocadeAPIClient
+  # Class to support versions checks for Brocade Network Advisor
+  class BNASupport
+    BNA_MIN_SUPPORTED = '14.2.0'.freeze
+    BNA_PEER_ZONING_TDZ_MIN_SUPPORTED = '14.4.0'.freeze
+  end
+end

data/lib/BrocadeAPIClient/switches.rb

@@ -0,0 +1,29 @@
+# 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 BrocadeAPIClient
+  # Switches REST API Methods
+  class Switches
+    def initialize(http_client)
+      @http_client = http_client
+      @base_url = '/resourcegroups/All'
+    end
+
+    def fabricswitches(fabricid)
+      api_url = @base_url + '/fcfabrics/' + fabricid.upcase + '/fcswitches'
+      _response, _body = @http_client.get(api_url)
+    end
+
+    def allswitches
+      api_url =  @base_url + '/fcswitches'
+      _response, _body = @http_client.get(api_url)
+    end
+  end
+end

data/lib/BrocadeAPIClient/version.rb

@@ -0,0 +1,13 @@
+# 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 BrocadeAPIClient
+  VERSION = '0.1.1'.freeze
+end

data/lib/BrocadeAPIClient/zones.rb

@@ -0,0 +1,183 @@
+# 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 'exceptions'
+
+module BrocadeAPIClient
+  # Zones REST API Methods
+  class Zones
+    def initialize(http_client)
+      @http_client = http_client
+      @base_url = '/resourcegroups/All/fcfabrics/'
+    end
+
+    def zoneshow(fabrickey, zones = 'all', zkey = 'none')
+      api_url = @base_url + fabrickey.upcase + '/zones'
+      if zones == 'all'
+      elsif zones == 'active'
+        api_url += if zkey == 'none'
+                     '?active=true'
+                   else '/' + zkey + '-true'
+                   end
+      elsif zones == 'defined'
+        api_url += if zkey == 'none'
+                     '?active=false'
+                   else '/' + zkey + '-false'
+                   end
+      else
+        err_msg = 'Unsupported Zoning Option, supported ALL is without zonename'
+        raise BrocadeAPIClient::UnsupportedOption
+      end
+      _response, _body = @http_client.get(api_url)
+    end
+
+    def zonedbs(fabrickey)
+      api_url = @base_url + fabrickey.upcase + '/zonedbs'
+      _response, _body = @http_client.get(api_url)
+    end
+
+    def alishow(fabrickey, zakey = 'none')
+      api_url = @base_url + fabrickey.upcase + '/zonealiases'
+      api_url += '/' + zakey unless zakey == 'none'
+      _response, _body = @http_client.get(api_url)
+    end
+
+    def cfgshow(fabrickey, type)
+      api_url =  @base_url + fabrickey.upcase + '/zonesets'
+      if type == 'all'
+      elsif type == 'active'
+        api_url += '?active=true'
+      elsif type == 'defined'
+        api_url +=  '?active=false'
+      else raise BrocadeAPIClient::UnsupportedOption
+      end
+      _response, _body = @http_client.get(api_url)
+    end
+
+    def alicreate(fabrickey, aliname, *wwn)
+      wwn.map!(&:upcase)
+      api_url = @base_url + fabrickey.upcase + '/createzoningobject'
+      alihash ||= { name: aliname, memberNames: wwn }
+      (aliarray ||= []) << alihash
+      payload ||= { zoneAliases: aliarray }
+      _response, _body = @http_client.post(api_url, body: payload)
+    end
+
+    def control_transaction(fabrickey, action)
+      payload ||= { lsanZoning: 'false', action: action.upcase }
+      api_url = @base_url + fabrickey.upcase + '/controlzonetransaction'
+      _response, _body = @http_client.post(api_url, body: payload)
+    end
+
+    def zonecreate_standard(fabrickey, zonename, *aliases)
+      api_url = @base_url + fabrickey.upcase + '/createzoningobject'
+      zonearray = []
+      zonehash ||= { name: zonename, aliasNames: aliases, type: 'STANDARD' }
+      (zonearray ||= []) << zonehash
+      payload ||= { zones: zonearray }
+      _response, _body = @http_client.post(api_url, body: payload)
+    end
+
+    def zonecreate_peerzone(fabrickey, zonename, **members)
+      raise BrocadeAPIClient::InvalidPeerzoneOptions unless members.key?(:principal) && members.key?(:members)
+
+      api_url = @base_url + fabrickey.upcase + '/createzoningobject'
+      peermembers ||= { peerMemberName: members[:members] }
+      peerdetails ||= { principalMemberName: members[:principal], peerMembers: peermembers }
+      zonedetails ||= { name: zonename, type: 'STANDARD', peerZone: 'True', peerZoneDetails: peerdetails }
+      (zonearray ||= []) << zonedetails
+      payload ||= { zones: zonearray }
+      _response, _body = @http_client.post(api_url, body: payload)
+    end
+
+    def zonedelete(fabrickey, *zonenames)
+      api_url = @base_url + fabrickey.upcase + '/deletezoningobject'
+      payload ||= { zoneNames: zonenames }
+      _response, _body = @http_client.post(api_url, body: payload)
+    end
+
+    def alidelete(fabrickey, *alinames)
+      api_url = @base_url + fabrickey.upcase + '/deletezoningobject'
+      payload ||= { zoneAliasNames: alinames }
+      _response, _body = @http_client.post(api_url, body: payload)
+    end
+
+    def altercfg(fabrickey, action, cfgname, *zonenames)
+      api_url = @base_url + fabrickey.upcase + '/updatezoningobject'
+      payload ||= { action: validate_answer(action) }
+      cfghash ||= { name: cfgname, zoneNames: zonenames }
+      (cfgarray ||= []) << cfghash
+      payload.store(:zoneSets, cfgarray)
+      _response, _body = @http_client.post(api_url, body: payload)
+    end
+
+    def alteralias(fabrickey, action, aliname, *wwn)
+      api_url = @base_url + fabrickey.upcase + '/updatezoningobject'
+      payload ||= { action: validate_answer(action) }
+      wwn.map!(&:upcase)
+      alihash ||= { name: aliname, memberNames: wwn }
+      (aliarray ||= []) << alihash
+      payload.store(:zoneAliases, aliarray)
+      _response, _body = @http_client.post(api_url, body: payload)
+    end
+
+    def alterzoning_standard(fabrickey, action, zonename, *aliases)
+      api_url = @base_url + fabrickey.upcase + '/updatezoningobject'
+      payload ||= { action: validate_answer(action) }
+      zonehash ||= { name: zonename, aliasNames: aliases }
+      (zonearray ||= []) << zonehash
+      payload.store(:zones, zonearray)
+      _response, _body = @http_client.post(api_url, body: payload)
+    end
+
+    def alterzoning_peerzone(fabrickey, action, zonename, **wwn)
+      api_url = @base_url + fabrickey.upcase + '/updatezoningobject'
+      peerdetails = {}
+      peermembers = {}
+      payload ||= { action: validate_answer(action) }
+      case (wwn.keys & %i[principal members]).sort
+      when %i[members principal]
+        wwn[:members].map!(&:upcase)
+        wwn[:principal].map!(&:upcase)
+        peermembers = { peerMemberName: wwn[:members] }
+        peerdetails = { principalMemberName: wwn[:principal] }
+      when [:principal]
+        wwn[:principal].map!(&:upcase)
+        peerdetails = { principalMemberName: wwn[:principal] }
+      when [:members]
+        wwn[:members].map!(&:upcase)
+        peermembers = { peerMemberName: wwn[:members] }
+      else
+        raise BrocadeAPIClient::InvalidPeerzoneOptions
+      end
+      peerdetails.store(:peerMembers, peermembers)
+      zonedetails ||= { name: zonename, type: 'STANDARD', peerZone: 'True', peerZoneDetails: peerdetails }
+      (zonearray ||= []) << zonedetails
+      payload.store(:zones, zonearray)
+      _response, _body = @http_client.post(api_url, body: payload)
+    end
+
+    def cfgenable(fabrickey, cfgname)
+      api_url = @base_url + fabrickey.upcase + '/zonesets/' + cfgname + '-false/activate'
+      payload = {}
+      _response, _body = @http_client.post(api_url, body: payload)
+    end
+
+    private
+
+    def validate_answer(action)
+      case action.upcase
+      when 'ADD', 'REMOVE'
+        action.upcase
+      else
+        raise BrocadeAPIClient::UnsupportedAction
+      end
+    end
+  end
+end