Adds support for storing and getting vim creds
Adds support for vim account create operation
Adds local sqlite database
Adds AuthManager and DatabaseManager classes
Modifies integration tests
Change-Id: I0609b53835be94c8c36c12df905e09ce14eff3a7
Signed-off-by: Benjamin Diaz <bdiaz@whitestack.com>
diff --git a/.gitignore b/.gitignore
index f4d6bb1..d994eb7 100644
--- a/.gitignore
+++ b/.gitignore
@@ -76,3 +76,4 @@
.settings/
__pycache__/
.idea
+*.db
\ No newline at end of file
diff --git a/Dockerfile b/Dockerfile
index 8d281ca..baf3976 100644
--- a/Dockerfile
+++ b/Dockerfile
@@ -29,7 +29,7 @@
DEBIAN_FRONTEND=noninteractive pip install -U pip && \
DEBIAN_FRONTENT=noninteractive pip install -U requests logutils jsonschema lxml kafka mock && \
DEBIAN_FRONTEND=noninteractive pip install -U setuptools setuptools-version-command stdeb jsmin && \
- DEBIAN_FRONTEND=noninteractive pip install -U six pyvcloud bottle cherrypy pyopenssl && \
+ DEBIAN_FRONTEND=noninteractive pip install -U six pyvcloud==18.2.* bottle cherrypy pyopenssl && \
DEBIAN_FRONTEND=noninteractive apt-get --yes install default-jre libmysqlclient-dev && \
DEBIAN_FRONTEND=noninteractive apt-get --yes install libmysqlclient-dev libxml2 && \
DEBIAN_FRONTEND=noninteractive pip install -U MySQL-python \
@@ -39,4 +39,5 @@
gnocchiclient \
boto==2.48 \
python-cloudwatchlogs-logging \
- py-cloudwatch
+ py-cloudwatch \
+ peewee==3.1.*
diff --git a/doc/MON_install_guide.rst b/doc/MON_install_guide.rst
index d086a82..5265e59 100644
--- a/doc/MON_install_guide.rst
+++ b/doc/MON_install_guide.rst
@@ -100,7 +100,7 @@
::
- lxc exec MON -- nohup python /root/MON/osm_mon/core/message_bus/common_consumer &
+ lxc exec MON -- nohup python /root/MON/osm_mon/core/message_bus/common_consumer.py > /root/MON_plugins.log 2>&1 &
* To enable Aodh alarm notifications to be sent to SO:
diff --git a/osm_mon/core/auth.py b/osm_mon/core/auth.py
new file mode 100644
index 0000000..bdc0498
--- /dev/null
+++ b/osm_mon/core/auth.py
@@ -0,0 +1,54 @@
+# -*- coding: utf-8 -*-
+
+# Copyright 2018 Whitestack, LLC
+# *************************************************************
+
+# This file is part of OSM Monitoring module
+# All Rights Reserved to Whitestack, LLC
+
+# 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.
+
+# For those usages not covered by the Apache License, Version 2.0 please
+# contact: bdiaz@whitestack.com or glavado@whitestack.com
+##
+
+import json
+
+from osm_mon.core.database import VimCredentials, DatabaseManager
+
+
+class AuthManager:
+
+ def __init__(self):
+ self.database_manager = DatabaseManager()
+
+ def store_auth_credentials(self, message):
+ values = json.loads(message.value)
+ credentials = VimCredentials()
+ credentials.uuid = values['_id']
+ credentials.name = values['name']
+ credentials.type = values['vim_type']
+ credentials.url = values['vim_url']
+ credentials.user = values['vim_user']
+ credentials.password = values['vim_password']
+ credentials.tenant_name = values['vim_tenant_name']
+ credentials.config = json.dumps(values['config'])
+ self.database_manager.save_credentials(credentials)
+
+ def get_credentials(self, vim_uuid):
+ return self.database_manager.get_credentials(vim_uuid)
+
+ def delete_auth_credentials(self, message):
+ # TODO
+ pass
+
diff --git a/osm_mon/core/database.py b/osm_mon/core/database.py
new file mode 100644
index 0000000..2191106
--- /dev/null
+++ b/osm_mon/core/database.py
@@ -0,0 +1,67 @@
+# -*- coding: utf-8 -*-
+
+# Copyright 2018 Whitestack, LLC
+# *************************************************************
+
+# This file is part of OSM Monitoring module
+# All Rights Reserved to Whitestack, LLC
+
+# 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.
+
+# For those usages not covered by the Apache License, Version 2.0 please
+# contact: bdiaz@whitestack.com or glavado@whitestack.com
+##
+
+import logging
+
+from peewee import *
+from playhouse.sqlite_ext import SqliteExtDatabase
+
+from osm_mon.plugins.OpenStack.settings import Config
+
+log = logging.getLogger(__name__)
+cfg = Config.instance()
+
+db = SqliteExtDatabase('mon.db')
+
+
+class BaseModel(Model):
+ class Meta:
+ database = db
+
+
+class VimCredentials(BaseModel):
+ uuid = CharField()
+ name = CharField()
+ type = CharField()
+ url = CharField()
+ user = CharField()
+ password = CharField()
+ tenant_name = CharField()
+ config = TextField()
+
+
+class DatabaseManager:
+ def create_tables(self):
+ try:
+ db.connect()
+ db.create_tables([VimCredentials])
+ db.close()
+ except Exception as e:
+ log.exception("Error creating tables: ")
+
+ def get_credentials(self, vim_uuid):
+ return VimCredentials.get(VimCredentials.uuid == vim_uuid)
+
+ def save_credentials(self, vim_credentials):
+ vim_credentials.save()
diff --git a/osm_mon/core/message_bus/common_consumer b/osm_mon/core/message_bus/common_consumer.py
similarity index 80%
rename from osm_mon/core/message_bus/common_consumer
rename to osm_mon/core/message_bus/common_consumer.py
index efbb122..27a4188 100755
--- a/osm_mon/core/message_bus/common_consumer
+++ b/osm_mon/core/message_bus/common_consumer.py
@@ -21,19 +21,18 @@
import json
import logging
-import sys
import os
+import sys
-sys.path.append("/root/MON")
-
-logging.basicConfig(filename='MON_plugins.log',
+logging.basicConfig(stream=sys.stdout,
format='%(asctime)s %(message)s',
- datefmt='%m/%d/%Y %I:%M:%S %p', filemode='a',
+ datefmt='%m/%d/%Y %I:%M:%S %p',
level=logging.INFO)
log = logging.getLogger(__name__)
+sys.path.append(os.path.abspath(os.path.join(os.path.realpath(__file__), '..', '..', '..', '..')))
+
from kafka import KafkaConsumer
-from kafka.errors import KafkaError
from osm_mon.plugins.OpenStack.Aodh import alarming
from osm_mon.plugins.OpenStack.common import Common
@@ -46,16 +45,24 @@
from osm_mon.plugins.vRealiseOps import plugin_receiver
+from osm_mon.core.auth import AuthManager
+from osm_mon.core.database import DatabaseManager
+
# Initialize servers
if "BROKER_URI" in os.environ:
server = {'server': os.getenv("BROKER_URI")}
else:
server = {'server': 'localhost:9092'}
-
-
# Initialize consumers for alarms and metrics
-common_consumer = KafkaConsumer(bootstrap_servers=server['server'])
+common_consumer = KafkaConsumer(bootstrap_servers=server['server'],
+ key_deserializer=bytes.decode,
+ value_deserializer=bytes.decode,
+ group_id="mon-consumer")
+
+auth_manager = AuthManager()
+database_manager = DatabaseManager()
+database_manager.create_tables()
# Create OpenStack alarming and metric instances
auth_token = None
@@ -69,9 +76,10 @@
aws_connection = Connection()
aws_access_credentials = AccessCredentials()
-#Create vROps plugin_receiver class instance
+# Create vROps plugin_receiver class instance
vrops_rcvr = plugin_receiver.PluginReceiver()
+
def get_vim_type(message):
"""Get the vim type that is required by the message."""
try:
@@ -80,13 +88,16 @@
log.warn("vim_type is not configured correctly; %s", exc)
return None
+
# Define subscribe the consumer for the plugins
-topics = ['metric_request', 'alarm_request', 'access_credentials']
+topics = ['metric_request', 'alarm_request', 'access_credentials', 'vim_account']
+# TODO: Remove access_credentials
common_consumer.subscribe(topics)
-try:
- log.info("Listening for alarm_request and metric_request messages")
- for message in common_consumer:
+log.info("Listening for alarm_request and metric_request messages")
+for message in common_consumer:
+ log.info("Message arrived: %s", message)
+ try:
# Check the message topic
if message.topic == "metric_request":
# Check the vim desired by the message
@@ -100,7 +111,7 @@
elif vim_type == "aws":
log.info("This message is for the CloudWatch plugin.")
aws_conn = aws_connection.setEnvironment()
- cloudwatch_metrics.metric_calls(message,aws_conn)
+ cloudwatch_metrics.metric_calls(message, aws_conn)
elif vim_type == "vmware":
log.info("This metric_request message is for the vROPs plugin.")
@@ -130,6 +141,13 @@
log.debug("vim_type is misconfigured or unsupported; %s",
vim_type)
+ elif message.topic == "vim_account":
+ if message.key == "create" or message.key == "edit":
+ auth_manager.store_auth_credentials(message)
+ if message.key == "delete":
+ auth_manager.delete_auth_credentials(message)
+
+ # TODO: Remove in the near future. Modify tests accordingly.
elif message.topic == "access_credentials":
# Check the vim desired by the message
vim_type = get_vim_type(message)
@@ -139,7 +157,7 @@
elif vim_type == "aws":
log.info("This message is for the CloudWatch plugin.")
- aws_access_credentials.access_credential_calls(message)
+ aws_access_credentials.access_credential_calls(message)
elif vim_type == "vmware":
log.info("This access_credentials message is for the vROPs plugin.")
@@ -153,5 +171,5 @@
log.info("This topic is not relevant to any of the MON plugins.")
-except KafkaError as exc:
- log.warn("Exception: %s", exc)
+ except Exception as exc:
+ log.exception("Exception: %s")
diff --git a/osm_mon/core/models/vim_account_create.json b/osm_mon/core/models/vim_account_create.json
new file mode 100644
index 0000000..536e5cd
--- /dev/null
+++ b/osm_mon/core/models/vim_account_create.json
@@ -0,0 +1,44 @@
+/*
+ Copyright 2018 Whitestack, LLC
+ *************************************************************
+
+ This file is part of OSM Monitoring module
+ All Rights Reserved to Whitestack, LLC
+
+ 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.
+
+ For those usages not covered by the Apache License, Version 2.0 please
+ contact: bdiaz@whitestack.com or glavado@whitestack.com
+*/
+{
+ "schema_version": { "type": "string" },
+ "schema_type": { "type": "string" },
+ "_id": { "type": "string" },
+ "name": { "type": "string" },
+ "description": { "type": "string" },
+ "vim_type": { "type": "string" },
+ "vim_url": { "type": "string" },
+ "vim_user": { "type": "string" },
+ "vim_password": { "type": "string" },
+ "vim_tenant_name": { "type": "string" },
+ "config": { "type":"object" },
+ "required": [ "schema_version",
+ "schema_type",
+ "_id",
+ "name",
+ "vim_url",
+ "vim_type",
+ "vim_user",
+ "vim_password",
+ "vim_tenant_name" ]
+}
diff --git a/osm_mon/test/integration/__init__.py b/osm_mon/test/integration/__init__.py
new file mode 100644
index 0000000..d81308a
--- /dev/null
+++ b/osm_mon/test/integration/__init__.py
@@ -0,0 +1,23 @@
+# -*- coding: utf-8 -*-
+
+# Copyright 2018 Whitestack, LLC
+# *************************************************************
+
+# This file is part of OSM Monitoring module
+# All Rights Reserved to Whitestack, LLC
+
+# 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.
+
+# For those usages not covered by the Apache License, Version 2.0 please
+# contact: bdiaz@whitestack.com or glavado@whitestack.com
+##
diff --git a/osm_mon/test/integration/test_access_cred.py b/osm_mon/test/integration/test_access_cred.py
index 532a2f6..231711b 100644
--- a/osm_mon/test/integration/test_access_cred.py
+++ b/osm_mon/test/integration/test_access_cred.py
@@ -23,51 +23,59 @@
"""Test an end to end Openstack access_credentials requests."""
import json
-
import logging
-
-from kafka import KafkaConsumer
-from kafka import KafkaProducer
-
-from keystoneclient.v3 import client
+import unittest
import mock
+from kafka import KafkaConsumer
+from kafka import KafkaProducer
+from kafka.errors import KafkaError
+from keystoneclient.v3 import client
+from osm_mon.plugins.OpenStack.Aodh import alarming
from osm_mon.plugins.OpenStack.common import Common
log = logging.getLogger(__name__)
-# Create an instance of the common openstack class, producer and consumer
-openstack_auth = Common()
-producer = KafkaProducer(bootstrap_servers='localhost:9092')
-req_consumer = KafkaConsumer(bootstrap_servers='localhost:9092',
- group_id='osm_mon')
-req_consumer.subscribe("access_credentials")
+# TODO: Remove this file
+class AccessCredentialsTest(unittest.TestCase):
+ def setUp(self):
+ # Set up common and alarming class instances
+ self.alarms = alarming.Alarming()
+ self.openstack_auth = Common()
+ try:
+ self.producer = KafkaProducer(bootstrap_servers='localhost:9092')
+ self.req_consumer = KafkaConsumer(bootstrap_servers='localhost:9092',
+ group_id='osm_mon',
+ consumer_timeout_ms=2000)
+ self.req_consumer.subscribe(['access_credentials'])
+ except KafkaError:
+ self.skipTest('Kafka server not present.')
-@mock.patch.object(client, "Client")
-def test_access_cred_req(keyclient):
- """Test access credentials request message from KafkaProducer."""
- # Set-up message, producer and consumer for tests
- payload = {"vim_type": "OpenStack",
- "access_config":
- {"openstack_site": "my_site",
- "user": "my_user",
- "password": "my_password",
- "vim_tenant_name": "my_tenant"}}
+ @mock.patch.object(client, "Client")
+ def test_access_cred_req(self, keyclient):
+ """Test access credentials request message from KafkaProducer."""
+ # Set-up message, producer and consumer for tests
+ payload = {"vim_type": "OpenStack",
+ "access_config":
+ {"openstack_site": "my_site",
+ "user": "my_user",
+ "password": "my_password",
+ "vim_tenant_name": "my_tenant"}}
- producer.send('access_credentials', value=json.dumps(payload))
+ self.producer.send('access_credentials', value=json.dumps(payload))
- for message in req_consumer:
- # Check the vim desired by the message
- vim_type = json.loads(message.value)["vim_type"].lower()
- if vim_type == "openstack":
- openstack_auth._authenticate(message=message)
+ for message in self.req_consumer:
+ # Check the vim desired by the message
+ vim_type = json.loads(message.value)["vim_type"].lower()
+ if vim_type == "openstack":
+ self.openstack_auth._authenticate(message=message)
- # A keystone client is created with the valid access_credentials
- keyclient.assert_called_with(
- auth_url="my_site", username="my_user", password="my_password",
- tenant_name="my_tenant")
+ # A keystone client is created with the valid access_credentials
+ keyclient.assert_called_with(
+ auth_url="my_site", username="my_user", password="my_password",
+ tenant_name="my_tenant")
- return
+ return
diff --git a/osm_mon/test/integration/test_alarm_integration.py b/osm_mon/test/integration/test_alarm_integration.py
index 489c307..13f0fef 100644
--- a/osm_mon/test/integration/test_alarm_integration.py
+++ b/osm_mon/test/integration/test_alarm_integration.py
@@ -23,182 +23,186 @@
"""Test an end to end Openstack alarm requests."""
import json
-
import logging
-
-from osm_mon.core.message_bus.producer import KafkaProducer as prod
-
-from kafka import KafkaConsumer
-from kafka import KafkaProducer
+import unittest
import mock
+from kafka import KafkaConsumer
+from kafka import KafkaProducer
+from kafka.errors import KafkaError
+from osm_mon.core.message_bus.producer import KafkaProducer as prod
from osm_mon.plugins.OpenStack import response
-
from osm_mon.plugins.OpenStack.Aodh import alarming
from osm_mon.plugins.OpenStack.common import Common
log = logging.getLogger(__name__)
-# Set up common and alarming class instances
-alarms = alarming.Alarming()
-openstack_auth = Common()
-# Initialise the alarm request consumer and a producer for testing
-producer = KafkaProducer(bootstrap_servers='localhost:9092')
-req_consumer = KafkaConsumer(bootstrap_servers='localhost:9092',
- group_id='osm_mon')
-req_consumer.subscribe("alarm_request")
+class AlarmIntegrationTest(unittest.TestCase):
+ def setUp(self):
+ # Set up common and alarming class instances
+ self.alarms = alarming.Alarming()
+ self.openstack_auth = Common()
+ try:
+ self.producer = KafkaProducer(bootstrap_servers='localhost:9092')
+ self.req_consumer = KafkaConsumer(bootstrap_servers='localhost:9092',
+ group_id='osm_mon',
+ consumer_timeout_ms=2000)
+ self.req_consumer.subscribe(['alarm_request'])
+ except KafkaError:
+ self.skipTest('Kafka server not present.')
-@mock.patch.object(prod, "update_alarm_response")
-@mock.patch.object(alarming.Alarming, "update_alarm")
-@mock.patch.object(response.OpenStack_Response, "generate_response")
-def test_update_alarm_req(resp, update_alarm, update_resp):
- """Test Aodh update alarm request message from KafkaProducer."""
- # Set-up message, producer and consumer for tests
- payload = {"vim_type": "OpenSTACK",
- "alarm_update_request":
- {"correlation_id": 123,
- "alarm_uuid": "alarm_id",
- "metric_uuid": "metric_id"}}
+ @mock.patch.object(prod, "update_alarm_response")
+ @mock.patch.object(alarming.Alarming, "update_alarm")
+ @mock.patch.object(response.OpenStack_Response, "generate_response")
+ def test_update_alarm_req(self, resp, update_alarm, update_resp):
+ """Test Aodh update alarm request message from KafkaProducer."""
+ # Set-up message, producer and consumer for tests
+ payload = {"vim_type": "OpenSTACK",
+ "alarm_update_request":
+ {"correlation_id": 123,
+ "alarm_uuid": "alarm_id",
+ "metric_uuid": "metric_id"}}
- producer.send('alarm_request', key="update_alarm_request",
- value=json.dumps(payload))
+ self.producer.send('alarm_request', key="update_alarm_request",
+ value=json.dumps(payload))
- for message in req_consumer:
- # Check the vim desired by the message
- vim_type = json.loads(message.value)["vim_type"].lower()
- if vim_type == "openstack":
- # Mock a valid alarm update
- update_alarm.return_value = "alarm_id", True
- alarms.alarming(message, openstack_auth, None)
+ for message in self.req_consumer:
+ # Check the vim desired by the message
+ vim_type = json.loads(message.value)["vim_type"].lower()
+ if vim_type == "openstack":
+ # Mock a valid alarm update
+ update_alarm.return_value = "alarm_id", True
+ self.alarms.alarming(message, self.openstack_auth, None)
- # A response message is generated and sent via MON's producer
- resp.assert_called_with(
- 'update_alarm_response', alarm_id="alarm_id", cor_id=123,
- status=True)
- update_resp.assert_called_with(
- 'update_alarm_response', resp.return_value, 'alarm_response')
+ # A response message is generated and sent via MON's producer
+ resp.assert_called_with(
+ 'update_alarm_response', alarm_id="alarm_id", cor_id=123,
+ status=True)
+ update_resp.assert_called_with(
+ 'update_alarm_response', resp.return_value, 'alarm_response')
- return
+ return
+ self.fail("No message received in consumer")
+ @mock.patch.object(prod, "create_alarm_response")
+ @mock.patch.object(alarming.Alarming, "configure_alarm")
+ @mock.patch.object(response.OpenStack_Response, "generate_response")
+ def test_create_alarm_req(self, resp, config_alarm, create_resp):
+ """Test Aodh create alarm request message from KafkaProducer."""
+ # Set-up message, producer and consumer for tests
+ payload = {"vim_type": "OpenSTACK",
+ "alarm_create_request":
+ {"correlation_id": 123,
+ "alarm_name": "my_alarm",
+ "metric_name": "my_metric",
+ "resource_uuid": "my_resource",
+ "severity": "WARNING"}}
-@mock.patch.object(prod, "create_alarm_response")
-@mock.patch.object(alarming.Alarming, "configure_alarm")
-@mock.patch.object(response.OpenStack_Response, "generate_response")
-def test_create_alarm_req(resp, config_alarm, create_resp):
- """Test Aodh create alarm request message from KafkaProducer."""
- # Set-up message, producer and consumer for tests
- payload = {"vim_type": "OpenSTACK",
- "alarm_create_request":
- {"correlation_id": 123,
- "alarm_name": "my_alarm",
- "metric_name": "my_metric",
- "resource_uuid": "my_resource",
- "severity": "WARNING"}}
+ self.producer.send('alarm_request', key="create_alarm_request",
+ value=json.dumps(payload))
- producer.send('alarm_request', key="create_alarm_request",
- value=json.dumps(payload))
+ for message in self.req_consumer:
+ # Check the vim desired by the message
+ vim_type = json.loads(message.value)["vim_type"].lower()
+ if vim_type == "openstack":
+ # Mock a valid alarm creation
+ config_alarm.return_value = "alarm_id", True
+ self.alarms.alarming(message, self.openstack_auth, None)
- for message in req_consumer:
- # Check the vim desired by the message
- vim_type = json.loads(message.value)["vim_type"].lower()
- if vim_type == "openstack":
- # Mock a valid alarm creation
- config_alarm.return_value = "alarm_id", True
- alarms.alarming(message, openstack_auth, None)
+ # A response message is generated and sent via MON's produce
+ resp.assert_called_with(
+ 'create_alarm_response', status=True, alarm_id="alarm_id",
+ cor_id=123)
+ create_resp.assert_called_with(
+ 'create_alarm_response', resp.return_value, 'alarm_response')
- # A response message is generated and sent via MON's produce
- resp.assert_called_with(
- 'create_alarm_response', status=True, alarm_id="alarm_id",
- cor_id=123)
- create_resp.assert_called_with(
- 'create_alarm_response', resp.return_value, 'alarm_response')
+ return
+ self.fail("No message received in consumer")
- return
+ @mock.patch.object(prod, "list_alarm_response")
+ @mock.patch.object(alarming.Alarming, "list_alarms")
+ @mock.patch.object(response.OpenStack_Response, "generate_response")
+ def test_list_alarm_req(self, resp, list_alarm, list_resp):
+ """Test Aodh list alarm request message from KafkaProducer."""
+ # Set-up message, producer and consumer for tests
+ payload = {"vim_type": "OpenSTACK",
+ "alarm_list_request":
+ {"correlation_id": 123,
+ "resource_uuid": "resource_id", }}
+ self.producer.send('alarm_request', key="list_alarm_request",
+ value=json.dumps(payload))
-@mock.patch.object(prod, "list_alarm_response")
-@mock.patch.object(alarming.Alarming, "list_alarms")
-@mock.patch.object(response.OpenStack_Response, "generate_response")
-def test_list_alarm_req(resp, list_alarm, list_resp):
- """Test Aodh list alarm request message from KafkaProducer."""
- # Set-up message, producer and consumer for tests
- payload = {"vim_type": "OpenSTACK",
- "alarm_list_request":
- {"correlation_id": 123,
- "resource_uuid": "resource_id", }}
+ for message in self.req_consumer:
+ # Check the vim desired by the message
+ vim_type = json.loads(message.value)["vim_type"].lower()
+ if vim_type == "openstack":
+ # Mock an empty list generated by the request
+ list_alarm.return_value = []
+ self.alarms.alarming(message, self.openstack_auth, None)
- producer.send('alarm_request', key="list_alarm_request",
- value=json.dumps(payload))
+ # Resoonse message is generated
+ resp.assert_called_with(
+ 'list_alarm_response', alarm_list=[],
+ cor_id=123)
+ # Producer attempts to send the response message back to the SO
+ list_resp.assert_called_with(
+ 'list_alarm_response', resp.return_value, 'alarm_response')
- for message in req_consumer:
- # Check the vim desired by the message
- vim_type = json.loads(message.value)["vim_type"].lower()
- if vim_type == "openstack":
- # Mock an empty list generated by the request
- list_alarm.return_value = []
- alarms.alarming(message, openstack_auth, None)
+ return
+ self.fail("No message received in consumer")
- # Resoonse message is generated
- resp.assert_called_with(
- 'list_alarm_response', alarm_list=[],
- cor_id=123)
- # Producer attempts to send the response message back to the SO
- list_resp.assert_called_with(
- 'list_alarm_response', resp.return_value, 'alarm_response')
+ @mock.patch.object(alarming.Alarming, "delete_alarm")
+ @mock.patch.object(prod, "delete_alarm_response")
+ @mock.patch.object(response.OpenStack_Response, "generate_response")
+ def test_delete_alarm_req(self, resp, del_resp, del_alarm):
+ """Test Aodh delete alarm request message from KafkaProducer."""
+ # Set-up message, producer and consumer for tests
+ payload = {"vim_type": "OpenSTACK",
+ "alarm_delete_request":
+ {"correlation_id": 123,
+ "alarm_uuid": "alarm_id", }}
- return
+ self.producer.send('alarm_request', key="delete_alarm_request",
+ value=json.dumps(payload))
+ for message in self.req_consumer:
+ # Check the vim desired by the message
+ vim_type = json.loads(message.value)["vim_type"].lower()
+ if vim_type == "openstack":
+ self.alarms.alarming(message, self.openstack_auth, None)
-@mock.patch.object(alarming.Alarming, "delete_alarm")
-@mock.patch.object(prod, "delete_alarm_response")
-@mock.patch.object(response.OpenStack_Response, "generate_response")
-def test_delete_alarm_req(resp, del_resp, del_alarm):
- """Test Aodh delete alarm request message from KafkaProducer."""
- # Set-up message, producer and consumer for tests
- payload = {"vim_type": "OpenSTACK",
- "alarm_delete_request":
- {"correlation_id": 123,
- "alarm_uuid": "alarm_id", }}
+ # Response message is generated and sent by MON's producer
+ resp.assert_called_with(
+ 'delete_alarm_response', alarm_id="alarm_id",
+ status=del_alarm.return_value, cor_id=123)
+ del_resp.assert_called_with(
+ 'delete_alarm_response', resp.return_value, 'alarm_response')
- producer.send('alarm_request', key="delete_alarm_request",
- value=json.dumps(payload))
+ return
+ self.fail("No message received in consumer")
- for message in req_consumer:
- # Check the vim desired by the message
- vim_type = json.loads(message.value)["vim_type"].lower()
- if vim_type == "openstack":
- alarms.alarming(message, openstack_auth, None)
+ @mock.patch.object(alarming.Alarming, "update_alarm_state")
+ def test_ack_alarm_req(self, ack_alarm):
+ """Test Aodh acknowledge alarm request message from KafkaProducer."""
+ # Set-up message, producer and consumer for tests
+ payload = {"vim_type": "OpenSTACK",
+ "ack_details":
+ {"alarm_uuid": "alarm_id", }}
- # Response message is generated and sent by MON's producer
- resp.assert_called_with(
- 'delete_alarm_response', alarm_id="alarm_id",
- status=del_alarm.return_value, cor_id=123)
- del_resp.assert_called_with(
- 'delete_alarm_response', resp.return_value, 'alarm_response')
+ self.producer.send('alarm_request', key="acknowledge_alarm",
+ value=json.dumps(payload))
- return
-
-
-@mock.patch.object(alarming.Alarming, "update_alarm_state")
-def test_ack_alarm_req(ack_alarm):
- """Test Aodh acknowledge alarm request message from KafkaProducer."""
- # Set-up message, producer and consumer for tests
- payload = {"vim_type": "OpenSTACK",
- "ack_details":
- {"alarm_uuid": "alarm_id", }}
-
- producer.send('alarm_request', key="acknowledge_alarm",
- value=json.dumps(payload))
-
- for message in req_consumer:
- # Check the vim desired by the message
- vim_type = json.loads(message.value)["vim_type"].lower()
- if vim_type == "openstack":
- alarms.alarming(message, openstack_auth, None)
- # No response message is sent for and ack request
- # Alarm state is updated from alarm -> ok
- ack_alarm.assert_called_with(None, None, "alarm_id")
- return
+ for message in self.req_consumer:
+ # Check the vim desired by the message
+ vim_type = json.loads(message.value)["vim_type"].lower()
+ if vim_type == "openstack":
+ self.alarms.alarming(message, self.openstack_auth, None)
+ # No response message is sent for and ack request
+ # Alarm state is updated from alarm -> ok
+ ack_alarm.assert_called_with(None, None, "alarm_id")
+ return
+ self.fail("No message received in consumer")
diff --git a/osm_mon/test/integration/test_metric_integration.py b/osm_mon/test/integration/test_metric_integration.py
index 6c87dad..312359a 100644
--- a/osm_mon/test/integration/test_metric_integration.py
+++ b/osm_mon/test/integration/test_metric_integration.py
@@ -25,6 +25,9 @@
import json
import logging
+import unittest
+
+from kafka.errors import KafkaError
from osm_mon.core.message_bus.producer import KafkaProducer as prod
@@ -41,178 +44,184 @@
log = logging.getLogger(__name__)
-# Instances for the openstack common and metric classes
-metric_req = metrics.Metrics()
-openstack_auth = Common()
-# A metric_request consumer and a producer for testing purposes
-producer = KafkaProducer(bootstrap_servers='localhost:9092')
-req_consumer = KafkaConsumer(bootstrap_servers='localhost:9092',
- group_id='osm_mon')
-req_consumer.subscribe("metric_request")
+class MetricIntegrationTest(unittest.TestCase):
+ def setUp(self):
+ # Set up common and alarming class instances
+ self.metric_req = metrics.Metrics()
+ self.openstack_auth = Common()
+ try:
+ self.producer = KafkaProducer(bootstrap_servers='localhost:9092')
+ self.req_consumer = KafkaConsumer(bootstrap_servers='localhost:9092',
+ group_id='osm_mon',
+ consumer_timeout_ms=2000)
+ self.req_consumer.subscribe(['metric_request'])
+ except KafkaError:
+ self.skipTest('Kafka server not present.')
-@mock.patch.object(metrics.Metrics, "configure_metric")
-@mock.patch.object(prod, "create_metrics_resp")
-@mock.patch.object(response.OpenStack_Response, "generate_response")
-def test_create_metric_req(resp, create_resp, config_metric):
- """Test Gnocchi create metric request message from producer."""
- # Set-up message, producer and consumer for tests
- payload = {"vim_type": "OpenSTACK",
- "correlation_id": 123,
- "metric_create":
- {"metric_name": "my_metric",
- "resource_uuid": "resource_id"}}
+ @mock.patch.object(metrics.Metrics, "configure_metric")
+ @mock.patch.object(prod, "create_metrics_resp")
+ @mock.patch.object(response.OpenStack_Response, "generate_response")
+ def test_create_metric_req(self, resp, create_resp, config_metric):
+ """Test Gnocchi create metric request message from producer."""
+ # Set-up message, producer and consumer for tests
+ payload = {"vim_type": "OpenSTACK",
+ "correlation_id": 123,
+ "metric_create":
+ {"metric_name": "my_metric",
+ "resource_uuid": "resource_id"}}
- producer.send('metric_request', key="create_metric_request",
- value=json.dumps(payload))
+ self.producer.send('metric_request', key="create_metric_request",
+ value=json.dumps(payload))
- for message in req_consumer:
- # Check the vim desired by the message
- vim_type = json.loads(message.value)["vim_type"].lower()
- if vim_type == "openstack":
- # A valid metric is created
- config_metric.return_value = "metric_id", "resource_id", True
- metric_req.metric_calls(message, openstack_auth, None)
+ for message in self.req_consumer:
+ # Check the vim desired by the message
+ vim_type = json.loads(message.value)["vim_type"].lower()
+ if vim_type == "openstack":
+ # A valid metric is created
+ config_metric.return_value = "metric_id", "resource_id", True
+ self.metric_req.metric_calls(message, self.openstack_auth, None)
- # A response message is generated and sent by MON's producer
- resp.assert_called_with(
- 'create_metric_response', status=True, cor_id=123,
- metric_id="metric_id", r_id="resource_id")
- create_resp.assert_called_with(
- 'create_metric_response', resp.return_value, 'metric_response')
+ # A response message is generated and sent by MON's producer
+ resp.assert_called_with(
+ 'create_metric_response', status=True, cor_id=123,
+ metric_id="metric_id", r_id="resource_id")
+ create_resp.assert_called_with(
+ 'create_metric_response', resp.return_value, 'metric_response')
- return
+ return
+ self.fail("No message received in consumer")
+ @mock.patch.object(metrics.Metrics, "delete_metric")
+ @mock.patch.object(prod, "delete_metric_response")
+ @mock.patch.object(response.OpenStack_Response, "generate_response")
+ def test_delete_metric_req(self, resp, del_resp, del_metric):
+ """Test Gnocchi delete metric request message from producer."""
+ # Set-up message, producer and consumer for tests
+ payload = {"vim_type": "OpenSTACK",
+ "correlation_id": 123,
+ "metric_uuid": "metric_id",
+ "metric_name": "metric_name",
+ "resource_uuid": "resource_id"}
-@mock.patch.object(metrics.Metrics, "delete_metric")
-@mock.patch.object(prod, "delete_metric_response")
-@mock.patch.object(response.OpenStack_Response, "generate_response")
-def test_delete_metric_req(resp, del_resp, del_metric):
- """Test Gnocchi delete metric request message from producer."""
- # Set-up message, producer and consumer for tests
- payload = {"vim_type": "OpenSTACK",
- "correlation_id": 123,
- "metric_uuid": "metric_id",
- "metric_name": "metric_name",
- "resource_uuid": "resource_id"}
+ self.producer.send('metric_request', key="delete_metric_request",
+ value=json.dumps(payload))
- producer.send('metric_request', key="delete_metric_request",
- value=json.dumps(payload))
+ for message in self.req_consumer:
+ # Check the vim desired by the message
+ vim_type = json.loads(message.value)["vim_type"].lower()
+ if vim_type == "openstack":
+ # Metric has been deleted
+ del_metric.return_value = True
+ self.metric_req.metric_calls(message, self.openstack_auth, None)
- for message in req_consumer:
- # Check the vim desired by the message
- vim_type = json.loads(message.value)["vim_type"].lower()
- if vim_type == "openstack":
- # Metric has been deleted
- del_metric.return_value = True
- metric_req.metric_calls(message, openstack_auth, None)
+ # A response message is generated and sent by MON's producer
+ resp.assert_called_with(
+ 'delete_metric_response', m_id="metric_id",
+ m_name="metric_name", status=True, r_id="resource_id",
+ cor_id=123)
+ del_resp.assert_called_with(
+ 'delete_metric_response', resp.return_value, 'metric_response')
- # A response message is generated and sent by MON's producer
- resp.assert_called_with(
- 'delete_metric_response', m_id="metric_id",
- m_name="metric_name", status=True, r_id="resource_id",
- cor_id=123)
- del_resp.assert_called_with(
- 'delete_metric_response', resp.return_value, 'metric_response')
+ return
+ self.fail("No message received in consumer")
- return
+ @mock.patch.object(metrics.Metrics, "read_metric_data")
+ @mock.patch.object(prod, "read_metric_data_response")
+ @mock.patch.object(response.OpenStack_Response, "generate_response")
+ def test_read_metric_data_req(self, resp, read_resp, read_data):
+ """Test Gnocchi read metric data request message from producer."""
+ # Set-up message, producer and consumer for tests
+ payload = {"vim_type": "OpenSTACK",
+ "correlation_id": 123,
+ "metric_uuid": "metric_id",
+ "metric_name": "metric_name",
+ "resource_uuid": "resource_id"}
+ self.producer.send('metric_request', key="read_metric_data_request",
+ value=json.dumps(payload))
-@mock.patch.object(metrics.Metrics, "read_metric_data")
-@mock.patch.object(prod, "read_metric_data_response")
-@mock.patch.object(response.OpenStack_Response, "generate_response")
-def test_read_metric_data_req(resp, read_resp, read_data):
- """Test Gnocchi read metric data request message from producer."""
- # Set-up message, producer and consumer for tests
- payload = {"vim_type": "OpenSTACK",
- "correlation_id": 123,
- "metric_uuid": "metric_id",
- "metric_name": "metric_name",
- "resource_uuid": "resource_id"}
+ for message in self.req_consumer:
+ # Check the vim desired by the message
+ vim_type = json.loads(message.value)["vim_type"].lower()
+ if vim_type == "openstack":
+ # Mock empty lists generated by the request message
+ read_data.return_value = [], []
+ self.metric_req.metric_calls(message, self.openstack_auth, None)
- producer.send('metric_request', key="read_metric_data_request",
- value=json.dumps(payload))
+ # A response message is generated and sent by MON's producer
+ resp.assert_called_with(
+ 'read_metric_data_response', m_id="metric_id",
+ m_name="metric_name", r_id="resource_id", cor_id=123, times=[],
+ metrics=[])
+ read_resp.assert_called_with(
+ 'read_metric_data_response', resp.return_value,
+ 'metric_response')
- for message in req_consumer:
- # Check the vim desired by the message
- vim_type = json.loads(message.value)["vim_type"].lower()
- if vim_type == "openstack":
- # Mock empty lists generated by the request message
- read_data.return_value = [], []
- metric_req.metric_calls(message, openstack_auth, None)
+ return
+ self.fail("No message received in consumer")
- # A response message is generated and sent by MON's producer
- resp.assert_called_with(
- 'read_metric_data_response', m_id="metric_id",
- m_name="metric_name", r_id="resource_id", cor_id=123, times=[],
- metrics=[])
- read_resp.assert_called_with(
- 'read_metric_data_response', resp.return_value,
- 'metric_response')
+ @mock.patch.object(metrics.Metrics, "list_metrics")
+ @mock.patch.object(prod, "list_metric_response")
+ @mock.patch.object(response.OpenStack_Response, "generate_response")
+ def test_list_metrics_req(self, resp, list_resp, list_metrics):
+ """Test Gnocchi list metrics request message from producer."""
+ # Set-up message, producer and consumer for tests
+ payload = {"vim_type": "OpenSTACK",
+ "metrics_list_request":
+ {"correlation_id": 123, }}
- return
+ self.producer.send('metric_request', key="list_metric_request",
+ value=json.dumps(payload))
+ for message in self.req_consumer:
+ # Check the vim desired by the message
+ vim_type = json.loads(message.value)["vim_type"].lower()
+ if vim_type == "openstack":
+ # Mock an empty list generated by the request
+ list_metrics.return_value = []
+ self.metric_req.metric_calls(message, self.openstack_auth, None)
-@mock.patch.object(metrics.Metrics, "list_metrics")
-@mock.patch.object(prod, "list_metric_response")
-@mock.patch.object(response.OpenStack_Response, "generate_response")
-def test_list_metrics_req(resp, list_resp, list_metrics):
- """Test Gnocchi list metrics request message from producer."""
- # Set-up message, producer and consumer for tests
- payload = {"vim_type": "OpenSTACK",
- "metrics_list_request":
- {"correlation_id": 123, }}
+ # A response message is generated and sent by MON's producer
+ resp.assert_called_with(
+ 'list_metric_response', m_list=[], cor_id=123)
+ list_resp.assert_called_with(
+ 'list_metric_response', resp.return_value, 'metric_response')
- producer.send('metric_request', key="list_metric_request",
- value=json.dumps(payload))
+ return
+ self.fail("No message received in consumer")
- for message in req_consumer:
- # Check the vim desired by the message
- vim_type = json.loads(message.value)["vim_type"].lower()
- if vim_type == "openstack":
- # Mock an empty list generated by the request
- list_metrics.return_value = []
- metric_req.metric_calls(message, openstack_auth, None)
+ @mock.patch.object(metrics.Metrics, "get_metric_id")
+ @mock.patch.object(prod, "update_metric_response")
+ @mock.patch.object(response.OpenStack_Response, "generate_response")
+ def test_update_metrics_req(self, resp, update_resp, get_id):
+ """Test Gnocchi update metric request message from KafkaProducer."""
+ # Set-up message, producer and consumer for tests
+ payload = {"vim_type": "OpenSTACK",
+ "correlation_id": 123,
+ "metric_create":
+ {"metric_name": "my_metric",
+ "resource_uuid": "resource_id", }}
- # A response message is generated and sent by MON's producer
- resp.assert_called_with(
- 'list_metric_response', m_list=[], cor_id=123)
- list_resp.assert_called_with(
- 'list_metric_response', resp.return_value, 'metric_response')
+ self.producer.send('metric_request', key="update_metric_request",
+ value=json.dumps(payload))
- return
+ for message in self.req_consumer:
+ # Check the vim desired by the message
+ vim_type = json.loads(message.value)["vim_type"].lower()
+ if vim_type == "openstack":
+ # Gnocchi doesn't support metric updates
+ get_id.return_value = "metric_id"
+ self.metric_req.metric_calls(message, self.openstack_auth, None)
+ # Reponse message is generated and sent via MON's producer
+ # No metric update has taken place
+ resp.assert_called_with(
+ 'update_metric_response', status=False, cor_id=123,
+ r_id="resource_id", m_id="metric_id")
+ update_resp.assert_called_with(
+ 'update_metric_response', resp.return_value, 'metric_response')
-@mock.patch.object(metrics.Metrics, "get_metric_id")
-@mock.patch.object(prod, "update_metric_response")
-@mock.patch.object(response.OpenStack_Response, "generate_response")
-def test_update_metrics_req(resp, update_resp, get_id):
- """Test Gnocchi update metric request message from KafkaProducer."""
- # Set-up message, producer and consumer for tests
- payload = {"vim_type": "OpenSTACK",
- "correlation_id": 123,
- "metric_create":
- {"metric_name": "my_metric",
- "resource_uuid": "resource_id", }}
-
- producer.send('metric_request', key="update_metric_request",
- value=json.dumps(payload))
-
- for message in req_consumer:
- # Check the vim desired by the message
- vim_type = json.loads(message.value)["vim_type"].lower()
- if vim_type == "openstack":
- # Gnocchi doesn't support metric updates
- get_id.return_value = "metric_id"
- metric_req.metric_calls(message, openstack_auth, None)
-
- # Reponse message is generated and sent via MON's producer
- # No metric update has taken place
- resp.assert_called_with(
- 'update_metric_response', status=False, cor_id=123,
- r_id="resource_id", m_id="metric_id")
- update_resp.assert_called_with(
- 'update_metric_response', resp.return_value, 'metric_response')
-
- return
+ return
+ self.fail("No message received in consumer")
diff --git a/osm_mon/test/integration/test_notify_alarm.py b/osm_mon/test/integration/test_notify_alarm.py
index 519624f..96458ba 100644
--- a/osm_mon/test/integration/test_notify_alarm.py
+++ b/osm_mon/test/integration/test_notify_alarm.py
@@ -26,6 +26,7 @@
import logging
import socket
+import unittest
from BaseHTTPServer import BaseHTTPRequestHandler
from BaseHTTPServer import HTTPServer
@@ -72,7 +73,7 @@
def do_GET(self):
"""Mock functionality for GET request."""
-# self.send_response(requests.codes.ok)
+ # self.send_response(requests.codes.ok)
self._set_headers()
pass
@@ -152,38 +153,39 @@
assert response.ok
-@mock.patch.object(KafkaProducer, "notify_alarm")
-@mock.patch.object(OpenStack_Response, "generate_response")
-@mock.patch.object(Common, "_perform_request")
-@mock.patch.object(Common, "get_endpoint")
-@mock.patch.object(Common, "_authenticate")
-def test_post_notify_alarm(auth, endpoint, perf_req, resp, notify):
- """Integration test for notify_alarm."""
- url = 'http://localhost:{port}/users'.format(port=mock_server_port)
- payload = {"severity": "critical",
- "alarm_name": "my_alarm",
- "current": "current_state",
- "alarm_id": "my_alarm_id",
- "reason": "Threshold has been broken",
- "reason_data": {"count": 1,
- "most_recent": "null",
- "type": "threshold",
- "disposition": "unknown"},
- "previous": "previous_state"}
+class AlarmNotificationTest(unittest.TestCase):
+ @mock.patch.object(KafkaProducer, "notify_alarm")
+ @mock.patch.object(OpenStack_Response, "generate_response")
+ @mock.patch.object(Common, "_perform_request")
+ @mock.patch.object(Common, "get_endpoint")
+ @mock.patch.object(Common, "_authenticate")
+ def test_post_notify_alarm(self, auth, endpoint, perf_req, resp, notify):
+ """Integration test for notify_alarm."""
+ url = 'http://localhost:{port}/users'.format(port=mock_server_port)
+ payload = {"severity": "critical",
+ "alarm_name": "my_alarm",
+ "current": "current_state",
+ "alarm_id": "my_alarm_id",
+ "reason": "Threshold has been broken",
+ "reason_data": {"count": 1,
+ "most_recent": "null",
+ "type": "threshold",
+ "disposition": "unknown"},
+ "previous": "previous_state"}
- # Mock authenticate and request response for testing
- auth.return_value = "my_auth_token"
- endpoint.return_value = "my_endpoint"
- perf_req.return_value = MockResponse(valid_get_resp)
+ # Mock authenticate and request response for testing
+ auth.return_value = "my_auth_token"
+ endpoint.return_value = "my_endpoint"
+ perf_req.return_value = MockResponse(valid_get_resp)
- # Generate a post reqest for testing
- requests.post(url, json.dumps(payload))
+ # Generate a post reqest for testing
+ requests.post(url, json.dumps(payload))
- # A response message is generated with the following details
- resp.assert_called_with(
- "notify_alarm", a_id="my_alarm_id", r_id="my_resource_id",
- sev="critical", date='dd-mm-yyyy 00:00', state="current_state",
- vim_type="OpenStack")
+ # A response message is generated with the following details
+ resp.assert_called_with(
+ "notify_alarm", a_id="my_alarm_id", r_id="my_resource_id",
+ sev="critical", date='dd-mm-yyyy 00:00', state="current_state",
+ vim_type="OpenStack")
- # Reponse message is sent back to the SO via MON's producer
- notify.assert_called_with("notify_alarm", mock.ANY, "alarm_response")
+ # Reponse message is sent back to the SO via MON's producer
+ notify.assert_called_with("notify_alarm", mock.ANY, "alarm_response")
diff --git a/osm_mon/test/integration/test_vim_account.py b/osm_mon/test/integration/test_vim_account.py
new file mode 100644
index 0000000..bc610c3
--- /dev/null
+++ b/osm_mon/test/integration/test_vim_account.py
@@ -0,0 +1,77 @@
+# -*- coding: utf-8 -*-
+
+# Copyright 2018 Whitestack, LLC
+# *************************************************************
+
+# This file is part of OSM Monitoring module
+# All Rights Reserved to Whitestack, LLC
+
+# 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.
+
+# For those usages not covered by the Apache License, Version 2.0 please
+# contact: bdiaz@whitestack.com or glavado@whitestack.com
+##
+
+"""Test an end to end Openstack vim_account requests."""
+
+import json
+import logging
+import time
+import unittest
+
+from kafka import KafkaConsumer
+from kafka import KafkaProducer
+from kafka.errors import KafkaError
+
+from osm_mon.core.auth import AuthManager
+
+log = logging.getLogger(__name__)
+
+
+class VimAccountTest(unittest.TestCase):
+ def setUp(self):
+ try:
+ self.producer = KafkaProducer(bootstrap_servers='localhost:9092')
+ self.consumer = KafkaConsumer(bootstrap_servers='localhost:9092',
+ group_id='osm_mon')
+ self.consumer.subscribe(['vim_account'])
+ self.auth_manager = AuthManager()
+ except KafkaError:
+ self.skipTest('Kafka server not present.')
+
+ def test_create_vim_account(self):
+ """Test vim_account creation message from KafkaProducer."""
+ # Set-up message, producer and consumer for tests
+ payload = {
+ "_id": "test_id",
+ "name": "test_name",
+ "vim_type": "openstack",
+ "vim_url": "auth_url",
+ "vim_user": "user",
+ "vim_password": "password",
+ "vim_tenant_name": "tenant",
+ "config":
+ {
+ "foo": "bar"
+ }
+ }
+
+ self.producer.send('vim_account', key=b'create', value=json.dumps(payload))
+
+ self.producer.flush()
+
+ # FIXME: Create a schema for a vim_account_create_response, so we can test it
+ time.sleep(5)
+ creds = self.auth_manager.get_credentials(payload['_id'])
+ self.assertEqual(creds.name, payload['name'])
+ self.assertEqual(json.loads(creds.config), payload['config'])
diff --git a/requirements.txt b/requirements.txt
index 92faf90..bad8167 100644
--- a/requirements.txt
+++ b/requirements.txt
@@ -18,7 +18,7 @@
# For those usages not covered by the Apache License, Version 2.0 please
# contact: prithiv.mohan@intel.com or adrian.hoban@intel.com
-
+peewee
stdeb
MySQL-python
kafka
@@ -37,7 +37,8 @@
boto==2.48
python-cloudwatchlogs-logging
py-cloudwatch
-pyvcloud
+pyvcloud==18.2.*
pyopenssl
six
bottle
+peewee==3.1.*
diff --git a/setup.py b/setup.py
index b91ff35..163d17f 100644
--- a/setup.py
+++ b/setup.py
@@ -50,6 +50,6 @@
data_files = [('/etc/systemd/system/', ['scripts/kafka.sh']),
],
scripts=['osm_mon/plugins/vRealiseOps/vROPs_Webservice/vrops_webservice',
- 'kafkad', 'osm_mon/core/message_bus/common_consumer'],
+ 'kafkad', 'osm_mon/core/message_bus/common_consumer.py'],
include_package_data=True,
)