# coding: utf-8

"""
ClusterNodesApi.py
Copyright 2016 SmartBear Software

   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.
"""

from __future__ import absolute_import

import sys
import os
import re

# python 2 and python 3 compatibility library
from six import iteritems

from ..configuration import Configuration
from ..api_client import ApiClient


class ClusterNodesApi(object):
    """
    NOTE: This class is auto generated by the swagger code generator program.
    Do not edit the class manually.
    Ref: https://github.com/swagger-api/swagger-codegen
    """

    def __init__(self, api_client=None):
        config = Configuration()
        if api_client:
            self.api_client = api_client
        else:
            if not config.api_client:
                config.api_client = ApiClient()
            self.api_client = config.api_client

    def create_drives_drive_add_item(self, drives_drive_add_item, lnn, driveid, **kwargs):
        """
        
        Add a drive to a node.

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please define a `callback` function
        to be invoked when receiving the response.
        >>> def callback_function(response):
        >>>     pprint(response)
        >>>
        >>> thread = api.create_drives_drive_add_item(drives_drive_add_item, lnn, driveid, callback=callback_function)

        :param callback function: The callback function
            for asynchronous request. (optional)
        :param Empty drives_drive_add_item:  (required)
        :param int lnn:  (required)
        :param str driveid:  (required)
        :return: Empty
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['drives_drive_add_item', 'lnn', 'driveid']
        all_params.append('callback')

        params = locals()
        for key, val in iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method create_drives_drive_add_item" % key
                )
            params[key] = val
        del params['kwargs']

        # verify the required parameter 'drives_drive_add_item' is set
        if ('drives_drive_add_item' not in params) or (params['drives_drive_add_item'] is None):
            raise ValueError("Missing the required parameter `drives_drive_add_item` when calling `create_drives_drive_add_item`")
        # verify the required parameter 'lnn' is set
        if ('lnn' not in params) or (params['lnn'] is None):
            raise ValueError("Missing the required parameter `lnn` when calling `create_drives_drive_add_item`")
        # verify the required parameter 'driveid' is set
        if ('driveid' not in params) or (params['driveid'] is None):
            raise ValueError("Missing the required parameter `driveid` when calling `create_drives_drive_add_item`")


        resource_path = '/platform/3/cluster/nodes/{Lnn}/drives/{Driveid}/add'.replace('{format}', 'json')
        path_params = {}
        if 'lnn' in params:
            path_params['Lnn'] = params['lnn']
        if 'driveid' in params:
            path_params['Driveid'] = params['driveid']

        query_params = {}

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        if 'drives_drive_add_item' in params:
            body_params = params['drives_drive_add_item']

        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.\
            select_header_accept(['application/json'])
        if not header_params['Accept']:
            del header_params['Accept']

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.\
            select_header_content_type(['application/json'])

        # Authentication setting
        auth_settings = ['basic_auth']

        response = self.api_client.call_api(resource_path, 'POST',
                                            path_params,
                                            query_params,
                                            header_params,
                                            body=body_params,
                                            post_params=form_params,
                                            files=local_var_files,
                                            response_type='Empty',
                                            auth_settings=auth_settings,
                                            callback=params.get('callback'))
        return response

    def create_drives_drive_firmware_update_item(self, drives_drive_firmware_update_item, lnn, driveid, **kwargs):
        """
        
        Start a drive firmware update.

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please define a `callback` function
        to be invoked when receiving the response.
        >>> def callback_function(response):
        >>>     pprint(response)
        >>>
        >>> thread = api.create_drives_drive_firmware_update_item(drives_drive_firmware_update_item, lnn, driveid, callback=callback_function)

        :param callback function: The callback function
            for asynchronous request. (optional)
        :param DrivesDriveFirmwareUpdateItem drives_drive_firmware_update_item:  (required)
        :param int lnn:  (required)
        :param str driveid:  (required)
        :return: Empty
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['drives_drive_firmware_update_item', 'lnn', 'driveid']
        all_params.append('callback')

        params = locals()
        for key, val in iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method create_drives_drive_firmware_update_item" % key
                )
            params[key] = val
        del params['kwargs']

        # verify the required parameter 'drives_drive_firmware_update_item' is set
        if ('drives_drive_firmware_update_item' not in params) or (params['drives_drive_firmware_update_item'] is None):
            raise ValueError("Missing the required parameter `drives_drive_firmware_update_item` when calling `create_drives_drive_firmware_update_item`")
        # verify the required parameter 'lnn' is set
        if ('lnn' not in params) or (params['lnn'] is None):
            raise ValueError("Missing the required parameter `lnn` when calling `create_drives_drive_firmware_update_item`")
        # verify the required parameter 'driveid' is set
        if ('driveid' not in params) or (params['driveid'] is None):
            raise ValueError("Missing the required parameter `driveid` when calling `create_drives_drive_firmware_update_item`")


        resource_path = '/platform/3/cluster/nodes/{Lnn}/drives/{Driveid}/firmware/update'.replace('{format}', 'json')
        path_params = {}
        if 'lnn' in params:
            path_params['Lnn'] = params['lnn']
        if 'driveid' in params:
            path_params['Driveid'] = params['driveid']

        query_params = {}

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        if 'drives_drive_firmware_update_item' in params:
            body_params = params['drives_drive_firmware_update_item']

        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.\
            select_header_accept(['application/json'])
        if not header_params['Accept']:
            del header_params['Accept']

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.\
            select_header_content_type(['application/json'])

        # Authentication setting
        auth_settings = ['basic_auth']

        response = self.api_client.call_api(resource_path, 'POST',
                                            path_params,
                                            query_params,
                                            header_params,
                                            body=body_params,
                                            post_params=form_params,
                                            files=local_var_files,
                                            response_type='Empty',
                                            auth_settings=auth_settings,
                                            callback=params.get('callback'))
        return response

    def create_drives_drive_format_item(self, drives_drive_format_item, lnn, driveid, **kwargs):
        """
        
        Format a drive for use by OneFS.

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please define a `callback` function
        to be invoked when receiving the response.
        >>> def callback_function(response):
        >>>     pprint(response)
        >>>
        >>> thread = api.create_drives_drive_format_item(drives_drive_format_item, lnn, driveid, callback=callback_function)

        :param callback function: The callback function
            for asynchronous request. (optional)
        :param DrivesDriveFormatItem drives_drive_format_item:  (required)
        :param int lnn:  (required)
        :param str driveid:  (required)
        :return: Empty
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['drives_drive_format_item', 'lnn', 'driveid']
        all_params.append('callback')

        params = locals()
        for key, val in iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method create_drives_drive_format_item" % key
                )
            params[key] = val
        del params['kwargs']

        # verify the required parameter 'drives_drive_format_item' is set
        if ('drives_drive_format_item' not in params) or (params['drives_drive_format_item'] is None):
            raise ValueError("Missing the required parameter `drives_drive_format_item` when calling `create_drives_drive_format_item`")
        # verify the required parameter 'lnn' is set
        if ('lnn' not in params) or (params['lnn'] is None):
            raise ValueError("Missing the required parameter `lnn` when calling `create_drives_drive_format_item`")
        # verify the required parameter 'driveid' is set
        if ('driveid' not in params) or (params['driveid'] is None):
            raise ValueError("Missing the required parameter `driveid` when calling `create_drives_drive_format_item`")


        resource_path = '/platform/3/cluster/nodes/{Lnn}/drives/{Driveid}/format'.replace('{format}', 'json')
        path_params = {}
        if 'lnn' in params:
            path_params['Lnn'] = params['lnn']
        if 'driveid' in params:
            path_params['Driveid'] = params['driveid']

        query_params = {}

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        if 'drives_drive_format_item' in params:
            body_params = params['drives_drive_format_item']

        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.\
            select_header_accept(['application/json'])
        if not header_params['Accept']:
            del header_params['Accept']

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.\
            select_header_content_type(['application/json'])

        # Authentication setting
        auth_settings = ['basic_auth']

        response = self.api_client.call_api(resource_path, 'POST',
                                            path_params,
                                            query_params,
                                            header_params,
                                            body=body_params,
                                            post_params=form_params,
                                            files=local_var_files,
                                            response_type='Empty',
                                            auth_settings=auth_settings,
                                            callback=params.get('callback'))
        return response

    def create_drives_drive_purpose_item(self, drives_drive_purpose_item, lnn, driveid, **kwargs):
        """
        
        Assign a drive to a specific use case.

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please define a `callback` function
        to be invoked when receiving the response.
        >>> def callback_function(response):
        >>>     pprint(response)
        >>>
        >>> thread = api.create_drives_drive_purpose_item(drives_drive_purpose_item, lnn, driveid, callback=callback_function)

        :param callback function: The callback function
            for asynchronous request. (optional)
        :param DrivesDrivePurposeItem drives_drive_purpose_item:  (required)
        :param int lnn:  (required)
        :param str driveid:  (required)
        :return: Empty
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['drives_drive_purpose_item', 'lnn', 'driveid']
        all_params.append('callback')

        params = locals()
        for key, val in iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method create_drives_drive_purpose_item" % key
                )
            params[key] = val
        del params['kwargs']

        # verify the required parameter 'drives_drive_purpose_item' is set
        if ('drives_drive_purpose_item' not in params) or (params['drives_drive_purpose_item'] is None):
            raise ValueError("Missing the required parameter `drives_drive_purpose_item` when calling `create_drives_drive_purpose_item`")
        # verify the required parameter 'lnn' is set
        if ('lnn' not in params) or (params['lnn'] is None):
            raise ValueError("Missing the required parameter `lnn` when calling `create_drives_drive_purpose_item`")
        # verify the required parameter 'driveid' is set
        if ('driveid' not in params) or (params['driveid'] is None):
            raise ValueError("Missing the required parameter `driveid` when calling `create_drives_drive_purpose_item`")


        resource_path = '/platform/3/cluster/nodes/{Lnn}/drives/{Driveid}/purpose'.replace('{format}', 'json')
        path_params = {}
        if 'lnn' in params:
            path_params['Lnn'] = params['lnn']
        if 'driveid' in params:
            path_params['Driveid'] = params['driveid']

        query_params = {}

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        if 'drives_drive_purpose_item' in params:
            body_params = params['drives_drive_purpose_item']

        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.\
            select_header_accept(['application/json'])
        if not header_params['Accept']:
            del header_params['Accept']

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.\
            select_header_content_type(['application/json'])

        # Authentication setting
        auth_settings = ['basic_auth']

        response = self.api_client.call_api(resource_path, 'POST',
                                            path_params,
                                            query_params,
                                            header_params,
                                            body=body_params,
                                            post_params=form_params,
                                            files=local_var_files,
                                            response_type='Empty',
                                            auth_settings=auth_settings,
                                            callback=params.get('callback'))
        return response

    def create_drives_drive_smartfail_item(self, drives_drive_smartfail_item, lnn, driveid, **kwargs):
        """
        
        Remove a drive from use by OneFS.

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please define a `callback` function
        to be invoked when receiving the response.
        >>> def callback_function(response):
        >>>     pprint(response)
        >>>
        >>> thread = api.create_drives_drive_smartfail_item(drives_drive_smartfail_item, lnn, driveid, callback=callback_function)

        :param callback function: The callback function
            for asynchronous request. (optional)
        :param Empty drives_drive_smartfail_item:  (required)
        :param int lnn:  (required)
        :param str driveid:  (required)
        :return: Empty
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['drives_drive_smartfail_item', 'lnn', 'driveid']
        all_params.append('callback')

        params = locals()
        for key, val in iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method create_drives_drive_smartfail_item" % key
                )
            params[key] = val
        del params['kwargs']

        # verify the required parameter 'drives_drive_smartfail_item' is set
        if ('drives_drive_smartfail_item' not in params) or (params['drives_drive_smartfail_item'] is None):
            raise ValueError("Missing the required parameter `drives_drive_smartfail_item` when calling `create_drives_drive_smartfail_item`")
        # verify the required parameter 'lnn' is set
        if ('lnn' not in params) or (params['lnn'] is None):
            raise ValueError("Missing the required parameter `lnn` when calling `create_drives_drive_smartfail_item`")
        # verify the required parameter 'driveid' is set
        if ('driveid' not in params) or (params['driveid'] is None):
            raise ValueError("Missing the required parameter `driveid` when calling `create_drives_drive_smartfail_item`")


        resource_path = '/platform/3/cluster/nodes/{Lnn}/drives/{Driveid}/smartfail'.replace('{format}', 'json')
        path_params = {}
        if 'lnn' in params:
            path_params['Lnn'] = params['lnn']
        if 'driveid' in params:
            path_params['Driveid'] = params['driveid']

        query_params = {}

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        if 'drives_drive_smartfail_item' in params:
            body_params = params['drives_drive_smartfail_item']

        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.\
            select_header_accept(['application/json'])
        if not header_params['Accept']:
            del header_params['Accept']

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.\
            select_header_content_type(['application/json'])

        # Authentication setting
        auth_settings = ['basic_auth']

        response = self.api_client.call_api(resource_path, 'POST',
                                            path_params,
                                            query_params,
                                            header_params,
                                            body=body_params,
                                            post_params=form_params,
                                            files=local_var_files,
                                            response_type='Empty',
                                            auth_settings=auth_settings,
                                            callback=params.get('callback'))
        return response

    def create_drives_drive_stopfail_item(self, drives_drive_stopfail_item, lnn, driveid, **kwargs):
        """
        
        Stop restriping from a smartfailing drive.

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please define a `callback` function
        to be invoked when receiving the response.
        >>> def callback_function(response):
        >>>     pprint(response)
        >>>
        >>> thread = api.create_drives_drive_stopfail_item(drives_drive_stopfail_item, lnn, driveid, callback=callback_function)

        :param callback function: The callback function
            for asynchronous request. (optional)
        :param Empty drives_drive_stopfail_item:  (required)
        :param int lnn:  (required)
        :param str driveid:  (required)
        :return: Empty
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['drives_drive_stopfail_item', 'lnn', 'driveid']
        all_params.append('callback')

        params = locals()
        for key, val in iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method create_drives_drive_stopfail_item" % key
                )
            params[key] = val
        del params['kwargs']

        # verify the required parameter 'drives_drive_stopfail_item' is set
        if ('drives_drive_stopfail_item' not in params) or (params['drives_drive_stopfail_item'] is None):
            raise ValueError("Missing the required parameter `drives_drive_stopfail_item` when calling `create_drives_drive_stopfail_item`")
        # verify the required parameter 'lnn' is set
        if ('lnn' not in params) or (params['lnn'] is None):
            raise ValueError("Missing the required parameter `lnn` when calling `create_drives_drive_stopfail_item`")
        # verify the required parameter 'driveid' is set
        if ('driveid' not in params) or (params['driveid'] is None):
            raise ValueError("Missing the required parameter `driveid` when calling `create_drives_drive_stopfail_item`")


        resource_path = '/platform/3/cluster/nodes/{Lnn}/drives/{Driveid}/stopfail'.replace('{format}', 'json')
        path_params = {}
        if 'lnn' in params:
            path_params['Lnn'] = params['lnn']
        if 'driveid' in params:
            path_params['Driveid'] = params['driveid']

        query_params = {}

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        if 'drives_drive_stopfail_item' in params:
            body_params = params['drives_drive_stopfail_item']

        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.\
            select_header_accept(['application/json'])
        if not header_params['Accept']:
            del header_params['Accept']

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.\
            select_header_content_type(['application/json'])

        # Authentication setting
        auth_settings = ['basic_auth']

        response = self.api_client.call_api(resource_path, 'POST',
                                            path_params,
                                            query_params,
                                            header_params,
                                            body=body_params,
                                            post_params=form_params,
                                            files=local_var_files,
                                            response_type='Empty',
                                            auth_settings=auth_settings,
                                            callback=params.get('callback'))
        return response

    def create_drives_drive_suspend_item(self, drives_drive_suspend_item, lnn, driveid, **kwargs):
        """
        
        Temporarily remove a drive from use by OneFS.

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please define a `callback` function
        to be invoked when receiving the response.
        >>> def callback_function(response):
        >>>     pprint(response)
        >>>
        >>> thread = api.create_drives_drive_suspend_item(drives_drive_suspend_item, lnn, driveid, callback=callback_function)

        :param callback function: The callback function
            for asynchronous request. (optional)
        :param Empty drives_drive_suspend_item:  (required)
        :param int lnn:  (required)
        :param str driveid:  (required)
        :return: Empty
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['drives_drive_suspend_item', 'lnn', 'driveid']
        all_params.append('callback')

        params = locals()
        for key, val in iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method create_drives_drive_suspend_item" % key
                )
            params[key] = val
        del params['kwargs']

        # verify the required parameter 'drives_drive_suspend_item' is set
        if ('drives_drive_suspend_item' not in params) or (params['drives_drive_suspend_item'] is None):
            raise ValueError("Missing the required parameter `drives_drive_suspend_item` when calling `create_drives_drive_suspend_item`")
        # verify the required parameter 'lnn' is set
        if ('lnn' not in params) or (params['lnn'] is None):
            raise ValueError("Missing the required parameter `lnn` when calling `create_drives_drive_suspend_item`")
        # verify the required parameter 'driveid' is set
        if ('driveid' not in params) or (params['driveid'] is None):
            raise ValueError("Missing the required parameter `driveid` when calling `create_drives_drive_suspend_item`")


        resource_path = '/platform/3/cluster/nodes/{Lnn}/drives/{Driveid}/suspend'.replace('{format}', 'json')
        path_params = {}
        if 'lnn' in params:
            path_params['Lnn'] = params['lnn']
        if 'driveid' in params:
            path_params['Driveid'] = params['driveid']

        query_params = {}

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        if 'drives_drive_suspend_item' in params:
            body_params = params['drives_drive_suspend_item']

        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.\
            select_header_accept(['application/json'])
        if not header_params['Accept']:
            del header_params['Accept']

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.\
            select_header_content_type(['application/json'])

        # Authentication setting
        auth_settings = ['basic_auth']

        response = self.api_client.call_api(resource_path, 'POST',
                                            path_params,
                                            query_params,
                                            header_params,
                                            body=body_params,
                                            post_params=form_params,
                                            files=local_var_files,
                                            response_type='Empty',
                                            auth_settings=auth_settings,
                                            callback=params.get('callback'))
        return response

    def create_node_reboot_item(self, node_reboot_item, lnn, **kwargs):
        """
        
        Reboot the node specified by <LNN>.

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please define a `callback` function
        to be invoked when receiving the response.
        >>> def callback_function(response):
        >>>     pprint(response)
        >>>
        >>> thread = api.create_node_reboot_item(node_reboot_item, lnn, callback=callback_function)

        :param callback function: The callback function
            for asynchronous request. (optional)
        :param Empty node_reboot_item:  (required)
        :param int lnn:  (required)
        :return: Empty
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['node_reboot_item', 'lnn']
        all_params.append('callback')

        params = locals()
        for key, val in iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method create_node_reboot_item" % key
                )
            params[key] = val
        del params['kwargs']

        # verify the required parameter 'node_reboot_item' is set
        if ('node_reboot_item' not in params) or (params['node_reboot_item'] is None):
            raise ValueError("Missing the required parameter `node_reboot_item` when calling `create_node_reboot_item`")
        # verify the required parameter 'lnn' is set
        if ('lnn' not in params) or (params['lnn'] is None):
            raise ValueError("Missing the required parameter `lnn` when calling `create_node_reboot_item`")


        resource_path = '/platform/3/cluster/nodes/{Lnn}/reboot'.replace('{format}', 'json')
        path_params = {}
        if 'lnn' in params:
            path_params['Lnn'] = params['lnn']

        query_params = {}

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        if 'node_reboot_item' in params:
            body_params = params['node_reboot_item']

        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.\
            select_header_accept(['application/json'])
        if not header_params['Accept']:
            del header_params['Accept']

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.\
            select_header_content_type(['application/json'])

        # Authentication setting
        auth_settings = ['basic_auth']

        response = self.api_client.call_api(resource_path, 'POST',
                                            path_params,
                                            query_params,
                                            header_params,
                                            body=body_params,
                                            post_params=form_params,
                                            files=local_var_files,
                                            response_type='Empty',
                                            auth_settings=auth_settings,
                                            callback=params.get('callback'))
        return response

    def create_node_shutdown_item(self, node_shutdown_item, lnn, **kwargs):
        """
        
        Shutdown the node specified by <LNN>.

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please define a `callback` function
        to be invoked when receiving the response.
        >>> def callback_function(response):
        >>>     pprint(response)
        >>>
        >>> thread = api.create_node_shutdown_item(node_shutdown_item, lnn, callback=callback_function)

        :param callback function: The callback function
            for asynchronous request. (optional)
        :param Empty node_shutdown_item:  (required)
        :param int lnn:  (required)
        :return: Empty
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['node_shutdown_item', 'lnn']
        all_params.append('callback')

        params = locals()
        for key, val in iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method create_node_shutdown_item" % key
                )
            params[key] = val
        del params['kwargs']

        # verify the required parameter 'node_shutdown_item' is set
        if ('node_shutdown_item' not in params) or (params['node_shutdown_item'] is None):
            raise ValueError("Missing the required parameter `node_shutdown_item` when calling `create_node_shutdown_item`")
        # verify the required parameter 'lnn' is set
        if ('lnn' not in params) or (params['lnn'] is None):
            raise ValueError("Missing the required parameter `lnn` when calling `create_node_shutdown_item`")


        resource_path = '/platform/3/cluster/nodes/{Lnn}/shutdown'.replace('{format}', 'json')
        path_params = {}
        if 'lnn' in params:
            path_params['Lnn'] = params['lnn']

        query_params = {}

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        if 'node_shutdown_item' in params:
            body_params = params['node_shutdown_item']

        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.\
            select_header_accept(['application/json'])
        if not header_params['Accept']:
            del header_params['Accept']

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.\
            select_header_content_type(['application/json'])

        # Authentication setting
        auth_settings = ['basic_auth']

        response = self.api_client.call_api(resource_path, 'POST',
                                            path_params,
                                            query_params,
                                            header_params,
                                            body=body_params,
                                            post_params=form_params,
                                            files=local_var_files,
                                            response_type='Empty',
                                            auth_settings=auth_settings,
                                            callback=params.get('callback'))
        return response

    def get_drives_drive_firmware(self, lnn, driveid, **kwargs):
        """
        
        Retrieve drive firmware information.

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please define a `callback` function
        to be invoked when receiving the response.
        >>> def callback_function(response):
        >>>     pprint(response)
        >>>
        >>> thread = api.get_drives_drive_firmware(lnn, driveid, callback=callback_function)

        :param callback function: The callback function
            for asynchronous request. (optional)
        :param int lnn:  (required)
        :param str driveid:  (required)
        :return: DrivesDriveFirmware
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['lnn', 'driveid']
        all_params.append('callback')

        params = locals()
        for key, val in iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method get_drives_drive_firmware" % key
                )
            params[key] = val
        del params['kwargs']

        # verify the required parameter 'lnn' is set
        if ('lnn' not in params) or (params['lnn'] is None):
            raise ValueError("Missing the required parameter `lnn` when calling `get_drives_drive_firmware`")
        # verify the required parameter 'driveid' is set
        if ('driveid' not in params) or (params['driveid'] is None):
            raise ValueError("Missing the required parameter `driveid` when calling `get_drives_drive_firmware`")


        resource_path = '/platform/3/cluster/nodes/{Lnn}/drives/{Driveid}/firmware'.replace('{format}', 'json')
        path_params = {}
        if 'lnn' in params:
            path_params['Lnn'] = params['lnn']
        if 'driveid' in params:
            path_params['Driveid'] = params['driveid']

        query_params = {}

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None

        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.\
            select_header_accept(['application/json'])
        if not header_params['Accept']:
            del header_params['Accept']

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.\
            select_header_content_type(['application/json'])

        # Authentication setting
        auth_settings = ['basic_auth']

        response = self.api_client.call_api(resource_path, 'GET',
                                            path_params,
                                            query_params,
                                            header_params,
                                            body=body_params,
                                            post_params=form_params,
                                            files=local_var_files,
                                            response_type='DrivesDriveFirmware',
                                            auth_settings=auth_settings,
                                            callback=params.get('callback'))
        return response

    def get_node_drive(self, node_drive_id, lnn, **kwargs):
        """
        
        Retrieve drive information.

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please define a `callback` function
        to be invoked when receiving the response.
        >>> def callback_function(response):
        >>>     pprint(response)
        >>>
        >>> thread = api.get_node_drive(node_drive_id, lnn, callback=callback_function)

        :param callback function: The callback function
            for asynchronous request. (optional)
        :param str node_drive_id: Retrieve drive information. (required)
        :param int lnn:  (required)
        :return: NodeDrives
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['node_drive_id', 'lnn']
        all_params.append('callback')

        params = locals()
        for key, val in iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method get_node_drive" % key
                )
            params[key] = val
        del params['kwargs']

        # verify the required parameter 'node_drive_id' is set
        if ('node_drive_id' not in params) or (params['node_drive_id'] is None):
            raise ValueError("Missing the required parameter `node_drive_id` when calling `get_node_drive`")
        # verify the required parameter 'lnn' is set
        if ('lnn' not in params) or (params['lnn'] is None):
            raise ValueError("Missing the required parameter `lnn` when calling `get_node_drive`")


        resource_path = '/platform/3/cluster/nodes/{Lnn}/drives/{NodeDriveId}'.replace('{format}', 'json')
        path_params = {}
        if 'node_drive_id' in params:
            path_params['NodeDriveId'] = params['node_drive_id']
        if 'lnn' in params:
            path_params['Lnn'] = params['lnn']

        query_params = {}

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None

        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.\
            select_header_accept(['application/json'])
        if not header_params['Accept']:
            del header_params['Accept']

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.\
            select_header_content_type(['application/json'])

        # Authentication setting
        auth_settings = ['basic_auth']

        response = self.api_client.call_api(resource_path, 'GET',
                                            path_params,
                                            query_params,
                                            header_params,
                                            body=body_params,
                                            post_params=form_params,
                                            files=local_var_files,
                                            response_type='NodeDrives',
                                            auth_settings=auth_settings,
                                            callback=params.get('callback'))
        return response

    def get_node_drives(self, lnn, **kwargs):
        """
        
        List the drives on this node.

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please define a `callback` function
        to be invoked when receiving the response.
        >>> def callback_function(response):
        >>>     pprint(response)
        >>>
        >>> thread = api.get_node_drives(lnn, callback=callback_function)

        :param callback function: The callback function
            for asynchronous request. (optional)
        :param int lnn:  (required)
        :return: NodeDrives
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['lnn']
        all_params.append('callback')

        params = locals()
        for key, val in iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method get_node_drives" % key
                )
            params[key] = val
        del params['kwargs']

        # verify the required parameter 'lnn' is set
        if ('lnn' not in params) or (params['lnn'] is None):
            raise ValueError("Missing the required parameter `lnn` when calling `get_node_drives`")


        resource_path = '/platform/3/cluster/nodes/{Lnn}/drives'.replace('{format}', 'json')
        path_params = {}
        if 'lnn' in params:
            path_params['Lnn'] = params['lnn']

        query_params = {}

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None

        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.\
            select_header_accept(['application/json'])
        if not header_params['Accept']:
            del header_params['Accept']

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.\
            select_header_content_type(['application/json'])

        # Authentication setting
        auth_settings = ['basic_auth']

        response = self.api_client.call_api(resource_path, 'GET',
                                            path_params,
                                            query_params,
                                            header_params,
                                            body=body_params,
                                            post_params=form_params,
                                            files=local_var_files,
                                            response_type='NodeDrives',
                                            auth_settings=auth_settings,
                                            callback=params.get('callback'))
        return response

    def get_node_drives_purposelist(self, lnn, **kwargs):
        """
        
        Lists the available purposes for drives in this node.

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please define a `callback` function
        to be invoked when receiving the response.
        >>> def callback_function(response):
        >>>     pprint(response)
        >>>
        >>> thread = api.get_node_drives_purposelist(lnn, callback=callback_function)

        :param callback function: The callback function
            for asynchronous request. (optional)
        :param int lnn:  (required)
        :return: NodeDrivesPurposelist
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['lnn']
        all_params.append('callback')

        params = locals()
        for key, val in iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method get_node_drives_purposelist" % key
                )
            params[key] = val
        del params['kwargs']

        # verify the required parameter 'lnn' is set
        if ('lnn' not in params) or (params['lnn'] is None):
            raise ValueError("Missing the required parameter `lnn` when calling `get_node_drives_purposelist`")


        resource_path = '/platform/3/cluster/nodes/{Lnn}/drives-purposelist'.replace('{format}', 'json')
        path_params = {}
        if 'lnn' in params:
            path_params['Lnn'] = params['lnn']

        query_params = {}

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None

        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.\
            select_header_accept(['application/json'])
        if not header_params['Accept']:
            del header_params['Accept']

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.\
            select_header_content_type(['application/json'])

        # Authentication setting
        auth_settings = ['basic_auth']

        response = self.api_client.call_api(resource_path, 'GET',
                                            path_params,
                                            query_params,
                                            header_params,
                                            body=body_params,
                                            post_params=form_params,
                                            files=local_var_files,
                                            response_type='NodeDrivesPurposelist',
                                            auth_settings=auth_settings,
                                            callback=params.get('callback'))
        return response

    def get_node_hardware(self, lnn, **kwargs):
        """
        
        Retrieve node hardware identity information.

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please define a `callback` function
        to be invoked when receiving the response.
        >>> def callback_function(response):
        >>>     pprint(response)
        >>>
        >>> thread = api.get_node_hardware(lnn, callback=callback_function)

        :param callback function: The callback function
            for asynchronous request. (optional)
        :param int lnn:  (required)
        :return: NodeHardware
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['lnn']
        all_params.append('callback')

        params = locals()
        for key, val in iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method get_node_hardware" % key
                )
            params[key] = val
        del params['kwargs']

        # verify the required parameter 'lnn' is set
        if ('lnn' not in params) or (params['lnn'] is None):
            raise ValueError("Missing the required parameter `lnn` when calling `get_node_hardware`")


        resource_path = '/platform/3/cluster/nodes/{Lnn}/hardware'.replace('{format}', 'json')
        path_params = {}
        if 'lnn' in params:
            path_params['Lnn'] = params['lnn']

        query_params = {}

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None

        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.\
            select_header_accept(['application/json'])
        if not header_params['Accept']:
            del header_params['Accept']

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.\
            select_header_content_type(['application/json'])

        # Authentication setting
        auth_settings = ['basic_auth']

        response = self.api_client.call_api(resource_path, 'GET',
                                            path_params,
                                            query_params,
                                            header_params,
                                            body=body_params,
                                            post_params=form_params,
                                            files=local_var_files,
                                            response_type='NodeHardware',
                                            auth_settings=auth_settings,
                                            callback=params.get('callback'))
        return response

    def get_node_partitions(self, lnn, **kwargs):
        """
        
        Retrieve node partition information.

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please define a `callback` function
        to be invoked when receiving the response.
        >>> def callback_function(response):
        >>>     pprint(response)
        >>>
        >>> thread = api.get_node_partitions(lnn, callback=callback_function)

        :param callback function: The callback function
            for asynchronous request. (optional)
        :param int lnn:  (required)
        :return: NodePartitions
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['lnn']
        all_params.append('callback')

        params = locals()
        for key, val in iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method get_node_partitions" % key
                )
            params[key] = val
        del params['kwargs']

        # verify the required parameter 'lnn' is set
        if ('lnn' not in params) or (params['lnn'] is None):
            raise ValueError("Missing the required parameter `lnn` when calling `get_node_partitions`")


        resource_path = '/platform/3/cluster/nodes/{Lnn}/partitions'.replace('{format}', 'json')
        path_params = {}
        if 'lnn' in params:
            path_params['Lnn'] = params['lnn']

        query_params = {}

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None

        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.\
            select_header_accept(['application/json'])
        if not header_params['Accept']:
            del header_params['Accept']

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.\
            select_header_content_type(['application/json'])

        # Authentication setting
        auth_settings = ['basic_auth']

        response = self.api_client.call_api(resource_path, 'GET',
                                            path_params,
                                            query_params,
                                            header_params,
                                            body=body_params,
                                            post_params=form_params,
                                            files=local_var_files,
                                            response_type='NodePartitions',
                                            auth_settings=auth_settings,
                                            callback=params.get('callback'))
        return response

    def get_node_sensors(self, lnn, **kwargs):
        """
        
        Retrieve node sensor information.

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please define a `callback` function
        to be invoked when receiving the response.
        >>> def callback_function(response):
        >>>     pprint(response)
        >>>
        >>> thread = api.get_node_sensors(lnn, callback=callback_function)

        :param callback function: The callback function
            for asynchronous request. (optional)
        :param int lnn:  (required)
        :return: NodeSensors
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['lnn']
        all_params.append('callback')

        params = locals()
        for key, val in iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method get_node_sensors" % key
                )
            params[key] = val
        del params['kwargs']

        # verify the required parameter 'lnn' is set
        if ('lnn' not in params) or (params['lnn'] is None):
            raise ValueError("Missing the required parameter `lnn` when calling `get_node_sensors`")


        resource_path = '/platform/3/cluster/nodes/{Lnn}/sensors'.replace('{format}', 'json')
        path_params = {}
        if 'lnn' in params:
            path_params['Lnn'] = params['lnn']

        query_params = {}

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None

        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.\
            select_header_accept(['application/json'])
        if not header_params['Accept']:
            del header_params['Accept']

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.\
            select_header_content_type(['application/json'])

        # Authentication setting
        auth_settings = ['basic_auth']

        response = self.api_client.call_api(resource_path, 'GET',
                                            path_params,
                                            query_params,
                                            header_params,
                                            body=body_params,
                                            post_params=form_params,
                                            files=local_var_files,
                                            response_type='NodeSensors',
                                            auth_settings=auth_settings,
                                            callback=params.get('callback'))
        return response

    def get_node_state(self, lnn, **kwargs):
        """
        
        Retrieve node state information.

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please define a `callback` function
        to be invoked when receiving the response.
        >>> def callback_function(response):
        >>>     pprint(response)
        >>>
        >>> thread = api.get_node_state(lnn, callback=callback_function)

        :param callback function: The callback function
            for asynchronous request. (optional)
        :param int lnn:  (required)
        :return: NodeState
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['lnn']
        all_params.append('callback')

        params = locals()
        for key, val in iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method get_node_state" % key
                )
            params[key] = val
        del params['kwargs']

        # verify the required parameter 'lnn' is set
        if ('lnn' not in params) or (params['lnn'] is None):
            raise ValueError("Missing the required parameter `lnn` when calling `get_node_state`")


        resource_path = '/platform/3/cluster/nodes/{Lnn}/state'.replace('{format}', 'json')
        path_params = {}
        if 'lnn' in params:
            path_params['Lnn'] = params['lnn']

        query_params = {}

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None

        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.\
            select_header_accept(['application/json'])
        if not header_params['Accept']:
            del header_params['Accept']

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.\
            select_header_content_type(['application/json'])

        # Authentication setting
        auth_settings = ['basic_auth']

        response = self.api_client.call_api(resource_path, 'GET',
                                            path_params,
                                            query_params,
                                            header_params,
                                            body=body_params,
                                            post_params=form_params,
                                            files=local_var_files,
                                            response_type='NodeState',
                                            auth_settings=auth_settings,
                                            callback=params.get('callback'))
        return response

    def get_node_state_readonly(self, lnn, **kwargs):
        """
        
        Retrieve node readonly state information.

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please define a `callback` function
        to be invoked when receiving the response.
        >>> def callback_function(response):
        >>>     pprint(response)
        >>>
        >>> thread = api.get_node_state_readonly(lnn, callback=callback_function)

        :param callback function: The callback function
            for asynchronous request. (optional)
        :param int lnn:  (required)
        :return: NodeStateReadonly
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['lnn']
        all_params.append('callback')

        params = locals()
        for key, val in iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method get_node_state_readonly" % key
                )
            params[key] = val
        del params['kwargs']

        # verify the required parameter 'lnn' is set
        if ('lnn' not in params) or (params['lnn'] is None):
            raise ValueError("Missing the required parameter `lnn` when calling `get_node_state_readonly`")


        resource_path = '/platform/3/cluster/nodes/{Lnn}/state/readonly'.replace('{format}', 'json')
        path_params = {}
        if 'lnn' in params:
            path_params['Lnn'] = params['lnn']

        query_params = {}

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None

        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.\
            select_header_accept(['application/json'])
        if not header_params['Accept']:
            del header_params['Accept']

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.\
            select_header_content_type(['application/json'])

        # Authentication setting
        auth_settings = ['basic_auth']

        response = self.api_client.call_api(resource_path, 'GET',
                                            path_params,
                                            query_params,
                                            header_params,
                                            body=body_params,
                                            post_params=form_params,
                                            files=local_var_files,
                                            response_type='NodeStateReadonly',
                                            auth_settings=auth_settings,
                                            callback=params.get('callback'))
        return response

    def get_node_state_servicelight(self, lnn, **kwargs):
        """
        
        Retrieve node service light state information.

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please define a `callback` function
        to be invoked when receiving the response.
        >>> def callback_function(response):
        >>>     pprint(response)
        >>>
        >>> thread = api.get_node_state_servicelight(lnn, callback=callback_function)

        :param callback function: The callback function
            for asynchronous request. (optional)
        :param int lnn:  (required)
        :return: NodeStateServicelight
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['lnn']
        all_params.append('callback')

        params = locals()
        for key, val in iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method get_node_state_servicelight" % key
                )
            params[key] = val
        del params['kwargs']

        # verify the required parameter 'lnn' is set
        if ('lnn' not in params) or (params['lnn'] is None):
            raise ValueError("Missing the required parameter `lnn` when calling `get_node_state_servicelight`")


        resource_path = '/platform/3/cluster/nodes/{Lnn}/state/servicelight'.replace('{format}', 'json')
        path_params = {}
        if 'lnn' in params:
            path_params['Lnn'] = params['lnn']

        query_params = {}

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None

        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.\
            select_header_accept(['application/json'])
        if not header_params['Accept']:
            del header_params['Accept']

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.\
            select_header_content_type(['application/json'])

        # Authentication setting
        auth_settings = ['basic_auth']

        response = self.api_client.call_api(resource_path, 'GET',
                                            path_params,
                                            query_params,
                                            header_params,
                                            body=body_params,
                                            post_params=form_params,
                                            files=local_var_files,
                                            response_type='NodeStateServicelight',
                                            auth_settings=auth_settings,
                                            callback=params.get('callback'))
        return response

    def get_node_state_smartfail(self, lnn, **kwargs):
        """
        
        Retrieve node smartfail state information.

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please define a `callback` function
        to be invoked when receiving the response.
        >>> def callback_function(response):
        >>>     pprint(response)
        >>>
        >>> thread = api.get_node_state_smartfail(lnn, callback=callback_function)

        :param callback function: The callback function
            for asynchronous request. (optional)
        :param int lnn:  (required)
        :return: NodeStateSmartfail
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['lnn']
        all_params.append('callback')

        params = locals()
        for key, val in iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method get_node_state_smartfail" % key
                )
            params[key] = val
        del params['kwargs']

        # verify the required parameter 'lnn' is set
        if ('lnn' not in params) or (params['lnn'] is None):
            raise ValueError("Missing the required parameter `lnn` when calling `get_node_state_smartfail`")


        resource_path = '/platform/3/cluster/nodes/{Lnn}/state/smartfail'.replace('{format}', 'json')
        path_params = {}
        if 'lnn' in params:
            path_params['Lnn'] = params['lnn']

        query_params = {}

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None

        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.\
            select_header_accept(['application/json'])
        if not header_params['Accept']:
            del header_params['Accept']

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.\
            select_header_content_type(['application/json'])

        # Authentication setting
        auth_settings = ['basic_auth']

        response = self.api_client.call_api(resource_path, 'GET',
                                            path_params,
                                            query_params,
                                            header_params,
                                            body=body_params,
                                            post_params=form_params,
                                            files=local_var_files,
                                            response_type='NodeStateSmartfail',
                                            auth_settings=auth_settings,
                                            callback=params.get('callback'))
        return response

    def get_node_status(self, lnn, **kwargs):
        """
        
        Retrieve node status information.

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please define a `callback` function
        to be invoked when receiving the response.
        >>> def callback_function(response):
        >>>     pprint(response)
        >>>
        >>> thread = api.get_node_status(lnn, callback=callback_function)

        :param callback function: The callback function
            for asynchronous request. (optional)
        :param int lnn:  (required)
        :return: NodeStatus
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['lnn']
        all_params.append('callback')

        params = locals()
        for key, val in iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method get_node_status" % key
                )
            params[key] = val
        del params['kwargs']

        # verify the required parameter 'lnn' is set
        if ('lnn' not in params) or (params['lnn'] is None):
            raise ValueError("Missing the required parameter `lnn` when calling `get_node_status`")


        resource_path = '/platform/3/cluster/nodes/{Lnn}/status'.replace('{format}', 'json')
        path_params = {}
        if 'lnn' in params:
            path_params['Lnn'] = params['lnn']

        query_params = {}

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None

        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.\
            select_header_accept(['application/json'])
        if not header_params['Accept']:
            del header_params['Accept']

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.\
            select_header_content_type(['application/json'])

        # Authentication setting
        auth_settings = ['basic_auth']

        response = self.api_client.call_api(resource_path, 'GET',
                                            path_params,
                                            query_params,
                                            header_params,
                                            body=body_params,
                                            post_params=form_params,
                                            files=local_var_files,
                                            response_type='NodeStatus',
                                            auth_settings=auth_settings,
                                            callback=params.get('callback'))
        return response

    def get_node_status_batterystatus(self, lnn, **kwargs):
        """
        
        Retrieve node battery status information.

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please define a `callback` function
        to be invoked when receiving the response.
        >>> def callback_function(response):
        >>>     pprint(response)
        >>>
        >>> thread = api.get_node_status_batterystatus(lnn, callback=callback_function)

        :param callback function: The callback function
            for asynchronous request. (optional)
        :param int lnn:  (required)
        :return: NodeStatusBatterystatus
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['lnn']
        all_params.append('callback')

        params = locals()
        for key, val in iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method get_node_status_batterystatus" % key
                )
            params[key] = val
        del params['kwargs']

        # verify the required parameter 'lnn' is set
        if ('lnn' not in params) or (params['lnn'] is None):
            raise ValueError("Missing the required parameter `lnn` when calling `get_node_status_batterystatus`")


        resource_path = '/platform/3/cluster/nodes/{Lnn}/status/batterystatus'.replace('{format}', 'json')
        path_params = {}
        if 'lnn' in params:
            path_params['Lnn'] = params['lnn']

        query_params = {}

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None

        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.\
            select_header_accept(['application/json'])
        if not header_params['Accept']:
            del header_params['Accept']

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.\
            select_header_content_type(['application/json'])

        # Authentication setting
        auth_settings = ['basic_auth']

        response = self.api_client.call_api(resource_path, 'GET',
                                            path_params,
                                            query_params,
                                            header_params,
                                            body=body_params,
                                            post_params=form_params,
                                            files=local_var_files,
                                            response_type='NodeStatusBatterystatus',
                                            auth_settings=auth_settings,
                                            callback=params.get('callback'))
        return response

    def list_drives_drive_firmware_update(self, lnn, driveid, **kwargs):
        """
        
        Retrieve firmware update information.

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please define a `callback` function
        to be invoked when receiving the response.
        >>> def callback_function(response):
        >>>     pprint(response)
        >>>
        >>> thread = api.list_drives_drive_firmware_update(lnn, driveid, callback=callback_function)

        :param callback function: The callback function
            for asynchronous request. (optional)
        :param int lnn:  (required)
        :param str driveid:  (required)
        :return: DrivesDriveFirmwareUpdate
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['lnn', 'driveid']
        all_params.append('callback')

        params = locals()
        for key, val in iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method list_drives_drive_firmware_update" % key
                )
            params[key] = val
        del params['kwargs']

        # verify the required parameter 'lnn' is set
        if ('lnn' not in params) or (params['lnn'] is None):
            raise ValueError("Missing the required parameter `lnn` when calling `list_drives_drive_firmware_update`")
        # verify the required parameter 'driveid' is set
        if ('driveid' not in params) or (params['driveid'] is None):
            raise ValueError("Missing the required parameter `driveid` when calling `list_drives_drive_firmware_update`")


        resource_path = '/platform/3/cluster/nodes/{Lnn}/drives/{Driveid}/firmware/update'.replace('{format}', 'json')
        path_params = {}
        if 'lnn' in params:
            path_params['Lnn'] = params['lnn']
        if 'driveid' in params:
            path_params['Driveid'] = params['driveid']

        query_params = {}

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None

        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.\
            select_header_accept(['application/json'])
        if not header_params['Accept']:
            del header_params['Accept']

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.\
            select_header_content_type(['application/json'])

        # Authentication setting
        auth_settings = ['basic_auth']

        response = self.api_client.call_api(resource_path, 'GET',
                                            path_params,
                                            query_params,
                                            header_params,
                                            body=body_params,
                                            post_params=form_params,
                                            files=local_var_files,
                                            response_type='DrivesDriveFirmwareUpdate',
                                            auth_settings=auth_settings,
                                            callback=params.get('callback'))
        return response

    def update_node_state_readonly(self, node_state_readonly, lnn, **kwargs):
        """
        
        Modify one or more node readonly state settings.

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please define a `callback` function
        to be invoked when receiving the response.
        >>> def callback_function(response):
        >>>     pprint(response)
        >>>
        >>> thread = api.update_node_state_readonly(node_state_readonly, lnn, callback=callback_function)

        :param callback function: The callback function
            for asynchronous request. (optional)
        :param NodeStateReadonlyExtended node_state_readonly:  (required)
        :param int lnn:  (required)
        :return: None
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['node_state_readonly', 'lnn']
        all_params.append('callback')

        params = locals()
        for key, val in iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method update_node_state_readonly" % key
                )
            params[key] = val
        del params['kwargs']

        # verify the required parameter 'node_state_readonly' is set
        if ('node_state_readonly' not in params) or (params['node_state_readonly'] is None):
            raise ValueError("Missing the required parameter `node_state_readonly` when calling `update_node_state_readonly`")
        # verify the required parameter 'lnn' is set
        if ('lnn' not in params) or (params['lnn'] is None):
            raise ValueError("Missing the required parameter `lnn` when calling `update_node_state_readonly`")


        resource_path = '/platform/3/cluster/nodes/{Lnn}/state/readonly'.replace('{format}', 'json')
        path_params = {}
        if 'lnn' in params:
            path_params['Lnn'] = params['lnn']

        query_params = {}

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        if 'node_state_readonly' in params:
            body_params = params['node_state_readonly']

        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.\
            select_header_accept(['application/json'])
        if not header_params['Accept']:
            del header_params['Accept']

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.\
            select_header_content_type(['application/json'])

        # Authentication setting
        auth_settings = ['basic_auth']

        response = self.api_client.call_api(resource_path, 'PUT',
                                            path_params,
                                            query_params,
                                            header_params,
                                            body=body_params,
                                            post_params=form_params,
                                            files=local_var_files,
                                            response_type=None,
                                            auth_settings=auth_settings,
                                            callback=params.get('callback'))
        return response

    def update_node_state_servicelight(self, node_state_servicelight, lnn, **kwargs):
        """
        
        Modify one or more node service light state settings.

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please define a `callback` function
        to be invoked when receiving the response.
        >>> def callback_function(response):
        >>>     pprint(response)
        >>>
        >>> thread = api.update_node_state_servicelight(node_state_servicelight, lnn, callback=callback_function)

        :param callback function: The callback function
            for asynchronous request. (optional)
        :param NodeStateServicelightExtended node_state_servicelight:  (required)
        :param int lnn:  (required)
        :return: None
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['node_state_servicelight', 'lnn']
        all_params.append('callback')

        params = locals()
        for key, val in iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method update_node_state_servicelight" % key
                )
            params[key] = val
        del params['kwargs']

        # verify the required parameter 'node_state_servicelight' is set
        if ('node_state_servicelight' not in params) or (params['node_state_servicelight'] is None):
            raise ValueError("Missing the required parameter `node_state_servicelight` when calling `update_node_state_servicelight`")
        # verify the required parameter 'lnn' is set
        if ('lnn' not in params) or (params['lnn'] is None):
            raise ValueError("Missing the required parameter `lnn` when calling `update_node_state_servicelight`")


        resource_path = '/platform/3/cluster/nodes/{Lnn}/state/servicelight'.replace('{format}', 'json')
        path_params = {}
        if 'lnn' in params:
            path_params['Lnn'] = params['lnn']

        query_params = {}

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        if 'node_state_servicelight' in params:
            body_params = params['node_state_servicelight']

        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.\
            select_header_accept(['application/json'])
        if not header_params['Accept']:
            del header_params['Accept']

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.\
            select_header_content_type(['application/json'])

        # Authentication setting
        auth_settings = ['basic_auth']

        response = self.api_client.call_api(resource_path, 'PUT',
                                            path_params,
                                            query_params,
                                            header_params,
                                            body=body_params,
                                            post_params=form_params,
                                            files=local_var_files,
                                            response_type=None,
                                            auth_settings=auth_settings,
                                            callback=params.get('callback'))
        return response

    def update_node_state_smartfail(self, node_state_smartfail, lnn, **kwargs):
        """
        
        Modify smartfail state of the node.  Only the 'smartfailed' body member has any effect on node smartfail state.

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please define a `callback` function
        to be invoked when receiving the response.
        >>> def callback_function(response):
        >>>     pprint(response)
        >>>
        >>> thread = api.update_node_state_smartfail(node_state_smartfail, lnn, callback=callback_function)

        :param callback function: The callback function
            for asynchronous request. (optional)
        :param NodeStateSmartfailExtended node_state_smartfail:  (required)
        :param int lnn:  (required)
        :return: None
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['node_state_smartfail', 'lnn']
        all_params.append('callback')

        params = locals()
        for key, val in iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method update_node_state_smartfail" % key
                )
            params[key] = val
        del params['kwargs']

        # verify the required parameter 'node_state_smartfail' is set
        if ('node_state_smartfail' not in params) or (params['node_state_smartfail'] is None):
            raise ValueError("Missing the required parameter `node_state_smartfail` when calling `update_node_state_smartfail`")
        # verify the required parameter 'lnn' is set
        if ('lnn' not in params) or (params['lnn'] is None):
            raise ValueError("Missing the required parameter `lnn` when calling `update_node_state_smartfail`")


        resource_path = '/platform/3/cluster/nodes/{Lnn}/state/smartfail'.replace('{format}', 'json')
        path_params = {}
        if 'lnn' in params:
            path_params['Lnn'] = params['lnn']

        query_params = {}

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        if 'node_state_smartfail' in params:
            body_params = params['node_state_smartfail']

        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.\
            select_header_accept(['application/json'])
        if not header_params['Accept']:
            del header_params['Accept']

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.\
            select_header_content_type(['application/json'])

        # Authentication setting
        auth_settings = ['basic_auth']

        response = self.api_client.call_api(resource_path, 'PUT',
                                            path_params,
                                            query_params,
                                            header_params,
                                            body=body_params,
                                            post_params=form_params,
                                            files=local_var_files,
                                            response_type=None,
                                            auth_settings=auth_settings,
                                            callback=params.get('callback'))
        return response
