ironic-python-agent/ironic_python_agent/ironic_api_client.py

"""
Copyright 2013 Rackspace, Inc.

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

import json
import requests

from ironic_python_agent import encoding
from ironic_python_agent import errors
from ironic_python_agent.openstack.common import log
from ironic_python_agent.openstack.common import loopingcall


class APIClient(object):
    api_version = 'v1'
    payload_version = '1'

    def __init__(self, api_url):
        self.api_url = api_url.rstrip('/')
        self.session = requests.Session()
        self.encoder = encoding.RESTJSONEncoder()
        self.log = log.getLogger(__name__)

    def _request(self, method, path, data=None):
        request_url = '{api_url}{path}'.format(api_url=self.api_url, path=path)

        if data is not None:
            data = self.encoder.encode(data)

        request_headers = {
            'Content-Type': 'application/json',
            'Accept': 'application/json',
        }

        return self.session.request(method,
                                    request_url,
                                    headers=request_headers,
                                    data=data)

    def heartbeat(self, uuid, advertise_address):
        path = '/{api_version}/nodes/{uuid}/vendor_passthru/heartbeat'.format(
            api_version=self.api_version,
            uuid=uuid
        )
        data = {
            'agent_url': self._get_agent_url(advertise_address)
        }
        try:
            response = self._request('POST', path, data=data)
        except Exception as e:
            raise errors.HeartbeatError(str(e))

        if response.status_code != requests.codes.NO_CONTENT:
            msg = 'Invalid status code: {0}'.format(response.status_code)
            raise errors.HeartbeatError(msg)

        try:
            return float(response.headers['Heartbeat-Before'])
        except KeyError:
            raise errors.HeartbeatError('Missing Heartbeat-Before header')
        except Exception:
            raise errors.HeartbeatError('Invalid Heartbeat-Before header')

    def lookup_node(self, hardware_info, timeout, starting_interval):
        timer = loopingcall.DynamicLoopingCall(
            self._do_lookup,
            hardware_info=hardware_info,
            intervals=[starting_interval],
            total_time=[0],
            timeout=timeout)
        node_content = timer.start().wait()

        # True is returned on timeout
        if node_content is True:
            raise errors.LookupNodeError('Could not look up node info. Check '
                                         'logs for details.')
        return node_content

    def _do_lookup(self, hardware_info, timeout, intervals=[1],
                   total_time=[0]):
        """The actual call to lookup a node. Should be called inside
        loopingcall.DynamicLoopingCall.

        intervals and total_time are mutable so it can be changed by each run
        in the looping call and accessed/changed on the next run.
        """
        def next_interval(timeout, intervals=[], total_time=[]):
            """Function to calculate what the next interval should be. Uses
            exponential backoff and raises an exception (that won't
            be caught by do_lookup) to kill the looping call if it goes too
            long
            """
            new_interval = intervals[-1] * 2
            if total_time[0] + new_interval > timeout:
                # No retvalue signifies error
                raise loopingcall.LoopingCallDone()

            total_time[0] += new_interval
            intervals.append(new_interval)
            return new_interval

        path = '/{api_version}/drivers/teeth/vendor_passthru/lookup'.format(
            api_version=self.api_version
        )
        # This hardware won't be saved on the node currently, because of
        # how driver_vendor_passthru is implemented (no node saving).
        data = {
            'version': self.payload_version,
            'inventory': hardware_info
        }

        # Make the POST, make sure we get back normal data/status codes and
        # content
        try:
            response = self._request('POST', path, data=data)
        except Exception as e:
            self.log.warning('POST failed: %s' % str(e))
            return next_interval(timeout, intervals, total_time)

        if response.status_code != requests.codes.OK:
            self.log.warning('Invalid status code: %s' %
                             response.status_code)

            return next_interval(timeout, intervals, total_time)

        try:
            content = json.loads(response.content)
        except Exception as e:
            self.log.warning('Error decoding response: %s' % str(e))
            return next_interval(timeout, intervals, total_time)

        # Check for valid response data
        if 'node' not in content or 'uuid' not in content['node']:
            self.log.warning('Got invalid node data from the API: %s' %
                             content)
            return next_interval(timeout, intervals, total_time)

        if 'heartbeat_timeout' not in content:
            self.log.warning('Got invalid heartbeat from the API: %s' %
                             content)
            return next_interval(timeout, intervals, total_time)

        # Got valid content
        raise loopingcall.LoopingCallDone(retvalue=content)

    def _get_agent_url(self, advertise_address):
        return 'http://{0}:{1}'.format(advertise_address[0],
                                       advertise_address[1])