openstack/zun
Code Issues Proposed changes

Add Higgins Service Controller

Browse Source 
This patch adds higgins service controller which has follow APIs:

1. get_all: It returns the list of Higgins Service with information
            like status, disabled etc.

Co-Authored-By: Hongbin Lu <hongbin.lu@huawei.com>

Change-Id: Id78990f0a1e317700ec34f3339b1c039c69a0dc0
This commit is contained in:
Vivek Jain 2016-06-05 00:55:25 +05:30 committed by Hongbin Lu
parent 306b7c77a3
commit be872a54bc
12 changed files with 525 additions and 24 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
etc/zun/policy.json
View File

@ -1 +1,5 @@
{}
{
"zun-service:get_all": "rule:admin_api"
}

5
zun/api/controllers/base.py
View File

@ -24,8 +24,9 @@ class APIBase(object):
def __setattr__(self, field, value):
if field in self.fields:
validator = self.fields[field]['validate']
value = validator(value)
super(APIBase, self).__setattr__(field, value)
kwargs = self.fields[field].get('validate_args', {})
value = validator(value, **kwargs)
super(APIBase, self).__setattr__(field, value)
def as_dict(self):
"""Render this object as a dict of its fields."""

3
zun/api/controllers/root.py
View File

@ -16,6 +16,7 @@ from pecan import rest
from zun.api.controllers import base
from zun.api.controllers import link
from zun.api.controllers import types
from zun.api.controllers import v1
class Version(base.APIBase):
@ -75,7 +76,7 @@ class RootController(rest.RestController):
_default_version = 'v1'
"""The default API version"""
# v1 = v1.Controller()
v1 = v1.Controller()
@pecan.expose('json')
def get(self):

77
zun/api/controllers/types.py
View File

@ -11,11 +11,14 @@
# under the License.
import logging
import six
from oslo_utils import strutils
from zun.common import exception
from zun.common.i18n import _
from zun.common.i18n import _LE
LOG = logging.getLogger(__name__)
@ -24,6 +27,72 @@ class Text(object):
@classmethod
def validate(cls, value):
if value is None:
return None
if not isinstance(value, six.string_types):
raise exception.InvalidValue(value=value, type=cls.type_name)
return value
class String(object):
type_name = 'String'
@classmethod
def validate(cls, value, min_length=0, max_length=None):
if value is None:
return None
try:
strutils.check_string_length(value, min_length=min_length,
max_length=max_length)
except TypeError:
raise exception.InvalidValue(value=value, type=cls.type_name)
except ValueError as e:
raise exception.InvalidValue(message=str(e))
return value
class Integer(object):
type_name = 'Integer'
@classmethod
def validate(cls, value, minimum=None):
if value is None:
return None
if not isinstance(value, six.integer_types):
try:
value = int(value)
except Exception:
LOG.exception(_LE('Failed to convert value to int'))
raise exception.InvalidValue(value=value, type=cls.type_name)
if minimum is not None and value < minimum:
message = _("Integer '%(value)s' is smaller than "
"'%(min)d'.") % {'value': value, 'min': minimum}
raise exception.InvalidValue(message=message)
return value
class Bool(object):
type_name = 'Bool'
@classmethod
def validate(cls, value, default=None):
if value is None:
value = default
if not isinstance(value, bool):
try:
value = strutils.bool_from_string(value, strict=True)
except Exception:
LOG.exception(_LE('Failed to convert value to bool'))
raise exception.InvalidValue(value=value, type=cls.type_name)
return value
@ -34,6 +103,9 @@ class Custom(object):
self.type_name = self.user_class.__name__
def validate(self, value):
if value is None:
return None
if not isinstance(value, self.user_class):
try:
value = self.user_class(**value)
@ -51,6 +123,9 @@ class List(object):
self.type_name = 'List(%s)' % self.type.type_name
def validate(self, value):
if value is None:
return None
if not isinstance(value, list):
raise exception.InvalidValue(value=value, type=self.type_name)

53
zun/api/controllers/v1/__init__.py
View File

@ -21,11 +21,11 @@ NOTE: IN PROGRESS AND NOT FULLY IMPLEMENTED.
from oslo_log import log as logging
import pecan
from pecan import rest
from wsme import types as wtypes
from zun.api.controllers import base as controllers_base
from zun.api.controllers import link
from zun.api import expose
from zun.api.controllers import types
from zun.api.controllers.v1 import zun_services
LOG = logging.getLogger(__name__)
@ -33,25 +33,33 @@ LOG = logging.getLogger(__name__)
class MediaType(controllers_base.APIBase):
"""A media type representation."""
base = wtypes.text
type = wtypes.text
def __init__(self, base, type):
self.base = base
self.type = type
fields = {
'base': {
'validate': types.Text.validate
},
'type': {
'validate': types.Text.validate
},
}
class V1(controllers_base.APIBase):
"""The representation of the version 1 of the API."""
id = wtypes.text
"""The ID of the version, also acts as the release number"""
media_types = [MediaType]
"""An array of supcontainersed media types for this version"""
links = [link.Link]
"""Links that point to a specific URL for this version and documentation"""
fields = {
'id': {
'validate': types.Text.validate
},
'media_types': {
'validate': types.List(types.Custom(MediaType)).validate
},
'links': {
'validate': types.List(types.Custom(link.Link)).validate
},
'services': {
'validate': types.List(types.Custom(link.Link)).validate
},
}
@staticmethod
def convert():
@ -64,15 +72,22 @@ class V1(controllers_base.APIBase):
'developer/zun/dev',
'api-spec-v1.html',
bookmark=True, type='text/html')]
v1.media_types = [MediaType('application/json',
'application/vnd.openstack.zun.v1+json')]
v1.media_types = [MediaType(base='application/json',
type='application/vnd.openstack.zun.v1+json')]
v1.services = [link.Link.make_link('self', pecan.request.host_url,
'services', ''),
link.Link.make_link('bookmark',
pecan.request.host_url,
'services', '',
bookmark=True)]
return v1
class Controller(rest.RestController):
"""Version 1 API controller root."""
services = zun_services.ZunServiceController()
@expose.expose(V1)
@pecan.expose('json')
def get(self):
return V1.convert()

48
zun/api/controllers/v1/collection.py Normal file
View File

@ -0,0 +1,48 @@
# 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 pecan
from zun.api.controllers import base
from zun.api.controllers import link
from zun.api.controllers import types
class Collection(base.APIBase):
fields = {
'next': {
'validate': types.Text.validate,
},
}
@property
def collection(self):
return getattr(self, self._type)
def has_next(self, limit):
"""Return whether collection has more items."""
return len(self.collection) and len(self.collection) == limit
def get_next(self, limit, url=None, **kwargs):
"""Return a link to the next subset of the collection."""
if not self.has_next(limit):
return None
resource_url = url or self._type
q_args = ''.join(['%s=%s&' % (key, kwargs[key]) for key in kwargs])
next_args = '?%(args)slimit=%(limit)d&marker=%(marker)s' % {
'args': q_args, 'limit': limit,
'marker': self.collection[-1].uuid}
return link.Link.make_link('next', pecan.request.host_url,
resource_url, next_args).href

127
zun/api/controllers/v1/zun_services.py Normal file
View File

@ -0,0 +1,127 @@
# 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 pecan
from pecan import rest
from zun.api.controllers import base
from zun.api.controllers import types
from zun.api.controllers.v1 import collection
from zun.api import servicegroup as svcgrp_api
from zun import objects
class ZunService(base.APIBase):
fields = {
'host': {
'validate': types.String.validate,
'validate_args': {
'min_length': 1,
'max_length': 255,
},
},
'binary': {
'validate': types.String.validate,
'validate_args': {
'min_length': 1,
'max_length': 255,
},
},
'state': {
'validate': types.String.validate,
'validate_args': {
'min_length': 1,
'max_length': 255,
},
},
'id': {
'validate': types.Integer.validate,
'validate_args': {
'minimum': 1,
},
},
'report_count': {
'validate': types.Integer.validate,
'validate_args': {
'minimum': 0,
},
},
'disabled': {
'validate': types.Bool.validate,
'validate_args': {
'default': False,
},
},
'disabled_reason': {
'validate': types.String.validate,
'validate_args': {
'min_length': 0,
'max_length': 255,
},
},
}
def __init__(self, state, **kwargs):
super(ZunService, self).__init__(**kwargs)
setattr(self, 'state', state)
class ZunServiceCollection(collection.Collection):
fields = {
'services': {
'validate': types.List(types.Custom(ZunService)).validate,
},
}
def __init__(self, **kwargs):
super(ZunServiceCollection, self).__init__()
self._type = 'services'
@staticmethod
def convert_db_rec_list_to_collection(servicegroup_api,
rpc_hsvcs, **kwargs):
collection = ZunServiceCollection()
collection.services = []
for p in rpc_hsvcs:
alive = servicegroup_api.service_is_up(p)
state = 'up' if alive else 'down'
hsvc = ZunService(state, **p.as_dict())
collection.services.append(hsvc)
next = collection.get_next(limit=None, url=None, **kwargs)
if next is not None:
collection.next = next
return collection
class ZunServiceController(rest.RestController):
"""REST controller for zun-services."""
def __init__(self, **kwargs):
super(ZunServiceController, self).__init__()
self.servicegroup_api = svcgrp_api.ServiceGroup()
# TODO(hongbin): uncomment this once policy is ported
# @policy.enforce_wsgi("zun-service", "get_all")
@pecan.expose('json')
def get_all(self):
"""Retrieve a list of zun-services.
"""
hsvcs = objects.ZunService.list(pecan.request.context,
limit=None,
marker=None,
sort_key='id',
sort_dir='asc')
return ZunServiceCollection.convert_db_rec_list_to_collection(
self.servicegroup_api, hsvcs)

45
zun/api/servicegroup.py Normal file
View File

@ -0,0 +1,45 @@
# 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 oslo_config import cfg
from oslo_utils import timeutils
from zun import objects
periodic_opts = [
cfg.IntOpt('service_down_time',
default=180,
help='Max interval size between periodic tasks execution in '
'seconds.'),
]
CONF = cfg.CONF
CONF.register_opts(periodic_opts)
class ServiceGroup(object):
def __init__(self):
self.service_down_time = CONF.service_down_time
def service_is_up(self, member):
if not isinstance(member, objects.ZunService):
raise TypeError
if member.get('forced_down'):
return False
last_heartbeat = (member.get(
'last_seen_up') or member['updated_at'] or member['created_at'])
now = timeutils.utcnow(True)
elapsed = timeutils.delta_seconds(last_heartbeat, now)
is_up = abs(elapsed) <= self.service_down_time
return is_up

71
zun/tests/unit/api/controllers/test_types.py
View File

@ -19,7 +19,72 @@ from zun.tests import base as test_base
class TestTypes(test_base.BaseTestCase):
def test_text(self):
self.assertEqual(None, types.Text.validate(None))
self.assertEqual('test_value', types.Text.validate('test_value'))
self.assertRaises(exception.InvalidValue,
types.Text.validate, 1)
def test_string_type(self):
self.assertEqual(None, types.String.validate(None))
test_value = 'test_value'
self.assertEqual(test_value, types.String.validate(test_value))
self.assertRaises(exception.InvalidValue,
types.String.validate, 1)
# test min_length
for i in range(0, len(test_value)+1):
self.assertEqual(test_value, types.String.validate(
test_value, min_length=i))
for i in range(len(test_value)+1, 20):
self.assertRaises(exception.InvalidValue,
types.String.validate, test_value,
min_length=i)
# test max_length
for i in range(1, len(test_value)):
self.assertRaises(exception.InvalidValue,
types.String.validate, test_value,
max_length=i)
for i in range(len(test_value), 20):
self.assertEqual(test_value, types.String.validate(
test_value, max_length=i))
def test_integer_type(self):
self.assertEqual(None, types.Integer.validate(None))
test_value = 10
self.assertEqual(test_value, types.Integer.validate(test_value))
self.assertEqual(test_value, types.Integer.validate('10'))
self.assertRaises(exception.InvalidValue,
types.Integer.validate, 'invalid')
# test minimum
for i in range(0, test_value+1):
self.assertEqual(test_value, types.Integer.validate(
test_value, minimum=i))
for i in range(test_value+1, 20):
self.assertRaises(exception.InvalidValue,
types.Integer.validate, test_value,
minimum=i)
def test_bool_type(self):
self.assertTrue(types.Bool.validate(None, default=True))
test_value = True
self.assertEqual(test_value, types.Bool.validate(True))
self.assertEqual(test_value, types.Bool.validate('True'))
self.assertEqual(test_value, types.Bool.validate('true'))
self.assertEqual(test_value, types.Bool.validate('TRUE'))
self.assertRaises(exception.InvalidValue,
types.Bool.validate, None)
self.assertRaises(exception.InvalidValue,
types.Bool.validate, '')
self.assertRaises(exception.InvalidValue,
types.Bool.validate, 'TTT')
self.assertRaises(exception.InvalidValue,
types.Bool.validate, 2)
def test_custom(self):
class TestAPI(base.APIBase):
@ -30,6 +95,8 @@ class TestTypes(test_base.BaseTestCase):
}
test_type = types.Custom(TestAPI)
self.assertEqual(None, test_type.validate(None))
value = TestAPI(test='test_value')
value = test_type.validate(value)
self.assertIsInstance(value, TestAPI)
@ -46,6 +113,8 @@ class TestTypes(test_base.BaseTestCase):
def test_list_with_text_type(self):
list_type = types.List(types.Text)
self.assertEqual(None, list_type.validate(None))
value = list_type.validate(['test1', 'test2'])
self.assertEqual(['test1', 'test2'], value)
@ -62,6 +131,8 @@ class TestTypes(test_base.BaseTestCase):
}
list_type = types.List(types.Custom(TestAPI))
self.assertEqual(None, list_type.validate(None))
value = [{'test': 'test_value'}]
value = list_type.validate(value)
self.assertIsInstance(value, list)

0
zun/tests/unit/api/controllers/v1/__init__.py Normal file
View File

80
zun/tests/unit/api/controllers/v1/test_zun_service.py Normal file
View File

@ -0,0 +1,80 @@
# 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 zun.api.controllers.v1 import zun_services as zservice
from zun.tests import base
from zun.tests.unit.api import utils as apiutils
class TestZunServiceObject(base.BaseTestCase):
def setUp(self):
super(TestZunServiceObject, self).setUp()
self.rpc_dict = apiutils.zservice_get_data()
def test_msvc_obj_fields_filtering(self):
"""Test that it does filtering fields """
self.rpc_dict['fake-key'] = 'fake-value'
msvco = zservice.ZunService("up", **self.rpc_dict)
self.assertNotIn('fake-key', msvco.fields)
class db_rec(object):
def __init__(self, d):
self.rec_as_dict = d
def as_dict(self):
return self.rec_as_dict
# TODO(hongbin): Enable the tests below
# class TestZunServiceController(api_base.FunctionalTest):
# def setUp(self):
# super(TestZunServiceController, self).setUp()
# def test_empty(self):
# response = self.get_json('/hservices')
# self.assertEqual([], response['hservices'])
# def _rpc_api_reply(self, count=1):
# reclist = []
# for i in range(count):
# elem = apiutils.zservice_get_data()
# elem['id'] = i + 1
# rec = db_rec(elem)
# reclist.append(rec)
# return reclist
# @mock.patch.object(objects.ZunService, 'list')
# @mock.patch.object(servicegroup.ServiceGroup, 'service_is_up')
# def test_get_one(self, svc_up, mock_list):
# mock_list.return_value = self._rpc_api_reply()
# svc_up.return_value = "up"
# response = self.get_json('/hservices')
# self.assertEqual(len(response['hservices']), 1)
# self.assertEqual(response['hservices'][0]['id'], 1)
# @mock.patch.object(objects.ZunService, 'list')
# @mock.patch.object(servicegroup.ServiceGroup, 'service_is_up')
# def test_get_many(self, svc_up, mock_list):
# svc_num = 5
# mock_list.return_value = self._rpc_api_reply(svc_num)
# svc_up.return_value = "up"
# response = self.get_json('/hservices')
# self.assertEqual(len(response['hservices']), svc_num)
# for i in range(svc_num):
# elem = response['hservices'][i]
# self.assertEqual(elem['id'], i + 1)

34
zun/tests/unit/api/utils.py Normal file
View File

@ -0,0 +1,34 @@
# 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.
"""
Utils for testing the API service.
"""
import datetime
import pytz
def zservice_get_data(**kw):
"""Simulate what the RPC layer will get from DB """
faketime = datetime.datetime(2001, 1, 1, tzinfo=pytz.UTC)
return {
'binary': kw.get('binary', 'fake-binary'),
'host': kw.get('host', 'fake-host'),
'id': kw.get('id', 13),
'report_count': kw.get('report_count', 13),
'disabled': kw.get('disabled', False),
'disabled_reason': kw.get('disabled_reason', None),
'forced_down': kw.get('forced_down', False),
'last_seen_at': kw.get('last_seen_at', faketime),
'created_at': kw.get('created_at', faketime),
'updated_at': kw.get('updated_at', faketime),
}