"""Saves vim credentials. If a record with same uuid exists, overwrite it."""
exists = VimCredentials.get_or_none(VimCredentials.uuid == vim_credentials.uuid)
if exists:
- vim_credentials.id = exists.id
+ vim_credentials.uuid = exists.uuid
vim_credentials.save()
return vim_credentials
+++ /dev/null
-/* Copyright© 2017 Intel Research and Development Ireland Limited
- # This file is part of OSM Monitoring module
- # All Rights Reserved to Intel Corporation
-
- # 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: helena.mcgough@intel.com or adrian.hoban@intel.com
-
- # This is the message bus schema for CloudWatch access credentials */
-
-
-{
- "schema_version": { "type": "string" },
- "schema_type": { "type": "string" },
- "vim_type": { "type": "string" },
- "access_config":
- {
- "aws_site": { "type": "string" },
- "user": { "type": "string" },
- "password": { "type": "string" },
- "vim_tenant_name": { "type": "string" }
- },
- "required": [ "schema_version",
- "schema_type",
- "vim_type",
- "aws_site",
- "user",
- "password",
- "vim_tenant_name" ]
-}
+++ /dev/null
-/* Copyright© 2017 Intel Research and Development Ireland Limited
- # This file is part of OSM Monitoring module
- # All Rights Reserved to Intel Corporation
-
- # 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: helena.mcgough@intel.com or adrian.hoban@intel.com
-
- # This is the message bus schema for OpenStack access credentials */
-
-
-{
- "schema_version": { "type": "string" },
- "schema_type": { "type": "string" },
- "vim_type": { "type": "string" },
- "access_config":
- {
- "vim_uuid": { "type": "string" },
- "openstack_site": { "type" : "string" },
- "user": { "type": "string" },
- "password": { "type": "string" },
- "vim_tenant_name": { "type": "string" }
- },
- "required": [ "schema_version",
- "schema_type",
- "vim_type",
- "vim_uuid",
- "openstack_site",
- "user",
- "password",
- "vim_tenant_name" ]
-}
+++ /dev/null
-/* Copyright© 2017 Intel Research and Development Ireland Limited
- # This file is part of OSM Monitoring module
- # All Rights Reserved to Intel Corporation
-
- # 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: helena.mcgough@intel.com or adrian.hoban@intel.com
-
- # This is the message bus schema for vROPs access credentials */
-
-
-{
- "schema_version": { "type": "string" },
- "schema_type": { "type": "string" },
- "vim_type": { "type": "string" },
- "access_config":
- {
- "vrops_site": { "type": "string" },
- "vrops_user": { "type": "string" },
- "vrops_password": { "type": "string" },
- "vcloud-site": { "type": "string" },
- "admin_username": { "type": "string" },
- "admin_password": { "type": "string" },
- "nsx_manager": { "type": "string" },
- "nsx_user": { "type": "string" },
- "nsx_password": { "type": "string" },
- "vcenter_ip": { "type": "string" },
- "vcenter_port": { "type": "string" },
- "vcenter_user": { "type": "string" },
- "vcenter_password": { "type": "string" },
- "vim_tenant_name": { "type": "string" },
- "orgname": { "type": "string" }
- },
- "required": [ "schema_version",
- "schema_type",
- "vim_type",
- "vrops_site",
- "vrops_user",
- "vrops_password",
- "vcloud-site",
- "admin_username",
- "admin_password",
- "vcenter_ip",
- "vcenter_port",
- "vcenter_user",
- "vcenter_password",
- "vim_tenant_name",
- "orgname" ]
-}
+++ /dev/null
-
-/* Copyright© 2017 Intel Research and Development Ireland Limited
-# This file is part of OSM Monitoring module
-# All Rights Reserved to Intel Corporation
-
-# 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: prithiv.mohan@intel.com or adrian.hoban@intel.com
-
-# This is the message bus schema for acknowledge_alarm */
-
-{
- "schema_version": { "type": "string" },
- "schema_type": { "type": "string" },
- "vim_type": { "type": "string" },
- "vim_uuid": { "type": "string" },
- "ack_details":
- {
- "alarm_uuid": { "type": "string" },
- "ns_id": { "type": "string"},
- "vnf_member_index": { "type": "integer"},
- "vdu_name": { "type": "string"}
- },
- "required": [ "schema_version",
- "schema_type",
- "alarm_uuid",
- "ns_id",
- "vnf_member_index",
- "vdu_name"]
-}
+++ /dev/null
-/* Copyright© 2017 Intel Research and Development Ireland Limited
- # This file is part of OSM Monitoring module
- # All Rights Reserved to Intel Corporation
-
- # 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: prithiv.mohan@intel.com or adrian.hoban@intel.com
-
- # This is the message bus schema to create_metric */
-
-
-{
- "schema_version": { "type": "string" },
- "schema_type": { "type": "string" },
- "metric_create_request":
- {
- "correlation_id": { "type": "integer" },
- "metric_name": { "type" : "string" },
- "metric_unit": { "type": "string" },
- "ns_id": { "type": "string"},
- "vnf_member_index": { "type": "integer"},
- "vdu_name": { "type": "string"}
- },
- "required": [ "schema_version",
- "schema_type",
- "correlation_id",
- "metric_name",
- "metric_unit",
- "ns_id",
- "vnf_member_index",
- "vdu_name" ]
-}
+++ /dev/null
-/* Copyright© 2017 Intel Research and Development Ireland Limited
- # This file is part of OSM Monitoring module
- # All Rights Reserved to Intel Corporation
-
- # 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: prithiv.mohan@intel.com or adrian.hoban@intel.com
-
- # This is the message bus schema for create_metric response*/
-
-{
- "schema_version": { "type": "string" },
- "schema_type": { "type": "string" },
- "metric_create_response":
- {
- "correlation_id": { "type": "integer" },
- "metric_uuid": { "type": "string" },
- "status": { "type": "boolean" }
- },
- "required": [ "schema_type",
- "schema_version",
- "correlation_id",
- "metric_uuid",
- "status" ]
-}
+++ /dev/null
-/* Copyright© 2017 Intel Research and Development Ireland Limited
- # This file is part of OSM Monitoring module
- # All Rights Reserved to Intel Corporation
-
- # 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: prithiv.mohan@intel.com or adrian.hoban@intel.com
-
- # This is the message bus schema to delete_metric */
-
-{
- "schema_version": { "type": "string" },
- "schema_type": { "type": "string" },
- "correlation_id": { "type": "integer" },
- "metric_name": { "type": "string" },
- "ns_id": { "type": "string"},
- "vnf_member_index": { "type": "integer"},
- "vdu_name": { "type": "string"},
- "required": [ "schema_version",
- "schema_type",
- "metric_name",
- "ns_id",
- "vdu_name",
- "vnf_member_index",
- "correlation_id" ]
-}
+++ /dev/null
-/* Copyright© 2017 Intel Research and Development Ireland Limited
- # This file is part of OSM Monitoring module
- # All Rights Reserved to Intel Corporation
-
- # 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: prithiv.mohan@intel.com or adrian.hoban@intel.com
-
- # This is the message bus schema for delete_metric_response */
-
-{
- "schema_version": { "type": "string" },
- "schema_type": { "type": "string" },
- "metric_name": { "type": "string" },
- "metric_uuid": { "type": "string" },
- "resource_uuid": { "type": "string" },
- "correlation_id": { "type": "integer" },
- "status": { "type": "boolean" },
- "required": [ "schema_version",
- "schema_type",
- "metric_name",
- "metric_uuid",
- "resource_uuid",
- "status",
- "correlation_id"]
-}
+++ /dev/null
-/* Copyright© 2017 Intel Research and Development Ireland Limited
- # This file is part of OSM Monitoring module
- # All Rights Reserved to Intel Corporation
-
- # 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: prithiv.mohan@intel.com or adrian.hoban@intel.com
-
- # This is the message bus schema to list_metric */
-
-{
- "schema_version": { "type": "string" },
- "schema_type": { "type": "string" },
- "metrics_list_request":
- {
- "correlation_id": { "type": "integer" },
- "metric_name": { "type": "string" },
- "ns_id": { "type": "string"},
- "vnf_member_index": { "type": "integer"},
- "vdu_name": { "type": "string"}
- },
- "required": [ "schema_version",
- "schema_type",
- "ns_id",
- "vdu_name",
- "vnf_member_index",
- "correlation_id"
- ]
-}
+++ /dev/null
-/* Copyright© 2017 Intel Research and Development Ireland Limited
- # This file is part of OSM Monitoring module
- # All Rights Reserved to Intel Corporation
-
- # 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: prithiv.mohan@intel.com or adrian.hoban@intel.com
-
- # This is the message bus schema for list_metric response */
-
-{
- "schema_version": { "type": "string" },
- "schema_type": { "type": "string" },
- "correlation_id": { "type": "integer" },
- "status": { "type": "boolean" },
- "metrics_list":
- [{
- "type": "array",
- "properties":{
- "metric_name": { "type": "string" },
- "metric_uuid": { "type": "string" },
- "metric_unit": { "type": "string" },
- "resource_uuid": { "type": "string" }
- }
- }],
- "required": [ "schema_version",
- "schema_type",
- "correlation_id",
- "metric_name",
- "metric_uuid",
- "metric_unit",
- "resource_uuid" ]
-}
+++ /dev/null
-/* Copyright© 2017 Intel Research and Development Ireland Limited
- # This file is part of OSM Monitoring module
- # All Rights Reserved to Intel Corporation
-
- # 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: prithiv.mohan@intel.com or adrian.hoban@intel.com
-
- # This is the message bus schema to read_metric_data */
-
-{
- "schema_version": { "type": "string" },
- "schema_type": { "type": "string" },
- "metric_name": { "type": "string" },
- "ns_id": { "type": "string"},
- "vnf_member_index": { "type": "integer"},
- "vdu_name": { "type": "string"},
- "correlation_id": { "type": "integer" },
- "collection_period": { "type": "integer" },
- "collection_unit": { "type": "string" },
- "required": ["schema_version",
- "schema_type",
- "metric_name",
- "metric_uuid",
- "correlation_id",
- "collection_period",
- "collection_unit",
- "ns_id",
- "vdu_name",
- "vnf_member_index"]
-}
+++ /dev/null
-/* Copyright© 2017 Intel Research and Development Ireland Limited
- # This file is part of OSM Monitoring module
- # All Rights Reserved to Intel Corporation
-
- # 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: prithiv.mohan@intel.com or adrian.hoban@intel.com
-
- # This is the message bus schema for read_metric_data response */
-
-{
- "schema_version": { "type": "string" },
- "schema_type": {"type": "string" },
- "metric_name": { "type": "string" },
- "metric_uuid": { "type": "string" },
- "correlation_id": { "type": "integer" },
- "resource_uuid": { "type": "string" },
- "status": { "type": "boolean" },
- "metrics_data":
- {
- "time_series": [{
- "type": "array",
- "properties":
- { "time_stamp":
- { "type": "integer" }}}
- ],
- "metrics_series": [{
- "type": "array",
- "properties":
- { "data":
- { "type":
- ["integer",
- "string",
- "decimal"
- ]
- }
- }
- }
- ],
- },
- "unit": { "type": "string" },
- "required": [ "schema_version",
- "schema_type",
- "metric_name",
- "metric_uuid",
- "resource_uuid",
- "correlation_id",
- "time_series",
- "metrics_series",
- "status" ]
-}
+++ /dev/null
-/* Copyright© 2017 Intel Research and Development Ireland Limited
- # This file is part of OSM Monitoring module
- # All Rights Reserved to Intel Corporation
-
- # 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: prithiv.mohan@intel.com or adrian.hoban@intel.com
-
- # This is the message bus schema for update_metric response */
-
-{
- "schema_version": { "type": "string" },
- "schema_type": { "type": "string" },
- "metric_update_request":
- {
- "correlation_id": { "type": "integer" },
- "metric_name": { "type": "string" },
- "metric_unit": { "type": "string" },
- "ns_id": { "type": "string"},
- "vnf_member_index": { "type": "integer"},
- "vdu_name": { "type": "string"}
- },
- "required": [ "schema_version",
- "schema_type",
- "correlation_id",
- "metric_name",
- "metric_unit",
- "ns_id",
- "vdu_name",
- "vnf_member_index"
- ]
-}
+++ /dev/null
-/* Copyright© 2017 Intel Research and Development Ireland Limited
- # This file is part of OSM Monitoring module
- # All Rights Reserved to Intel Corporation
-
- # 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: prithiv.mohan@intel.com or adrian.hoban@intel.com
-
- # This is the message bus schema to update_metric */
-
-{
- "schema_version": { "type": "string" },
- "schema_type": { "type": "string" },
- "correlation_id": { "type": "integer" },
- "metric_update_response":
- {
- "metric_uuid": { "type": "string" },
- "status": { "type": "boolean" },
- "resource_uuid": { "type": "string" }
- },
- "required": [ "schema_version",
- "schema_type",
- "correlation_id",
- "metric_uuid",
- "resource_uuid",
- "status"]
-}
CfgParam('BROKER_URI', "localhost:9092", six.text_type),
CfgParam('MONGO_URI', "mongodb://mongo:27017", six.text_type),
CfgParam('DATABASE', "sqlite:///mon_sqlite.db", six.text_type),
- CfgParam('OS_NOTIFIER_URI', "http://localhost:8662", six.text_type),
CfgParam('OS_DEFAULT_GRANULARITY', 300, int),
CfgParam('REQUEST_TIMEOUT', 10, int),
CfgParam('OSMMON_LOG_LEVEL', "INFO", six.text_type),
+++ /dev/null
-##
-# Copyright 2017 xFlow Research Pvt. Ltd
-# This file is part of MON module
-# All Rights Reserved.
-#
-# 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 with: usman.javaid@xflowresearch.com
-##
-
-"""
-Access credentials class implements all the methods to store the access credentials for AWS
-"""
-
-__author__ = "Usman Javaid"
-__date__ = "20-December-2017"
-
-import json
-import logging
-import os
-
-log = logging.getLogger(__name__)
-
-
-class AccessCredentials():
-
- def logtest(self):
- log.info("Access credentials sourced for CloudWatch MON plugin")
-
- def access_credential_calls(self, message):
- try:
- message = json.loads(message.value)['access_config']
-
- AWS_KEY = message['user']
- AWS_SECRET = message['password']
- AWS_REGION = message['vim_tenant_name']
-
- os.environ['AWS_ACCESS_KEY_ID'] = AWS_KEY
- os.environ['AWS_SECRET_ACCESS_KEY'] = AWS_SECRET
- os.environ['AWS_EC2_REGION'] = AWS_REGION
-
- # aws_credentials.txt file to save the access credentials
- cloudwatch_credentials = open("../../plugins/CloudWatch/cloudwatch_credentials.txt", "w+")
- cloudwatch_credentials.write("AWS_ACCESS_KEY_ID=" + AWS_KEY +
- "\nAWS_SECRET_ACCESS_KEY=" + AWS_SECRET +
- "\nAWS_EC2_REGION=" + AWS_REGION)
-
- # Closing the file
- cloudwatch_credentials.close()
- log.info("Access credentials sourced for CloudWatch MON plugin")
-
- except Exception as e:
- log.error("Access credentials not provided correctly: %s", str(e))
+++ /dev/null
-##
-# Copyright 2017 xFlow Research Pvt. Ltd
-# This file is part of MON module
-# All Rights Reserved.
-#
-# 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 with: wajeeha.hamid@xflowresearch.com
-##
-
-"""
-Connecting with AWS services --CloudWatch/EC2 using Required keys
-"""
-
-__author__ = "Wajeeha Hamid"
-__date__ = "18-September-2017"
-
-import os
-
-try:
- import boto
- import boto.ec2
- import boto.vpc
- import boto.ec2.cloudwatch
- import boto.ec2.connection
- import logging
- from boto.ec2.cloudwatch.alarm import MetricAlarm
- from boto.ec2.cloudwatch.dimension import Dimension
- from boto.sns import connect_to_region
- from boto.utils import get_instance_metadata
-
-except:
- exit("Boto not available. Try activating your virtualenv OR `pip install boto`")
-
-log = logging.getLogger(__name__)
-
-
-class Connection:
- """Connection Establishment with AWS -- VPC/EC2/CloudWatch"""
-
- def setEnvironment(self):
- try:
- """Credentials for connecting to AWS-CloudWatch"""
- # Reads from the environment variables
- self.AWS_KEY = os.environ.get("AWS_ACCESS_KEY_ID")
- self.AWS_SECRET = os.environ.get("AWS_SECRET_ACCESS_KEY")
- self.AWS_REGION = os.environ.get("AWS_EC2_REGION", "us-west-2")
-
- # TODO Read from the cloudwatch_credentials.txt file
-
- return self.connection_instance()
- except Exception as e:
- log.error("AWS Credentials not configured, Try setting the access credentials first %s: ", str(e))
-
- def connection_instance(self):
- try:
- # VPC Connection
- self.vpc_conn = boto.vpc.connect_to_region(self.AWS_REGION,
- aws_access_key_id=self.AWS_KEY,
- aws_secret_access_key=self.AWS_SECRET)
-
- # EC2 Connection
- self.ec2_conn = boto.ec2.connect_to_region(self.AWS_REGION,
- aws_access_key_id=self.AWS_KEY,
- aws_secret_access_key=self.AWS_SECRET)
-
- """ TODO : Required to add actions against alarms when needed """
- # self.sns = connect_to_region(self.AWS_REGION)
- # self.topics = self.sns.get_all_topics()
- # self.topic = self.topics[u'ListTopicsResponse']['ListTopicsResult']['Topics'][0]['TopicArn']
-
- # Cloudwatch Connection
- self.cloudwatch_conn = boto.ec2.cloudwatch.connect_to_region(
- self.AWS_REGION,
- aws_access_key_id=self.AWS_KEY,
- aws_secret_access_key=self.AWS_SECRET)
- connection_dict = dict()
- connection_dict['ec2_connection'] = self.ec2_conn
- connection_dict['cloudwatch_connection'] = self.cloudwatch_conn
- return connection_dict
-
- except Exception as e:
- log.error("Failed to Connect with AWS %s: ", str(e))
+++ /dev/null
-##
-# Copyright 2017 xFlow Research Pvt. Ltd
-# This file is part of MON module
-# All Rights Reserved.
-#
-# 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 with: wajeeha.hamid@xflowresearch.com
-##
-
-''' Handling of alarms requests via BOTO 2.48 '''
-
-__author__ = "Wajeeha Hamid"
-__date__ = "18-September-2017"
-
-import logging
-
-log = logging.getLogger(__name__)
-
-try:
- import boto
- import boto.ec2
- import boto.vpc
- import boto.ec2.cloudwatch
- import boto.ec2.connection
-except:
- exit("Boto not avialable. Try activating your virtualenv OR `pip install boto`")
-
-STATISTICS = {
- "AVERAGE": "Average",
- "MINIMUM": "Minimum",
- "MAXIMUM": "Maximum",
- "COUNT": "SampleCount",
- "SUM": "Sum"}
-
-OPERATIONS = {
- "GE": ">=",
- "LE": "<=",
- "GT": ">",
- "LT": "<",
- "EQ": "="}
-
-
-class MetricAlarm():
- """Alarms Functionality Handler -- Carries out alarming requests and responses via BOTO.Cloudwatch """
-
- def __init__(self):
- self.alarm_resp = dict()
- self.del_resp = dict()
-
- def config_alarm(self, cloudwatch_conn, create_info):
- """Configure or Create a new alarm"""
- inner_dict = dict()
- """ Alarm Name to ID Mapping """
- alarm_info = create_info['alarm_create_request']
- alarm_id = alarm_info['alarm_name'] + "_" + alarm_info['resource_uuid']
- if self.is_present(cloudwatch_conn, alarm_id)['status'] == True:
- alarm_id = None
- log.debug("Alarm already exists, Try updating the alarm using 'update_alarm_configuration()'")
- return alarm_id
- else:
- try:
- if alarm_info['statistic'] in STATISTICS:
- if alarm_info['operation'] in OPERATIONS:
- alarm = boto.ec2.cloudwatch.alarm.MetricAlarm(
- connection=cloudwatch_conn,
- name=alarm_info['alarm_name'] + "_" + alarm_info['resource_uuid'],
- metric=alarm_info['metric_name'],
- namespace="AWS/EC2",
- statistic=STATISTICS[alarm_info['statistic']],
- comparison=OPERATIONS[alarm_info['operation']],
- threshold=alarm_info['threshold_value'],
- period=60,
- evaluation_periods=1,
- unit=alarm_info['unit'],
- description=alarm_info['severity'] + ";" + alarm_id + ";" + alarm_info['description'],
- dimensions={'InstanceId': alarm_info['resource_uuid']},
- alarm_actions=None,
- ok_actions=None,
- insufficient_data_actions=None)
-
- """Setting Alarm Actions :
- alarm_actions = ['arn:aws:swf:us-west-2:465479087178:action/actions/AWS_EC2.InstanceId.Stop/1.0']"""
-
- status = cloudwatch_conn.put_metric_alarm(alarm)
-
- log.debug("Alarm Configured Succesfully")
- self.alarm_resp['schema_version'] = str(create_info['schema_version'])
- self.alarm_resp['schema_type'] = 'create_alarm_response'
-
- inner_dict['correlation_id'] = str(alarm_info['correlation_id'])
- inner_dict['alarm_uuid'] = str(alarm_id)
- inner_dict['status'] = status
-
- self.alarm_resp['alarm_create_response'] = inner_dict
-
- if status == True:
- return self.alarm_resp
- else:
- return None
- else:
- log.error("Operation not supported")
- return None
- else:
- log.error("Statistic not supported")
- return None
- except Exception as e:
- log.error("Alarm Configuration Failed: " + str(e))
-
- def update_alarm(self, cloudwatch_conn, update_info):
-
- """Update or reconfigure an alarm"""
- inner_dict = dict()
- alarm_info = update_info['alarm_update_request']
-
- """Alarm Name to ID Mapping"""
- alarm_id = alarm_info['alarm_uuid']
- status = self.is_present(cloudwatch_conn, alarm_id)
-
- """Verifying : Alarm exists already"""
- if status['status'] == False:
- alarm_id = None
- log.debug("Alarm not found, Try creating the alarm using 'configure_alarm()'")
- return alarm_id
- else:
- try:
- if alarm_info['statistic'] in STATISTICS:
- if alarm_info['operation'] in OPERATIONS:
- alarm = boto.ec2.cloudwatch.alarm.MetricAlarm(
- connection=cloudwatch_conn,
- name=status['info'].name,
- metric=alarm_info['metric_name'],
- namespace="AWS/EC2",
- statistic=STATISTICS[alarm_info['statistic']],
- comparison=OPERATIONS[alarm_info['operation']],
- threshold=alarm_info['threshold_value'],
- period=60,
- evaluation_periods=1,
- unit=alarm_info['unit'],
- description=alarm_info['severity'] + ";" + alarm_id + ";" + alarm_info['description'],
- dimensions={'InstanceId': str(status['info'].dimensions['InstanceId']).split("'")[1]},
- alarm_actions=None,
- ok_actions=None,
- insufficient_data_actions=None)
-
- """Setting Alarm Actions :
- alarm_actions = ['arn:aws:swf:us-west-2:465479087178:action/actions/AWS_EC2.InstanceId.Stop/1.0']"""
-
- status = cloudwatch_conn.put_metric_alarm(alarm)
- log.debug("Alarm %s Updated ", alarm.name)
- self.alarm_resp['schema_version'] = str(update_info['schema_version'])
- self.alarm_resp['schema_type'] = 'update_alarm_response'
-
- inner_dict['correlation_id'] = str(alarm_info['correlation_id'])
- inner_dict['alarm_uuid'] = str(alarm_id)
- inner_dict['status'] = status
-
- self.alarm_resp['alarm_update_response'] = inner_dict
- return self.alarm_resp
- else:
- log.error("Operation not supported")
- return None
- else:
- log.error("Statistic not supported")
- return None
- except Exception as e:
- log.error("Error in Updating Alarm " + str(e))
-
- def delete_Alarm(self, cloudwatch_conn, del_info_all):
-
- """Deletes an Alarm with specified alarm_id"""
- inner_dict = dict()
- del_info = del_info_all['alarm_delete_request']
- status = self.is_present(cloudwatch_conn, del_info['alarm_uuid'])
- try:
- if status['status'] == True:
- del_status = cloudwatch_conn.delete_alarms(status['info'].name)
- self.del_resp['schema_version'] = str(del_info_all['schema_version'])
- self.del_resp['schema_type'] = 'delete_alarm_response'
- inner_dict['correlation_id'] = str(del_info['correlation_id'])
- inner_dict['alarm_id'] = str(del_info['alarm_uuid'])
- inner_dict['status'] = del_status
- self.del_resp['alarm_deletion_response'] = inner_dict
- return self.del_resp
- return None
- except Exception as e:
- log.error("Alarm Not Deleted: " + str(e))
-
- def alarms_list(self, cloudwatch_conn, list_info):
-
- """Get a list of alarms that are present on a particular VIM type"""
- alarm_list = []
- alarm_info = dict()
- inner_dict = list_info['alarm_list_request']
- try: # id vim
- alarms = cloudwatch_conn.describe_alarms()
- itr = 0
- for alarm in alarms:
- list_info['alarm_list_request']['alarm_uuid'] = str(alarm.description).split(';')[1]
-
- # Severity = alarm_name = resource_uuid = ""
- if inner_dict['severity'] == "" and inner_dict['alarm_name'] == "" and inner_dict[
- 'resource_uuid'] == "":
- alarm_list.insert(itr, self.alarm_details(cloudwatch_conn, list_info))
- itr += 1
- # alarm_name = resource_uuid = ""
- if inner_dict['severity'] == str(alarm.description).split(';')[0] and inner_dict['alarm_name'] == "" and \
- inner_dict['resource_uuid'] == "":
- alarm_list.insert(itr, self.alarm_details(cloudwatch_conn, list_info))
- itr += 1
- # severity = resource_uuid = ""
- if inner_dict['severity'] == "" and inner_dict['alarm_name'] in alarm.name and inner_dict[
- 'resource_uuid'] == "":
- alarm_list.insert(itr, self.alarm_details(cloudwatch_conn, list_info))
- itr += 1
- # severity = alarm_name = ""
- if inner_dict['severity'] == "" and inner_dict['alarm_name'] == "" and inner_dict['resource_uuid'] == \
- str(alarm.dimensions['InstanceId']).split("'")[1]:
- alarm_list.insert(itr, self.alarm_details(cloudwatch_conn, list_info))
- itr += 1
- # resource_uuid = ""
- if inner_dict['severity'] == str(alarm.description).split(';')[0] and inner_dict[
- 'alarm_name'] in alarm.name and inner_dict['resource_uuid'] == "":
- alarm_list.insert(itr, self.alarm_details(cloudwatch_conn, list_info))
- itr += 1
- # alarm_name = ""
- if inner_dict['severity'] == str(alarm.description).split(';')[0] and inner_dict['alarm_name'] == "" and \
- inner_dict['resource_uuid'] == str(alarm.dimensions['InstanceId']).split("'")[1]:
- alarm_list.insert(itr, self.alarm_details(cloudwatch_conn, list_info))
- itr += 1
- # severity = ""
- if inner_dict['severity'] == "" and inner_dict['alarm_name'] in alarm.name and inner_dict[
- 'resource_uuid'] == str(alarm.dimensions['InstanceId']).split("'")[1]:
- alarm_list.insert(itr, self.alarm_details(cloudwatch_conn, list_info))
- itr += 1
- # Everything provided
- if inner_dict['severity'] == str(alarm.description).split(';')[0] and inner_dict[
- 'alarm_name'] in alarm.name and inner_dict['resource_uuid'] == \
- str(alarm.dimensions['InstanceId']).split("'")[1]:
- alarm_list.insert(itr, self.alarm_details(cloudwatch_conn, list_info))
- itr += 1
-
- alarm_info['schema_version'] = str(list_info['schema_version'])
- alarm_info['schema_type'] = 'list_alarm_response'
- alarm_info['list_alarm_response'] = alarm_list
-
- return alarm_info
- except Exception as e:
- log.error("Error in Getting List : %s", str(e))
-
- def alarm_details(self, cloudwatch_conn, ack_info):
-
- """Get an individual alarm details specified by alarm_name"""
- try:
- alarms_details = cloudwatch_conn.describe_alarm_history()
- alarm_details_all = dict()
- alarm_details_dict = dict()
- ack_info_all = ack_info
-
- if 'ack_details' in ack_info:
- ack_info = ack_info['ack_details']
- elif 'alarm_list_request' in ack_info:
- ack_info = ack_info['alarm_list_request']
-
- is_present = self.is_present(cloudwatch_conn, ack_info['alarm_uuid'])
-
- for itr in range(len(alarms_details)):
- if alarms_details[itr].name == is_present['info'].name: # name, timestamp, summary
- if 'created' in alarms_details[itr].summary:
- alarm_details_dict['status'] = "New"
- elif 'updated' in alarms_details[itr].summary:
- alarm_details_dict['status'] = "Update"
- elif 'deleted' in alarms_details[itr].summary:
- alarm_details_dict['status'] = "Canceled"
-
- status = alarms_details[itr].summary.split()
- alarms = cloudwatch_conn.describe_alarms()
- for alarm in alarms:
- if str(alarm.description).split(';')[1] == ack_info['alarm_uuid']:
- alarm_details_dict['alarm_uuid'] = str(ack_info['alarm_uuid'])
- alarm_details_dict['resource_uuid'] = str(alarm.dimensions['InstanceId']).split("'")[1]
- alarm_details_dict['description'] = str(alarm.description).split(';')[1]
- alarm_details_dict['severity'] = str(alarm.description).split(';')[0]
- alarm_details_dict['start_date_time'] = str(alarms_details[itr].timestamp)
- alarm_details_dict['vim_type'] = str(ack_info_all['vim_type'])
- # TODO : tenant id
- if 'ack_details' in ack_info_all:
- alarm_details_all['schema_version'] = str(ack_info_all['schema_version'])
- alarm_details_all['schema_type'] = 'notify_alarm'
- alarm_details_all['notify_details'] = alarm_details_dict
- return alarm_details_all
-
- elif 'alarm_list_request' in ack_info_all:
- return alarm_details_dict
-
- except Exception as e:
- log.error("Error getting alarm details: %s", str(e))
-
- def is_present(self, cloudwatch_conn, alarm_id):
- """Finding alarm from already configured alarms"""
- alarm_info = dict()
- try:
- alarms = cloudwatch_conn.describe_alarms()
- for alarm in alarms:
- if str(alarm.description).split(';')[1] == alarm_id:
- alarm_info['status'] = True
- alarm_info['info'] = alarm
- return alarm_info
- alarm_info['status'] = False
- return alarm_info
- except Exception as e:
- log.error("Error Finding Alarm", str(e))
+++ /dev/null
-##
-# Copyright 2017 xFlow Research Pvt. Ltd
-# This file is part of MON module
-# All Rights Reserved.
-#
-# 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 with: wajeeha.hamid@xflowresearch.com
-##
-
-"""
-AWS-Plugin implements all the methods of MON to interact with AWS using the BOTO client
-"""
-
-__author__ = "Wajeeha Hamid"
-__date__ = "18-Sept-2017"
-
-import datetime
-import logging
-
-try:
- import boto
- import boto.ec2
- import boto.vpc
- import boto.ec2.cloudwatch
- import boto.ec2.connection
-except:
- exit("Boto not avialable. Try activating your virtualenv OR `pip install boto`")
-
-log = logging.getLogger(__name__)
-
-
-class Metrics:
-
- def createMetrics(self, cloudwatch_conn, metric_info):
- try:
-
- """createMetrics will be returning the metric_uuid=0 and
- status=True when the metric is supported by AWS"""
-
- supported = self.check_metric(metric_info['metric_name'])
- metric_resp = dict()
- metric_resp['resource_uuid'] = metric_info['resource_uuid']
-
- if supported['status']:
- metric_resp['status'] = True
- metric_resp['metric_uuid'] = 0
- log.debug("Metrics Configured Successfully : %s", metric_resp)
- else:
- metric_resp['status'] = False
- metric_resp['metric_uuid'] = None
- log.error("Metric name is not supported")
-
- return metric_resp
-
- except Exception as e:
- log.error("Metric Configuration Failed: " + str(e))
-
- def metricsData(self, cloudwatch_conn, data_info):
-
- """Getting Metrics Stats for an Hour.The datapoints are
- received after every one minute.
- Time interval can be modified using Timedelta value"""
-
- try:
- metric_info = dict()
- metric_info_dict = dict()
- timestamp_arr = {}
- value_arr = {}
-
- supported = self.check_metric(data_info['metric_name'])
-
- if supported['status']:
- if int(data_info['collection_period']) % 60 == 0:
- metric_stats = cloudwatch_conn.get_metric_statistics(60,
- datetime.datetime.utcnow() - datetime.timedelta(
- seconds=int(
- data_info['collection_period'])),
- datetime.datetime.utcnow(),
- supported['metric_name'], 'AWS/EC2', 'Maximum',
- dimensions={
- 'InstanceId': data_info['resource_uuid']},
- unit='Percent')
- index = 0
- for itr in range(len(metric_stats)):
- timestamp_arr[index] = str(metric_stats[itr]['Timestamp'])
- value_arr[index] = metric_stats[itr]['Maximum']
- index += 1
- metric_info_dict['time_series'] = timestamp_arr
- metric_info_dict['metrics_series'] = value_arr
- log.debug("Metrics Data : %s", metric_info_dict)
- return metric_info_dict
- else:
- log.error("Collection Period should be a multiple of 60")
- return False
-
- else:
- log.error("Metric name is not supported")
- return False
-
- except Exception as e:
- log.error("Error returning Metrics Data" + str(e))
-
- def updateMetrics(self, cloudwatch_conn, metric_info):
-
- """updateMetrics will be returning the metric_uuid=0 and
- status=True when the metric is supported by AWS"""
- try:
- supported = self.check_metric(metric_info['metric_name'])
- update_resp = dict()
- update_resp['resource_uuid'] = metric_info['resource_uuid']
- if supported['status']:
- update_resp['status'] = True
- update_resp['metric_uuid'] = 0
- log.debug("Metric Updated : %s", update_resp)
- else:
- update_resp['status'] = False
- update_resp['metric_uuid'] = None
- log.error("Metric name is not supported")
-
- return update_resp
-
- except Exception as e:
- log.error("Error in Update Metrics" + str(e))
-
- def deleteMetrics(self, cloudwatch_conn, del_info):
-
- """ " Not supported in AWS"
- Returning the required parameters with status = False"""
- try:
- supported = self.check_metric(del_info['metric_name'])
- metric_resp = dict()
- del_resp = dict()
- if supported['status']:
- del_resp['schema_version'] = del_info['schema_version']
- del_resp['schema_type'] = "delete_metric_response"
- del_resp['metric_name'] = del_info['metric_name']
- del_resp['metric_uuid'] = del_info['metric_uuid']
- del_resp['resource_uuid'] = del_info['resource_uuid']
- # TODO : yet to finalize
- del_resp['tenant_uuid'] = del_info['tenant_uuid']
- del_resp['correlation_id'] = del_info['correlation_uuid']
- del_resp['status'] = False
- log.info("Metric Deletion Not supported in AWS : %s", del_resp)
- return del_resp
- else:
- log.error("Metric name is not supported")
- return False
-
- except Exception as e:
- log.error(" Metric Deletion Not supported in AWS : " + str(e))
-
- def listMetrics(self, cloudwatch_conn, list_info):
-
- """Returns the list of available AWS/EC2 metrics on which
- alarms have been configured and the metrics are being monitored"""
- try:
- supported = self.check_metric(list_info['metric_name'])
- if supported['status']:
- metrics_list = []
- metrics_data = dict()
-
- # To get the list of associated metrics with the alarms
- alarms = cloudwatch_conn.describe_alarms()
- itr = 0
- if list_info['metric_name'] == "":
- for alarm in alarms:
- metrics_info = dict()
- instance_id = str(alarm.dimensions['InstanceId']).split("'")[1]
- metrics_info['metric_name'] = str(alarm.metric)
- metrics_info['metric_uuid'] = 0
- metrics_info['metric_unit'] = str(alarm.unit)
- metrics_info['resource_uuid'] = instance_id
- metrics_list.insert(itr, metrics_info)
- itr += 1
- log.info(metrics_list)
- return metrics_list
- else:
- for alarm in alarms:
- metrics_info = dict()
- if alarm.metric == supported['metric_name']:
- instance_id = str(alarm.dimensions['InstanceId']).split("'")[1]
- metrics_info['metric_name'] = str(alarm.metric)
- metrics_info['metric_uuid'] = 0
- metrics_info['metric_unit'] = str(alarm.unit)
- metrics_info['resource_uuid'] = instance_id
- metrics_list.insert(itr, metrics_info)
- itr += 1
- return metrics_list
- else:
- log.error("Metric name is not supported")
- return False
-
- except Exception as e:
- log.error("Error in Getting Metric List " + str(e))
-
- def check_metric(self, metric_name):
-
- """ Checking whether the metric is supported by AWS """
- try:
- check_resp = dict()
- # metric_name
- if metric_name == 'CPU_UTILIZATION':
- metric_name = 'CPUUtilization'
- metric_status = True
- elif metric_name == 'DISK_READ_OPS':
- metric_name = 'DiskReadOps'
- metric_status = True
- elif metric_name == 'DISK_WRITE_OPS':
- metric_name = 'DiskWriteOps'
- metric_status = True
- elif metric_name == 'DISK_READ_BYTES':
- metric_name = 'DiskReadBytes'
- metric_status = True
- elif metric_name == 'DISK_WRITE_BYTES':
- metric_name = 'DiskWriteBytes'
- metric_status = True
- elif metric_name == 'PACKETS_RECEIVED':
- metric_name = 'NetworkPacketsIn'
- metric_status = True
- elif metric_name == 'PACKETS_SENT':
- metric_name = 'NetworkPacketsOut'
- metric_status = True
- elif metric_name == "":
- metric_name = None
- metric_status = True
- log.info("Metric Not Supported by AWS plugin ")
- else:
- metric_name = None
- metric_status = False
- log.info("Metric Not Supported by AWS plugin ")
- check_resp['metric_name'] = metric_name
- # status
- if metric_status:
- check_resp['status'] = True
- else:
- check_resp['status'] = False
-
- return check_resp
-
- except Exception as e:
- log.error("Error in Plugin Inputs %s", str(e))
+++ /dev/null
-##
-# Copyright 2017 xFlow Research Pvt. Ltd
-# This file is part of MON module
-# All Rights Reserved.
-#
-# 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 with: wajeeha.hamid@xflowresearch.com
-##
-
-"""
-AWS-Plugin implements all the methods of MON to interact with AWS using the BOTO client
-"""
-from io import UnsupportedOperation
-
-from osm_mon.core.settings import Config
-from osm_mon.plugins.CloudWatch.metric_alarms import MetricAlarm
-from osm_mon.plugins.CloudWatch.metrics import Metrics
-
-__author__ = "Wajeeha Hamid"
-__date__ = "18-September-2017"
-
-import logging
-
-log = logging.getLogger(__name__)
-
-
-class plugin_alarms:
- """Receives Alarm info from MetricAlarm and connects with the consumer/producer"""
-
- def __init__(self):
- self._cfg = Config.instance()
- self.metricAlarm = MetricAlarm()
- self.metric = Metrics()
-
- def configure_alarm(self, alarm_info):
- alarm_id = self.metricAlarm.config_alarm(self.cloudwatch_conn, alarm_info)
- return alarm_id
-
- def update_alarm_configuration(self, test):
- alarm_id = self.metricAlarm.update_alarm(self.cloudwatch_conn, test)
- return alarm_id
-
- def delete_alarm(self, alarm_id):
- return self.metricAlarm.delete_Alarm(self.cloudwatch_conn, alarm_id)
-
- def get_alarms_list(self, instance_id):
- return self.metricAlarm.alarms_list(self.cloudwatch_conn, instance_id)
-
- def get_ack_details(self, ack_info):
- return self.metricAlarm.alarm_details(self.cloudwatch_conn, ack_info)
-
- def get_metrics_data(self, metric_name, period, instance_id):
- # TODO: Investigate and fix this call
- return self.metric.metricsData(self.cloudwatch_conn, metric_name, period, instance_id)
-
- def alarm_calls(self, key: str, alarm_info: dict, aws_conn: dict):
- """Gets the message from the common consumer"""
- try:
- self.cloudwatch_conn = aws_conn['cloudwatch_connection']
- self.ec2_conn = aws_conn['ec2_connection']
-
- if key == "create_alarm_request":
- alarm_inner_dict = alarm_info['alarm_create_request']
- metric_status = self.check_metric(alarm_inner_dict['metric_name'])
-
- if self.check_resource(alarm_inner_dict['resource_uuid']) and metric_status['status']:
- log.debug("Resource and Metrics exists")
-
- alarm_info['alarm_create_request']['metric_name'] = metric_status['metric_name']
- # Generate a valid response message, send via producer
- config_resp = self.configure_alarm(alarm_info) # alarm_info = message.value
-
- if config_resp is None:
- log.debug("Alarm Already exists")
- # TODO: This should return a response with status False
- return config_resp
-
- else:
- log.info("New alarm created with alarm info: %s", config_resp)
- return config_resp
-
- else:
- log.error("Resource ID doesn't exists")
-
- elif key == "acknowledge_alarm":
- alarm_inner_dict = alarm_info['ack_details']
-
- if self.check_resource(alarm_inner_dict['resource_uuid']):
- ack_details = self.get_ack_details(alarm_info)
- log.info("Acknowledge sent: %s", ack_details)
- return ack_details
-
- else:
- log.error("Resource ID is Incorrect")
-
- elif key == "update_alarm_request":
- alarm_inner_dict = alarm_info['alarm_update_request']
- metric_status = self.check_metric(alarm_inner_dict['metric_name'])
-
- if metric_status['status']:
- log.debug("Resource and Metrics exists")
- alarm_info['alarm_update_request']['metric_name'] = metric_status['metric_name']
- # Generate a valid response message, send via producer
- update_resp = self.update_alarm_configuration(alarm_info)
-
- if update_resp is None:
- # TODO: This should return a response with status False
- log.debug("Alarm Already exists")
- return update_resp
-
- else:
- log.info("Alarm Updated with alarm info: %s", update_resp)
- return update_resp
-
- else:
- log.info("Metric Not Supported")
-
- elif key == "delete_alarm_request":
- # Generate a valid response message, send via producer
- del_resp = self.delete_alarm(alarm_info)
- log.info("Alarm Deleted with alarm info: %s", del_resp)
- return del_resp
-
- elif key == "alarm_list_request":
- alarm_inner_dict = alarm_info['alarm_list_request']
-
- if self.check_resource(alarm_inner_dict['resource_uuid']) or alarm_inner_dict['resource_uuid'] == "":
- # Generate a valid response message, send via producer
- list_resp = self.get_alarms_list(alarm_info) # ['alarm_names']
- return list_resp
- else:
- log.error("Resource ID is Incorrect")
-
- else:
- raise UnsupportedOperation("Unknown key, no action will be performed")
-
- except Exception as e:
- log.error("Message retrieval exception: %s", str(e))
-
- def check_resource(self, resource_uuid):
- """Finding Resource with the resource_uuid"""
- try:
- check_resp = dict()
- instances = self.ec2_conn.get_all_instance_status()
-
- # resource_id
- for instance_id in instances:
- instance_id = str(instance_id).split(':')[1]
-
- if instance_id == resource_uuid:
- check_resp['resource_uuid'] = resource_uuid
- return True
- return False
-
- except Exception as e:
- log.error("Error in Plugin Inputs %s", str(e))
-
- def check_metric(self, metric_name):
- """ Checking whether the metric is supported by AWS """
- try:
- check_resp = dict()
-
- # metric_name
- if metric_name == 'CPU_UTILIZATION':
- metric_name = 'CPUUtilization'
- metric_status = True
-
- elif metric_name == 'DISK_READ_OPS':
- metric_name = 'DiskReadOps'
- metric_status = True
-
- elif metric_name == 'DISK_WRITE_OPS':
- metric_name = 'DiskWriteOps'
- metric_status = True
-
- elif metric_name == 'DISK_READ_BYTES':
- metric_name = 'DiskReadBytes'
- metric_status = True
-
- elif metric_name == 'DISK_WRITE_BYTES':
- metric_name = 'DiskWriteBytes'
- metric_status = True
-
- elif metric_name == 'PACKETS_RECEIVED':
- metric_name = 'NetworkPacketsIn'
- metric_status = True
-
- elif metric_name == 'PACKETS_SENT':
- metric_name = 'NetworkPacketsOut'
- metric_status = True
-
- else:
- metric_name = None
- metric_status = False
- check_resp['metric_name'] = metric_name
- # status
-
- if metric_status:
- check_resp['status'] = True
- return check_resp
-
- except Exception as e:
- log.error("Error in Plugin Inputs %s", str(e))
+++ /dev/null
-##
-# Copyright 2017 xFlow Research Pvt. Ltd
-# This file is part of MON module
-# All Rights Reserved.
-#
-# 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 with: wajeeha.hamid@xflowresearch.com
-##
-
-"""
-AWS-Plugin implements all the methods of MON to interact with AWS using the BOTO client
-"""
-from io import UnsupportedOperation
-
-from osm_mon.core.settings import Config
-from osm_mon.plugins.CloudWatch.metrics import Metrics
-
-__author__ = "Wajeeha Hamid"
-__date__ = "18-September-2017"
-
-import logging
-
-log = logging.getLogger(__name__)
-
-
-class plugin_metrics:
- """Receives Alarm info from MetricAlarm and connects with the consumer/producer """
-
- def __init__(self):
- self._cfg = Config.instance()
- self.metric = Metrics()
-
- def create_metric_request(self, metric_info):
- """Compatible API using normalized parameters"""
- metric_resp = self.metric.createMetrics(self.cloudwatch_conn, metric_info)
- return metric_resp
-
- def update_metric_request(self, updated_info):
- """Compatible API using normalized parameters"""
- update_resp = self.metric.updateMetrics(self.cloudwatch_conn, updated_info)
- return update_resp
-
- def delete_metric_request(self, delete_info):
- """Compatible API using normalized parameters"""
- del_resp = self.metric.deleteMetrics(self.cloudwatch_conn, delete_info)
- return del_resp
-
- def list_metrics_request(self, list_info):
- """Compatible API using normalized parameters"""
- list_resp = self.metric.listMetrics(self.cloudwatch_conn, list_info)
- return list_resp
-
- def read_metrics_data(self, list_info):
- """Compatible API using normalized parameters
- Read all metric data related to a specified metric"""
- data_resp = self.metric.metricsData(self.cloudwatch_conn, list_info)
- return data_resp
-
- def metric_calls(self, key: str, metric_info: dict, aws_conn: dict):
- """Gets the message from the common consumer"""
-
- try:
- self.cloudwatch_conn = aws_conn['cloudwatch_connection']
- self.ec2_conn = aws_conn['ec2_connection']
-
- metric_response = dict()
-
- log.debug("VIM support : AWS")
-
- if key == "create_metric_request":
- if self.check_resource(metric_info['metric_create_request']['resource_uuid']):
- metric_resp = self.create_metric_request(
- metric_info['metric_create_request']) # alarm_info = message.value
- metric_response['schema_version'] = metric_info['schema_version']
- metric_response['schema_type'] = "create_metric_response"
- metric_response['metric_create_response'] = metric_resp
- log.info("Metric configured: %s", metric_resp)
- return metric_response
-
- elif key == "update_metric_request":
- if self.check_resource(metric_info['metric_create_request']['resource_uuid']):
- update_resp = self.update_metric_request(metric_info['metric_create_request'])
- metric_response['schema_version'] = metric_info['schema_version']
- metric_response['schema_type'] = "update_metric_response"
- metric_response['metric_update_response'] = update_resp
- log.info("Metric Updates: %s", metric_response)
- return metric_response
-
- elif key == "delete_metric_request":
- if self.check_resource(metric_info['resource_uuid']):
- del_resp = self.delete_metric_request(metric_info)
- log.info("Metric Deletion Not supported in AWS : %s", del_resp)
- return del_resp
-
- elif key == "list_metric_request":
- if self.check_resource(metric_info['metrics_list_request']['resource_uuid']):
- list_resp = self.list_metrics_request(metric_info['metrics_list_request'])
- metric_response['schema_version'] = metric_info['schema_version']
- metric_response['schema_type'] = "list_metric_response"
- metric_response['correlation_id'] = metric_info['metrics_list_request']['correlation_id']
- metric_response['vim_type'] = metric_info['vim_type']
- metric_response['metrics_list'] = list_resp
- log.info("Metric List: %s", metric_response)
- return metric_response
-
- elif key == "read_metric_data_request":
- if self.check_resource(metric_info['resource_uuid']):
- data_resp = self.read_metrics_data(metric_info)
- metric_response['schema_version'] = metric_info['schema_version']
- metric_response['schema_type'] = "read_metric_data_response"
- metric_response['metric_name'] = metric_info['metric_name']
- metric_response['metric_uuid'] = metric_info['metric_uuid']
- metric_response['correlation_id'] = metric_info['correlation_uuid']
- metric_response['resource_uuid'] = metric_info['resource_uuid']
- metric_response['tenant_uuid'] = metric_info['tenant_uuid']
- metric_response['metrics_data'] = data_resp
- log.info("Metric Data Response: %s", metric_response)
- return metric_response
-
- else:
- raise UnsupportedOperation("Unknown key, no action will be performed")
-
- except Exception as e:
- log.error("Consumer exception: %s", str(e))
-
- def check_resource(self, resource_uuid):
-
- """Checking the resource_uuid is present in EC2 instances"""
- try:
- check_resp = dict()
- instances = self.ec2_conn.get_all_instance_status()
- status_resource = False
-
- # resource_id
- for instance_id in instances:
- instance_id = str(instance_id).split(':')[1]
- if instance_id == resource_uuid:
- check_resp['resource_uuid'] = resource_uuid
- status_resource = True
- else:
- status_resource = False
-
- # status
- return status_resource
-
- except Exception as e:
- log.error("Error in Plugin Inputs %s", str(e))
+++ /dev/null
-# Copyright 2017 Intel Research and Development Ireland Limited
-# *************************************************************
-
-# This file is part of OSM Monitoring module
-# All Rights Reserved to Intel Corporation
-
-# 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: helena.mcgough@intel.com or adrian.hoban@intel.com
-##
-"""Aodh plugin for OSM MON."""
+++ /dev/null
-# Copyright 2017 Intel Research and Development Ireland Limited
-# *************************************************************
-
-# This file is part of OSM Monitoring module
-# All Rights Reserved to Intel Corporation
-
-# 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: helena.mcgough@intel.com or adrian.hoban@intel.com
-##
-"""Carry out alarming requests via Aodh API."""
-
-import json
-import logging
-from io import UnsupportedOperation
-
-import six
-
-from osm_mon.core.auth import AuthManager
-from osm_mon.core.database import DatabaseManager
-from osm_mon.core.settings import Config
-from osm_mon.plugins.OpenStack.Gnocchi.metric_handler import METRIC_MAPPINGS
-from osm_mon.plugins.OpenStack.common import Common
-from osm_mon.plugins.OpenStack.response import OpenStackResponseBuilder
-
-log = logging.getLogger(__name__)
-
-SEVERITIES = {
- "warning": "low",
- "minor": "low",
- "major": "moderate",
- "critical": "critical",
- "indeterminate": "critical"}
-
-STATISTICS = {
- "average": "mean",
- "minimum": "min",
- "maximum": "max",
- "count": "count",
- "sum": "sum"}
-
-
-class OpenstackAlarmHandler(object):
- """Carries out alarming requests and responses via Aodh API."""
-
- def __init__(self):
- """Create the OpenStack alarming instance."""
- self._database_manager = DatabaseManager()
- self._auth_manager = AuthManager()
- self._cfg = Config.instance()
-
- # Use the Response class to generate valid json response messages
- self._response = OpenStackResponseBuilder()
-
- def handle_message(self, key: str, values: dict, vim_uuid: str):
- """
- Processes alarm request message depending on it's key
- :param key: Kafka message key
- :param values: Dict containing alarm request data. Follows models defined in core.models.
- :param vim_uuid: UUID of the VIM to handle the alarm request.
- :return: Dict containing alarm response data. Follows models defined in core.models.
- """
-
- log.info("OpenStack alarm action required.")
-
- verify_ssl = self._auth_manager.is_verify_ssl(vim_uuid)
-
- auth_token = Common.get_auth_token(vim_uuid, verify_ssl=verify_ssl)
-
- alarm_endpoint = Common.get_endpoint("alarming", vim_uuid, verify_ssl=verify_ssl)
- metric_endpoint = Common.get_endpoint("metric", vim_uuid, verify_ssl=verify_ssl)
-
- vim_account = self._auth_manager.get_credentials(vim_uuid)
- vim_config = json.loads(vim_account.config)
-
- if key == "create_alarm_request":
- alarm_details = values['alarm_create_request']
- alarm_id = None
- status = False
- try:
- metric_name = alarm_details['metric_name'].lower()
- resource_id = alarm_details['resource_uuid']
-
- self.check_for_metric(auth_token, metric_endpoint, metric_name, resource_id, verify_ssl)
-
- alarm_id = self.configure_alarm(
- alarm_endpoint, auth_token, alarm_details, vim_config, verify_ssl)
-
- log.info("Alarm successfully created")
- self._database_manager.save_alarm(alarm_id,
- vim_uuid,
- alarm_details['threshold_value'],
- alarm_details['operation'].lower(),
- alarm_details['metric_name'].lower(),
- alarm_details['vdu_name'].lower(),
- alarm_details['vnf_member_index'],
- alarm_details['ns_id'].lower()
- )
- status = True
- except Exception as e:
- log.exception("Error creating alarm")
- raise e
- finally:
- return self._response.generate_response('create_alarm_response',
- cor_id=alarm_details['correlation_id'],
- status=status,
- alarm_id=alarm_id)
-
- elif key == "list_alarm_request":
- list_details = values['alarm_list_request']
- alarm_list = None
- try:
- alarm_list = self.list_alarms(
- alarm_endpoint, auth_token, list_details, verify_ssl)
- except Exception as e:
- log.exception("Error listing alarms")
- raise e
- finally:
- return self._response.generate_response('list_alarm_response',
- cor_id=list_details['correlation_id'],
- alarm_list=alarm_list)
-
- elif key == "delete_alarm_request":
- request_details = values['alarm_delete_request']
- alarm_id = request_details['alarm_uuid']
- status = False
- try:
- self.delete_alarm(
- alarm_endpoint, auth_token, alarm_id, verify_ssl)
- status = True
- except Exception as e:
- log.exception("Error deleting alarm")
- raise e
- finally:
- return self._response.generate_response('delete_alarm_response',
- cor_id=request_details['correlation_id'],
- status=status,
- alarm_id=alarm_id)
-
- elif key == "acknowledge_alarm_request":
- try:
- alarm_id = values['ack_details']['alarm_uuid']
-
- self.update_alarm_state(
- alarm_endpoint, auth_token, alarm_id, verify_ssl)
-
- log.info("Acknowledged the alarm and cleared it.")
- except Exception as e:
- log.exception("Error acknowledging alarm")
- raise
- finally:
- return None
-
- elif key == "update_alarm_request":
- # Update alarm configurations
- alarm_details = values['alarm_update_request']
- alarm_id = None
- status = False
- try:
- alarm_id = self.update_alarm(
- alarm_endpoint, auth_token, alarm_details, vim_config, verify_ssl)
- status = True
- except Exception as e:
- log.exception("Error updating alarm")
- raise e
- finally:
- return self._response.generate_response('update_alarm_response',
- cor_id=alarm_details['correlation_id'],
- status=status,
- alarm_id=alarm_id)
-
- else:
- raise UnsupportedOperation("Unknown key {}, no action will be performed.".format(key))
-
- def configure_alarm(self, alarm_endpoint, auth_token, values, vim_config, verify_ssl):
- """Create requested alarm in Aodh."""
- url = "{}/v2/alarms/".format(alarm_endpoint)
-
- # Check if the desired alarm is supported
- alarm_name = values['alarm_name'].lower()
- metric_name = values['metric_name'].lower()
- resource_id = values['resource_uuid']
-
- if metric_name not in METRIC_MAPPINGS.keys():
- raise KeyError("Metric {} is not supported.".format(metric_name))
-
- if 'granularity' in vim_config and 'granularity' not in values:
- values['granularity'] = vim_config['granularity']
- payload = self.check_payload(values, metric_name, resource_id,
- alarm_name)
- new_alarm = Common.perform_request(
- url, auth_token, req_type="post", payload=payload, verify_ssl=verify_ssl)
- return json.loads(new_alarm.text)['alarm_id']
-
- def delete_alarm(self, endpoint, auth_token, alarm_id, verify_ssl):
- """Delete alarm function."""
- url = "{}/v2/alarms/%s".format(endpoint) % alarm_id
-
- result = Common.perform_request(
- url, auth_token, req_type="delete", verify_ssl=verify_ssl)
- if str(result.status_code) == "404":
- raise ValueError("Alarm {} doesn't exist".format(alarm_id))
-
- def list_alarms(self, endpoint, auth_token, list_details, verify_ssl):
- """Generate the requested list of alarms."""
- url = "{}/v2/alarms/".format(endpoint)
- a_list, name_list, sev_list, res_list = [], [], [], []
-
- # TODO(mcgoughh): for now resource_id is a mandatory field
- # Check for a resource id
- try:
- resource = list_details['resource_uuid']
- name = list_details['alarm_name'].lower()
- severity = list_details['severity'].lower()
- sev = SEVERITIES[severity]
- except KeyError as e:
- log.warning("Missing parameter for alarm list request: %s", e)
- raise e
-
- # Perform the request to get the desired list
- try:
- result = Common.perform_request(
- url, auth_token, req_type="get", verify_ssl=verify_ssl)
-
- if result is not None:
- # Get list based on resource id
- for alarm in json.loads(result.text):
- rule = alarm['gnocchi_resources_threshold_rule']
- if resource == rule['resource_id']:
- res_list.append(alarm['alarm_id'])
-
- # Generate specified listed if requested
- if name is not None and sev is not None:
- log.info("Return a list of %s alarms with %s severity.",
- name, sev)
- for alarm in json.loads(result.text):
- if name == alarm['name']:
- name_list.append(alarm['alarm_id'])
- for alarm in json.loads(result.text):
- if sev == alarm['severity']:
- sev_list.append(alarm['alarm_id'])
- name_sev_list = list(set(name_list).intersection(sev_list))
- a_list = list(set(name_sev_list).intersection(res_list))
- elif name is not None:
- log.info("Returning a %s list of alarms.", name)
- for alarm in json.loads(result.text):
- if name == alarm['name']:
- name_list.append(alarm['alarm_id'])
- a_list = list(set(name_list).intersection(res_list))
- elif sev is not None:
- log.info("Returning %s severity alarm list.", sev)
- for alarm in json.loads(result.text):
- if sev == alarm['severity']:
- sev_list.append(alarm['alarm_id'])
- a_list = list(set(sev_list).intersection(res_list))
- else:
- log.info("Returning an entire list of alarms.")
- a_list = res_list
- else:
- log.info("There are no alarms!")
- response_list = []
- for alarm in json.loads(result.text):
- if alarm['alarm_id'] in a_list:
- response_list.append(alarm)
- return response_list
-
- except Exception as e:
- log.exception("Failed to generate alarm list: ")
- raise e
-
- def update_alarm_state(self, endpoint, auth_token, alarm_id, verify_ssl):
- """Set the state of an alarm to ok when ack message is received."""
- url = "{}/v2/alarms/%s/state".format(endpoint) % alarm_id
- payload = json.dumps("ok")
-
- result = Common.perform_request(
- url, auth_token, req_type="put", payload=payload, verify_ssl=verify_ssl)
-
- return json.loads(result.text)
-
- def update_alarm(self, endpoint, auth_token, values, vim_config, verify_ssl):
- """Get alarm name for an alarm configuration update."""
- # Get already existing alarm details
- url = "{}/v2/alarms/%s".format(endpoint) % values['alarm_uuid']
-
- # Gets current configurations about the alarm
- result = Common.perform_request(
- url, auth_token, req_type="get")
- alarm_name = json.loads(result.text)['name']
- rule = json.loads(result.text)['gnocchi_resources_threshold_rule']
- alarm_state = json.loads(result.text)['state']
- resource_id = rule['resource_id']
- metric_name = [key for key, value in six.iteritems(METRIC_MAPPINGS) if value == rule['metric']][0]
-
- # Generates and check payload configuration for alarm update
- if 'granularity' in vim_config and 'granularity' not in values:
- values['granularity'] = vim_config['granularity']
- payload = self.check_payload(values, metric_name, resource_id,
- alarm_name, alarm_state=alarm_state)
-
- # Updates the alarm configurations with the valid payload
- update_alarm = Common.perform_request(
- url, auth_token, req_type="put", payload=payload, verify_ssl=verify_ssl)
-
- return json.loads(update_alarm.text)['alarm_id']
-
- def check_payload(self, values, metric_name, resource_id,
- alarm_name, alarm_state=None):
- """Check that the payload is configuration for update/create alarm."""
- cfg = Config.instance()
- # Check state and severity
-
- severity = 'critical'
- if 'severity' in values:
- severity = values['severity'].lower()
-
- if severity == "indeterminate":
- alarm_state = "insufficient data"
- if alarm_state is None:
- alarm_state = "ok"
-
- statistic = values['statistic'].lower()
-
- granularity = cfg.OS_DEFAULT_GRANULARITY
- if 'granularity' in values:
- granularity = values['granularity']
-
- resource_type = 'generic'
- if 'resource_type' in values:
- resource_type = values['resource_type'].lower()
-
- # Try to configure the payload for the update/create request
- # Can only update: threshold, operation, statistic and
- # the severity of the alarm
- rule = {'threshold': values['threshold_value'],
- 'comparison_operator': values['operation'].lower(),
- 'metric': METRIC_MAPPINGS[metric_name],
- 'resource_id': resource_id,
- 'resource_type': resource_type,
- 'aggregation_method': STATISTICS[statistic],
- 'granularity': granularity, }
- payload = json.dumps({'state': alarm_state,
- 'name': alarm_name,
- 'severity': SEVERITIES[severity],
- 'type': 'gnocchi_resources_threshold',
- 'gnocchi_resources_threshold_rule': rule,
- 'alarm_actions': [cfg.OS_NOTIFIER_URI],
- 'repeat_actions': True}, sort_keys=True)
- return payload
-
- def get_alarm_state(self, endpoint, auth_token, alarm_id):
- """Get the state of the alarm."""
- url = "{}/v2/alarms/%s/state".format(endpoint) % alarm_id
-
- alarm_state = Common.perform_request(
- url, auth_token, req_type="get")
- return json.loads(alarm_state.text)
-
- def check_for_metric(self, auth_token, metric_endpoint, metric_name, resource_id, verify_ssl):
- """
- Checks if resource has a specific metric. If not, throws exception.
- :param verify_ssl: Boolean flag to set SSL cert validation
- :param auth_token: OpenStack auth token
- :param metric_endpoint: OpenStack metric endpoint
- :param metric_name: Metric name
- :param resource_id: Resource UUID
- :return: Metric details from resource
- :raise Exception: Could not retrieve metric from resource
- """
- try:
- url = "{}/v1/resource/generic/{}".format(metric_endpoint, resource_id)
- result = Common.perform_request(
- url, auth_token, req_type="get", verify_ssl=verify_ssl)
- resource = json.loads(result.text)
- metrics_dict = resource['metrics']
- return metrics_dict[METRIC_MAPPINGS[metric_name]]
- except Exception as e:
- log.exception("Desired Gnocchi metric not found:", e)
- raise e
+++ /dev/null
-# Copyright 2017 Intel Research and Development Ireland Limited
-# *************************************************************
-
-# This file is part of OSM Monitoring module
-# All Rights Reserved to Intel Corporation
-
-# 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: helena.mcgough@intel.com or adrian.hoban@intel.com
-##
-# __author__ = Helena McGough
-#
-"""A Webserver to send alarm notifications from Aodh to the SO."""
-import json
-import logging
-import os
-import re
-import sys
-import time
-
-from six.moves.BaseHTTPServer import BaseHTTPRequestHandler
-from six.moves.BaseHTTPServer import HTTPServer
-
-# Initialise a logger for alarm notifier
-from osm_mon.core.message_bus.producer import Producer
-from osm_mon.core.settings import Config
-
-cfg = Config.instance()
-
-logging.basicConfig(stream=sys.stdout,
- format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
- datefmt='%m/%d/%Y %I:%M:%S %p',
- level=logging.getLevelName(cfg.OSMMON_LOG_LEVEL))
-log = logging.getLogger(__name__)
-
-kafka_logger = logging.getLogger('kafka')
-kafka_logger.setLevel(logging.getLevelName(cfg.OSMMON_KAFKA_LOG_LEVEL))
-kafka_formatter = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s')
-kafka_handler = logging.StreamHandler(sys.stdout)
-kafka_handler.setFormatter(kafka_formatter)
-kafka_logger.addHandler(kafka_handler)
-
-sys.path.append(os.path.abspath(os.path.join(os.path.realpath(__file__), '..', '..', '..', '..', '..')))
-
-from osm_mon.core.database import DatabaseManager
-
-from osm_mon.plugins.OpenStack.response import OpenStackResponseBuilder
-
-
-class NotifierHandler(BaseHTTPRequestHandler):
- """Handler class for alarm_actions triggered by OSM alarms."""
-
- def _set_headers(self):
- """Set the headers for a request."""
- self.send_response(200)
- self.send_header('Content-type', 'text/html')
- self.end_headers()
-
- def do_GET(self):
- """Get request functionality."""
- self._set_headers()
-
- def do_POST(self):
- """POST request function."""
- # Gets header and data from the post request and records info
- self._set_headers()
- # Gets the size of data
- content_length = int(self.headers['Content-Length'])
- post_data = self.rfile.read(content_length)
- # Python 2/3 string compatibility
- try:
- post_data = post_data.decode()
- except AttributeError:
- pass
- log.info("This alarm was triggered: %s", post_data)
-
- # Send alarm notification to message bus
- try:
- self.notify_alarm(json.loads(post_data))
- except Exception:
- log.exception("Error notifying alarm")
-
- def notify_alarm(self, values):
- """Sends alarm notification message to bus."""
-
- # Initialise configuration and authentication for response message
- response = OpenStackResponseBuilder()
-
- database_manager = DatabaseManager()
-
- alarm_id = values['alarm_id']
- alarm = database_manager.get_alarm(alarm_id, 'openstack')
- # Process an alarm notification if resource_id is valid
- # Get date and time for response message
- a_date = time.strftime("%d-%m-%Y") + " " + time.strftime("%X")
- # Generate and send response
- resp_message = response.generate_response(
- 'notify_alarm',
- alarm_id=alarm_id,
- vdu_name=alarm.vdur_name,
- vnf_member_index=alarm.vnf_member_index,
- ns_id=alarm.nsr_id,
- metric_name=alarm.monitoring_param,
- operation=alarm.operation,
- threshold_value=alarm.threshold,
- sev=values['severity'],
- date=a_date,
- state=values['current'])
- self._publish_response('notify_alarm', json.dumps(resp_message))
- log.info("Sent alarm notification: %s", resp_message)
-
- def _publish_response(self, key: str, msg: str):
- producer = Producer()
- producer.send(topic='alarm_response', key=key, value=msg)
- producer.flush()
-
-
-def run(server_class=HTTPServer, handler_class=NotifierHandler, port=8662):
- """Run the webserver application to retrieve alarm notifications."""
- try:
- server_address = ('', port)
- httpd = server_class(server_address, handler_class)
- log.info("Starting alarm notifier server on port: %s", port)
- httpd.serve_forever()
- except Exception as exc:
- log.warning("Failed to start webserver, %s", exc)
-
-
-if __name__ == "__main__":
- cfg = Config.instance()
- p = re.compile(':(\d+)', re.IGNORECASE)
- m = p.search(cfg.OS_NOTIFIER_URI)
- if m:
- port = m.group(1)
- run(port=int(port))
- else:
- run()
+++ /dev/null
-# Copyright 2017 Intel Research and Development Ireland Limited
-# *************************************************************
-
-# This file is part of OSM Monitoring module
-# All Rights Reserved to Intel Corporation
-
-# 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: helena.mcgough@intel.com or adrian.hoban@intel.com
-##
-"""Gnocchi plugin for OSM MON."""
+++ /dev/null
-# Copyright 2017 Intel Research and Development Ireland Limited
-# *************************************************************
-
-# This file is part of OSM Monitoring module
-# All Rights Reserved to Intel Corporation
-
-# 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: helena.mcgough@intel.com or adrian.hoban@intel.com
-##
-"""Carry out OpenStack metric requests via Gnocchi API."""
-
-import datetime
-import json
-import logging
-import time
-
-import six
-
-from osm_mon.core.auth import AuthManager
-from osm_mon.core.settings import Config
-from osm_mon.plugins.OpenStack.common import Common
-from osm_mon.plugins.OpenStack.response import OpenStackResponseBuilder
-
-log = logging.getLogger(__name__)
-
-METRIC_MAPPINGS = {
- "average_memory_utilization": "memory.usage",
- "disk_read_ops": "disk.read.requests",
- "disk_write_ops": "disk.write.requests",
- "disk_read_bytes": "disk.read.bytes",
- "disk_write_bytes": "disk.write.bytes",
- "packets_dropped": "interface.if_dropped",
- "packets_received": "interface.if_packets",
- "packets_sent": "interface.if_packets",
- "cpu_utilization": "cpu_util",
-}
-
-PERIOD_MS = {
- "HR": 3600000,
- "DAY": 86400000,
- "WEEK": 604800000,
- "MONTH": 2629746000,
- "YEAR": 31556952000
-}
-
-
-class OpenstackMetricHandler(object):
- """OpenStack metric requests performed via the Gnocchi API."""
-
- def __init__(self):
- """Initialize the metric actions."""
- self._cfg = Config.instance()
-
- # Use the Response class to generate valid json response messages
- self._response = OpenStackResponseBuilder()
-
- self._auth_manager = AuthManager()
-
- def handle_request(self, key: str, values: dict, vim_uuid: str) -> dict:
- """
- Processes metric request message depending on it's key
- :param key: Kafka message key
- :param values: Dict containing metric request data. Follows models defined in core.models.
- :param vim_uuid: UUID of the VIM to handle the metric request.
- :return: Dict containing metric response data. Follows models defined in core.models.
- """
-
- log.info("OpenStack metric action required.")
-
- if 'metric_name' in values and values['metric_name'] not in METRIC_MAPPINGS.keys():
- raise ValueError('Metric ' + values['metric_name'] + ' is not supported.')
-
- verify_ssl = self._auth_manager.is_verify_ssl(vim_uuid)
-
- endpoint = Common.get_endpoint("metric", vim_uuid, verify_ssl=verify_ssl)
-
- auth_token = Common.get_auth_token(vim_uuid, verify_ssl=verify_ssl)
-
- if key == "create_metric_request":
- metric_details = values['metric_create_request']
- status = False
- metric_id = None
- resource_id = None
- try:
- # Configure metric
- metric_id, resource_id = self.configure_metric(endpoint, auth_token, metric_details, verify_ssl)
- log.info("Metric successfully created")
- status = True
- except Exception as e:
- log.exception("Error creating metric")
- raise e
- finally:
- return self._response.generate_response('create_metric_response',
- cor_id=metric_details['correlation_id'],
- status=status,
- metric_id=metric_id,
- resource_id=resource_id)
-
- elif key == "read_metric_data_request":
- metric_id = None
- timestamps = []
- metric_data = []
- status = False
- try:
- metric_id = self.get_metric_id(endpoint,
- auth_token,
- METRIC_MAPPINGS[values['metric_name']],
- values['resource_uuid'],
- verify_ssl)
- # Read all metric data related to a specified metric
- timestamps, metric_data = self.read_metric_data(endpoint, auth_token, values, verify_ssl)
- log.info("Metric data collected successfully")
- status = True
- except Exception as e:
- log.exception("Error reading metric data")
- raise e
- finally:
- return self._response.generate_response('read_metric_data_response',
- cor_id=values['correlation_id'],
- status=status,
- metric_id=metric_id,
- metric_name=values['metric_name'],
- resource_id=values['resource_uuid'],
- times=timestamps,
- metrics=metric_data)
-
- elif key == "delete_metric_request":
- metric_id = None
- status = False
- try:
- # delete the specified metric in the request
- metric_id = self.get_metric_id(endpoint, auth_token, METRIC_MAPPINGS[values['metric_name']],
- values['resource_uuid'], verify_ssl)
- self.delete_metric(
- endpoint, auth_token, metric_id, verify_ssl)
- log.info("Metric deleted successfully")
- status = True
-
- except Exception as e:
- log.exception("Error deleting metric")
- raise e
- finally:
- return self._response.generate_response('delete_metric_response',
- cor_id=values['correlation_id'],
- metric_id=metric_id,
- metric_name=values['metric_name'],
- status=status,
- resource_id=values['resource_uuid'])
-
- elif key == "update_metric_request":
- # Gnocchi doesn't support configuration updates
- # Log and send a response back to this effect
- log.warning("Gnocchi doesn't support metric configuration updates.")
- req_details = values['metric_update_request']
- metric_name = req_details['metric_name']
- resource_id = req_details['resource_uuid']
- metric_id = self.get_metric_id(endpoint, auth_token, metric_name, resource_id, verify_ssl)
- return self._response.generate_response('update_metric_response',
- cor_id=req_details['correlation_id'],
- status=False,
- resource_id=resource_id,
- metric_id=metric_id)
-
- elif key == "list_metric_request":
- list_details = values['metrics_list_request']
- metric_list = []
- status = False
- try:
- metric_list = self.list_metrics(
- endpoint, auth_token, list_details, verify_ssl)
- log.info("Metrics listed successfully")
- status = True
- except Exception as e:
- log.exception("Error listing metrics")
- raise e
- finally:
- return self._response.generate_response('list_metric_response',
- cor_id=list_details['correlation_id'],
- status=status,
- metric_list=metric_list)
-
- else:
- raise ValueError("Unknown key {}, no action will be performed.".format(key))
-
- def configure_metric(self, endpoint, auth_token, values, verify_ssl):
- """Create the new metric in Gnocchi."""
- required_fields = ['resource_uuid', 'metric_name']
- for field in required_fields:
- if field not in values:
- raise ValueError("Missing field: " + field)
-
- resource_id = values['resource_uuid']
- metric_name = values['metric_name'].lower()
-
- # Check for an existing metric for this resource
- metric_id = self.get_metric_id(
- endpoint, auth_token, metric_name, resource_id, verify_ssl)
-
- if metric_id is None:
- # Try appending metric to existing resource
- try:
- base_url = "{}/v1/resource/generic/%s/metric"
- res_url = base_url.format(endpoint) % resource_id
- payload = {metric_name: {'archive_policy_name': 'high',
- 'unit': values['metric_unit']}}
- result = Common.perform_request(
- res_url,
- auth_token,
- req_type="post",
- verify_ssl=verify_ssl,
- payload=json.dumps(payload, sort_keys=True))
- # Get id of newly created metric
- for row in json.loads(result.text):
- if row['name'] == metric_name:
- metric_id = row['id']
- log.info("Appended metric to existing resource.")
-
- return metric_id, resource_id
- except Exception as exc:
- # Gnocchi version of resource does not exist creating a new one
- log.info("Failed to append metric to existing resource:%s",
- exc)
- url = "{}/v1/resource/generic".format(endpoint)
- metric = {'name': metric_name,
- 'archive_policy_name': 'high',
- 'unit': values['metric_unit'], }
-
- resource_payload = json.dumps({'id': resource_id,
- 'metrics': {
- metric_name: metric}}, sort_keys=True)
-
- resource = Common.perform_request(
- url,
- auth_token,
- req_type="post",
- payload=resource_payload,
- verify_ssl=verify_ssl)
-
- # Return the newly created resource_id for creating alarms
- new_resource_id = json.loads(resource.text)['id']
- log.info("Created new resource for metric: %s",
- new_resource_id)
-
- metric_id = self.get_metric_id(
- endpoint, auth_token, metric_name, new_resource_id, verify_ssl)
-
- return metric_id, new_resource_id
-
- else:
- raise ValueError("Metric already exists for this resource")
-
- def delete_metric(self, endpoint, auth_token, metric_id, verify_ssl):
- """Delete metric."""
- url = "{}/v1/metric/%s".format(endpoint) % metric_id
-
- result = Common.perform_request(
- url,
- auth_token,
- req_type="delete",
- verify_ssl=verify_ssl)
- if not str(result.status_code).startswith("2"):
- log.warning("Failed to delete the metric.")
- raise ValueError("Error deleting metric. Aodh API responded with code " + str(result.status_code))
-
- def list_metrics(self, endpoint, auth_token, values, verify_ssl):
- """List all metrics."""
-
- # Check for a specified list
- metric_name = None
- if 'metric_name' in values:
- metric_name = values['metric_name'].lower()
-
- resource = None
- if 'resource_uuid' in values:
- resource = values['resource_uuid']
-
- if resource:
- url = "{}/v1/resource/generic/{}".format(endpoint, resource)
- result = Common.perform_request(
- url, auth_token, req_type="get", verify_ssl=verify_ssl)
- resource_data = json.loads(result.text)
- metrics = resource_data['metrics']
-
- if metric_name:
- if metrics.get(METRIC_MAPPINGS[metric_name]):
- metric_id = metrics[METRIC_MAPPINGS[metric_name]]
- url = "{}/v1/metric/{}".format(endpoint, metric_id)
- result = Common.perform_request(
- url, auth_token, req_type="get", verify_ssl=verify_ssl)
- metric_list = json.loads(result.text)
- log.info("Returning an %s resource list for %s metrics",
- metric_name, resource)
- return metric_list
- else:
- log.info("Metric {} not found for {} resource".format(metric_name, resource))
- return []
- else:
- metric_list = []
- for k, v in metrics.items():
- url = "{}/v1/metric/{}".format(endpoint, v)
- result = Common.perform_request(
- url, auth_token, req_type="get", verify_ssl=verify_ssl)
- metric = json.loads(result.text)
- metric_list.append(metric)
- if metric_list:
- log.info("Return a list of %s resource metrics", resource)
- return metric_list
-
- else:
- log.info("There are no metrics available")
- return []
- else:
- url = "{}/v1/metric?sort=name:asc".format(endpoint)
- result = Common.perform_request(
- url, auth_token, req_type="get", verify_ssl=verify_ssl)
- metrics = []
- metrics_partial = json.loads(result.text)
- for metric in metrics_partial:
- metrics.append(metric)
-
- while len(json.loads(result.text)) > 0:
- last_metric_id = metrics_partial[-1]['id']
- url = "{}/v1/metric?sort=name:asc&marker={}".format(endpoint, last_metric_id)
- result = Common.perform_request(
- url, auth_token, req_type="get", verify_ssl=verify_ssl)
- if len(json.loads(result.text)) > 0:
- metrics_partial = json.loads(result.text)
- for metric in metrics_partial:
- metrics.append(metric)
-
- if metrics is not None:
- # Format the list response
- if metric_name is not None:
- metric_list = self.response_list(
- metrics, metric_name=metric_name)
- log.info("Returning a list of %s metrics", metric_name)
- else:
- metric_list = self.response_list(metrics)
- log.info("Returning a complete list of metrics")
- return metric_list
- else:
- log.info("There are no metrics available")
- return []
-
- def get_metric_id(self, endpoint, auth_token, metric_name, resource_id, verify_ssl):
- """Check if the desired metric already exists for the resource."""
- url = "{}/v1/resource/generic/%s".format(endpoint) % resource_id
- try:
- # Try return the metric id if it exists
- result = Common.perform_request(
- url,
- auth_token,
- req_type="get",
- verify_ssl=verify_ssl)
- return json.loads(result.text)['metrics'][metric_name]
- except KeyError as e:
- log.error("Metric doesn't exist. No metric_id available")
- raise e
-
- def read_metric_data(self, endpoint, auth_token, values, verify_ssl):
- """Collect metric measures over a specified time period."""
- timestamps = []
- data = []
- # get metric_id
- metric_id = self.get_metric_id(endpoint, auth_token, METRIC_MAPPINGS[values['metric_name']],
- values['resource_uuid'], verify_ssl)
- # Try and collect measures
- collection_unit = values['collection_unit'].upper()
- collection_period = values['collection_period']
-
- # Define the start and end time based on configurations
- # FIXME: Local timezone may differ from timezone set in Gnocchi, causing discrepancies in measures
- stop_time = time.strftime("%Y-%m-%d") + "T" + time.strftime("%X")
- end_time = int(round(time.time() * 1000))
- diff = collection_period * PERIOD_MS[collection_unit]
- s_time = (end_time - diff) / 1000.0
- start_time = datetime.datetime.fromtimestamp(s_time).strftime(
- '%Y-%m-%dT%H:%M:%S.%f')
- base_url = "{}/v1/metric/%(0)s/measures?start=%(1)s&stop=%(2)s"
- url = base_url.format(endpoint) % {
- "0": metric_id, "1": start_time, "2": stop_time}
-
- # Perform metric data request
- metric_data = Common.perform_request(
- url,
- auth_token,
- req_type="get",
- verify_ssl=verify_ssl)
-
- # Generate a list of the requested timestamps and data
- for r in json.loads(metric_data.text):
- timestamp = r[0].replace("T", " ")
- timestamps.append(timestamp)
- data.append(r[2])
-
- return timestamps, data
-
- def response_list(self, metric_list, metric_name=None, resource=None):
- """Create the appropriate lists for a list response."""
- resp_list, name_list, res_list = [], [], []
-
- # Create required lists
- for row in metric_list:
- # Only list OSM metrics
- name = None
- if row['name'] in METRIC_MAPPINGS.values():
- for k, v in six.iteritems(METRIC_MAPPINGS):
- if row['name'] == v:
- name = k
- metric = {"metric_name": name,
- "metric_uuid": row['id'],
- "metric_unit": row['unit'],
- "resource_uuid": row['resource_id']}
- resp_list.append(metric)
- # Generate metric_name specific list
- if metric_name is not None and name is not None:
- if metric_name in METRIC_MAPPINGS.keys() and row['name'] == METRIC_MAPPINGS[metric_name]:
- metric = {"metric_name": metric_name,
- "metric_uuid": row['id'],
- "metric_unit": row['unit'],
- "resource_uuid": row['resource_id']}
- name_list.append(metric)
- # Generate resource specific list
- if resource is not None and name is not None:
- if row['resource_id'] == resource:
- metric = {"metric_name": name,
- "metric_uuid": row['id'],
- "metric_unit": row['unit'],
- "resource_uuid": row['resource_id']}
- res_list.append(metric)
-
- # Join required lists
- if metric_name is not None and resource is not None:
- # Return intersection of res_list and name_list
- return [i for i in res_list for j in name_list if i['metric_uuid'] == j['metric_uuid']]
- elif metric_name is not None:
- return name_list
- elif resource is not None:
- return res_list
- else:
- return resp_list
+++ /dev/null
-# Copyright 2017 Intel Research and Development Ireland Limited
-# *************************************************************
-
-# This file is part of OSM Monitoring module
-# All Rights Reserved to Intel Corporation
-
-# 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: helena.mcgough@intel.com or adrian.hoban@intel.com
-##
-"""OpenStack plugin for OSM MON."""
+++ /dev/null
-# Copyright 2017 Intel Research and Development Ireland Limited
-# *************************************************************
-
-# This file is part of OSM Monitoring module
-# All Rights Reserved to Intel Corporation
-
-# 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: helena.mcgough@intel.com or adrian.hoban@intel.com
-##
-"""Common methods for the OpenStack plugins."""
-import json
-import logging
-
-import requests
-import yaml
-from keystoneauth1 import session
-from keystoneauth1.identity import v3
-from keystoneclient.v3 import client
-
-from osm_mon.core.auth import AuthManager
-from osm_mon.core.settings import Config
-
-__author__ = "Helena McGough"
-
-log = logging.getLogger(__name__)
-cfg = Config.instance()
-
-
-class Common(object):
- """Common calls for Gnocchi/Aodh plugins."""
-
- def __init__(self):
- """Create the common instance."""
-
- @staticmethod
- def get_auth_token(vim_uuid, verify_ssl=True):
- """Authenticate and/or renew the authentication token."""
- auth_manager = AuthManager()
- creds = auth_manager.get_credentials(vim_uuid)
- sess = session.Session(verify=verify_ssl)
- ks = client.Client(session=sess)
- token_dict = ks.get_raw_token_from_identity_service(auth_url=creds.url,
- username=creds.user,
- password=creds.password,
- project_name=creds.tenant_name,
- project_domain_id='default',
- user_domain_id='default')
- return token_dict['auth_token']
-
- @staticmethod
- def get_endpoint(service_type, vim_uuid, verify_ssl=True):
- """
- Gets the public endpoint for an OpenStack service in the configured region (default: RegionOne).
- :param service_type: Service type name (eg. metric or alarming)
- :param vim_uuid: VIM UUID generated by OSM
- :param verify_ssl: If False, disables SSL validation. Useful when using self signed certs.
- :return: Endpoint url string.
-
- :raises ValueError If it can't find services, or if it can find services but no endpoint for specified region.
- """
- auth_manager = AuthManager()
- creds = auth_manager.get_credentials(vim_uuid)
- auth = v3.Password(auth_url=creds.url,
- username=creds.user,
- password=creds.password,
- project_name=creds.tenant_name,
- project_domain_id='default',
- user_domain_id='default')
- sess = session.Session(auth=auth, verify=verify_ssl)
- ks = client.Client(session=sess, interface='public')
- services = ks.services.list(type=service_type)
- if not services:
- raise ValueError("No services found for {}. Is the corresponding service enabled?".format(service_type))
- service = services[0]
- endpoints = ks.endpoints.list(service)
- endpoint_type = 'publicURL'
- region_name = 'RegionOne'
- if creds.config is not None:
- try:
- config = json.loads(creds.config)
- except ValueError:
- config = yaml.safe_load(creds.config)
- if 'endpoint_type' in config:
- endpoint_type = config['endpoint_type']
- if 'region_name' in config:
- region_name = config['region_name']
- for endpoint in endpoints:
- if endpoint.interface in endpoint_type and endpoint.region == region_name:
- return endpoint.url
- raise ValueError("No endpoints found for service {} in region {}".format(service_type, region_name))
-
- @staticmethod
- def perform_request(url, auth_token,
- req_type=None, payload=None, params=None, verify_ssl=True):
- """Perform the POST/PUT/GET/DELETE request."""
-
- timeout = cfg.REQUEST_TIMEOUT
-
- # request headers
- headers = {'X-Auth-Token': auth_token,
- 'Content-type': 'application/json'}
- # perform request and return its result
- if req_type == "put":
- response = requests.put(
- url, data=payload, headers=headers,
- timeout=timeout, verify=verify_ssl)
- elif req_type == "get":
- response = requests.get(
- url, params=params, headers=headers, timeout=timeout, verify=verify_ssl)
- elif req_type == "delete":
- response = requests.delete(
- url, headers=headers, timeout=timeout, verify=verify_ssl)
- else:
- response = requests.post(
- url, data=payload, headers=headers,
- timeout=timeout, verify=verify_ssl)
-
- # Raises exception if there was an error
- try:
- response.raise_for_status()
- # pylint: disable=broad-except
- except Exception:
- # Log out the result of the request
- log.warning(
- 'Result: %s, %s',
- response.status_code, response.text)
- return response
+++ /dev/null
-# Copyright 2017 Intel Research and Development Ireland Limited
-# *************************************************************
-
-# This file is part of OSM Monitoring module
-# All Rights Reserved to Intel Corporation
-
-# 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: helena.mcgough@intel.com or adrian.hoban@intel.com
-##
-"""Generate valid responses to send back to the SO."""
-
-import logging
-
-log = logging.getLogger(__name__)
-
-schema_version = "1.0"
-
-
-class OpenStackResponseBuilder(object):
- """Generates responses for OpenStack plugin."""
-
- def __init__(self):
- """Initialize OpenStack Response instance."""
-
- def generate_response(self, key, **kwargs) -> dict:
- """Make call to appropriate response function."""
- if key == "list_alarm_response":
- message = self.alarm_list_response(**kwargs)
- elif key == "create_alarm_response":
- message = self.create_alarm_response(**kwargs)
- elif key == "delete_alarm_response":
- message = self.delete_alarm_response(**kwargs)
- elif key == "update_alarm_response":
- message = self.update_alarm_response(**kwargs)
- elif key == "create_metric_response":
- message = self.metric_create_response(**kwargs)
- elif key == "read_metric_data_response":
- message = self.read_metric_data_response(**kwargs)
- elif key == "delete_metric_response":
- message = self.delete_metric_response(**kwargs)
- elif key == "update_metric_response":
- message = self.update_metric_response(**kwargs)
- elif key == "list_metric_response":
- message = self.list_metric_response(**kwargs)
- elif key == "notify_alarm":
- message = self.notify_alarm(**kwargs)
- else:
- log.warning("Failed to generate a valid response message.")
- message = None
-
- return message
-
- def alarm_list_response(self, **kwargs) -> dict:
- """Generate the response for an alarm list request."""
- alarm_list_resp = {"schema_version": schema_version,
- "schema_type": "list_alarm_response",
- "correlation_id": kwargs['cor_id'],
- "list_alarm_response": kwargs['alarm_list']}
- return alarm_list_resp
-
- def create_alarm_response(self, **kwargs) -> dict:
- """Generate a response for a create alarm request."""
- create_alarm_resp = {"schema_version": schema_version,
- "schema_type": "create_alarm_response",
- "alarm_create_response": {
- "correlation_id": kwargs['cor_id'],
- "alarm_uuid": kwargs['alarm_id'],
- "status": kwargs['status']}}
- return create_alarm_resp
-
- def delete_alarm_response(self, **kwargs) -> dict:
- """Generate a response for a delete alarm request."""
- delete_alarm_resp = {"schema_version": schema_version,
- "schema_type": "alarm_deletion_response",
- "alarm_deletion_response": {
- "correlation_id": kwargs['cor_id'],
- "alarm_uuid": kwargs['alarm_id'],
- "status": kwargs['status']}}
- return delete_alarm_resp
-
- def update_alarm_response(self, **kwargs) -> dict:
- """Generate a response for an update alarm request."""
- update_alarm_resp = {"schema_version": schema_version,
- "schema_type": "update_alarm_response",
- "alarm_update_response": {
- "correlation_id": kwargs['cor_id'],
- "alarm_uuid": kwargs['alarm_id'],
- "status": kwargs['status']}}
- return update_alarm_resp
-
- def metric_create_response(self, **kwargs) -> dict:
- """Generate a response for a create metric request."""
- create_metric_resp = {"schema_version": schema_version,
- "schema_type": "create_metric_response",
- "correlation_id": kwargs['cor_id'],
- "metric_create_response": {
- "metric_uuid": kwargs['metric_id'],
- "resource_uuid": kwargs['resource_id'],
- "status": kwargs['status']}}
- return create_metric_resp
-
- def read_metric_data_response(self, **kwargs) -> dict:
- """Generate a response for a read metric data request."""
- read_metric_data_resp = {"schema_version": schema_version,
- "schema_type": "read_metric_data_response",
- "metric_name": kwargs['metric_name'],
- "metric_uuid": kwargs['metric_id'],
- "resource_uuid": kwargs['resource_id'],
- "correlation_id": kwargs['cor_id'],
- "status": kwargs['status'],
- "metrics_data": {
- "time_series": kwargs['times'],
- "metrics_series": kwargs['metrics']}}
- return read_metric_data_resp
-
- def delete_metric_response(self, **kwargs) -> dict:
- """Generate a response for a delete metric request."""
- delete_metric_resp = {"schema_version": schema_version,
- "schema_type": "delete_metric_response",
- "metric_name": kwargs['metric_name'],
- "metric_uuid": kwargs['metric_id'],
- "resource_uuid": kwargs['resource_id'],
- "correlation_id": kwargs['cor_id'],
- "status": kwargs['status']}
- return delete_metric_resp
-
- def update_metric_response(self, **kwargs) -> dict:
- """Generate a repsonse for an update metric request."""
- update_metric_resp = {"schema_version": schema_version,
- "schema_type": "update_metric_response",
- "correlation_id": kwargs['cor_id'],
- "metric_update_response": {
- "metric_uuid": kwargs['metric_id'],
- "status": kwargs['status'],
- "resource_uuid": kwargs['resource_id']}}
- return update_metric_resp
-
- def list_metric_response(self, **kwargs) -> dict:
- """Generate a response for a list metric request."""
- list_metric_resp = {"schema_version": schema_version,
- "schema_type": "list_metric_response",
- "correlation_id": kwargs['cor_id'],
- "status": kwargs['status'],
- "metrics_list": kwargs['metric_list']}
- return list_metric_resp
-
- def notify_alarm(self, **kwargs) -> dict:
- """Generate a response to send alarm notifications."""
- notify_alarm_resp = {"schema_version": schema_version,
- "schema_type": "notify_alarm",
- "notify_details": {
- "alarm_uuid": kwargs['alarm_id'],
- "vdu_name": kwargs['vdu_name'],
- "vnf_member_index": kwargs['vnf_member_index'],
- "ns_id": kwargs['ns_id'],
- "metric_name": kwargs['metric_name'],
- "threshold_value": kwargs['threshold_value'],
- "operation": kwargs['operation'],
- "severity": kwargs['sev'],
- "status": kwargs['state'],
- "start_date": kwargs['date']}}
- return notify_alarm_resp
+++ /dev/null
-# Copyright 2017 Intel Research and Development Ireland Limited
-# *************************************************************
-
-# This file is part of OSM Monitoring module
-# All Rights Reserved to Intel Corporation
-
-# 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: helena.mcgough@intel.com or adrian.hoban@intel.com
-##
-"""Simple singleton class."""
-
-from __future__ import unicode_literals
-
-
-class Singleton(object):
- """Simple singleton class."""
-
- def __init__(self, decorated):
- """Initialize singleton instance."""
- self._decorated = decorated
-
- def instance(self):
- """Return singleton instance."""
- try:
- return self._instance
- except AttributeError:
- self._instance = self._decorated()
- return self._instance
+++ /dev/null
-# -*- coding: utf-8 -*-
-
-# Copyright 2017 Intel Research and Development Ireland Limited
-# *************************************************************
-
-# This file is part of OSM Monitoring module
-# All Rights Reserved to Intel Corporation
-
-# 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: helena.mcgough@intel.com or adrian.hoban@intel.com
-##
-"""Plugins for OSM MON."""
+++ /dev/null
-# -*- coding: utf-8 -*-
-
-##
-# Copyright 2016-2017 VMware Inc.
-# This file is part of ETSI OSM
-# All Rights Reserved.
-#
-# 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: osslegalrouting@vmware.com
-##
-
-"""
-Monitoring metrics & creating Alarm definitions in vROPs
-"""
-import logging
-
-import pytz
-import requests
-import six
-from pyvcloud.vcd.client import BasicLoginCredentials
-from pyvcloud.vcd.client import Client
-
-from xml.etree import ElementTree as XmlElementTree
-import traceback
-import time
-import json
-from OpenSSL.crypto import load_certificate, FILETYPE_PEM
-import os
-import sys
-import datetime
-from socket import getfqdn
-
-import urllib3
-
-from osm_mon.core.settings import Config
-
-sys.path.append(os.path.join(os.path.dirname(os.path.abspath(__file__)), '..', '..', '..'))
-from osm_mon.core.database import DatabaseManager
-
-API_VERSION = '5.9'
-
-urllib3.disable_warnings(urllib3.exceptions.InsecureRequestWarning)
-OPERATION_MAPPING = {'GE': 'GT_EQ', 'LE': 'LT_EQ', 'GT': 'GT', 'LT': 'LT', 'EQ': 'EQ'}
-severity_mano2vrops = {'WARNING': 'WARNING', 'MINOR': 'WARNING', 'MAJOR': "IMMEDIATE",
- 'CRITICAL': 'CRITICAL', 'INDETERMINATE': 'UNKNOWN'}
-PERIOD_MSEC = {'HR': 3600000, 'DAY': 86400000, 'WEEK': 604800000, 'MONTH': 2678400000, 'YEAR': 31536000000}
-
-# To Do - Add actual webhook url & certificate
-# SSL_CERTIFICATE_FILE_NAME = 'vROPs_Webservice/SSL_certificate/www.vrops_webservice.com.cert'
-# webhook_url = "https://mano-dev-1:8080/notify/" #for testing
-webhook_url = "https://" + getfqdn() + ":8080/notify/"
-SSL_CERTIFICATE_FILE_NAME = ('vROPs_Webservice/SSL_certificate/' + getfqdn() + ".cert")
-# SSL_CERTIFICATE_FILE_NAME = 'vROPs_Webservice/SSL_certificate/10.172.137.214.cert' #for testing
-
-MODULE_DIR = os.path.dirname(__file__)
-CONFIG_FILE_NAME = 'vrops_config.xml'
-CONFIG_FILE_PATH = os.path.join(MODULE_DIR, CONFIG_FILE_NAME)
-SSL_CERTIFICATE_FILE_PATH = os.path.join(MODULE_DIR, SSL_CERTIFICATE_FILE_NAME)
-
-cfg = Config.instance()
-logging.basicConfig(stream=sys.stdout,
- format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
- datefmt='%m/%d/%Y %I:%M:%S %p',
- level=logging.getLevelName(cfg.OSMMON_LOG_LEVEL))
-
-logger = logging.getLogger(__name__)
-
-
-class MonPlugin:
- """MON Plugin class for vROPs telemetry plugin
- """
-
- def __init__(self, access_config=None):
- """Constructor of MON plugin
- Params:
- 'access_config': dictionary with VIM access information based on VIM type.
- This contains a consolidate version of VIM & monitoring tool config at creation and
- particular VIM config at their attachment.
- For VIM type: 'vmware',
- access_config - {'vrops_site':<>, 'vrops_user':<>, 'vrops_password':<>,
- 'vcloud-site':<>,'admin_username':<>,'admin_password':<>,
- 'nsx_manager':<>,'nsx_user':<>,'nsx_password':<>,
- 'vcenter_ip':<>,'vcenter_port':<>,'vcenter_user':<>,'vcenter_password':<>,
- 'vim_tenant_name':<>,'orgname':<>}
-
- #To Do
- Returns: Raise an exception if some needed parameter is missing, but it must not do any connectivity
- check against the VIM
- """
-
- if access_config is None:
- logger.error("VIM Access Configuration not provided")
- raise KeyError("VIM Access Configuration not provided")
-
- self.database_manager = DatabaseManager()
-
- self.access_config = access_config
- if not bool(access_config):
- logger.error("VIM Account details are not added. Please add a VIM account")
- raise KeyError("VIM Account details are not added. Please add a VIM account")
-
- try:
- self.vrops_site = access_config['vrops_site']
- self.vrops_user = access_config['vrops_user']
- self.vrops_password = access_config['vrops_password']
- self.vcloud_site = access_config['vim_url']
- self.admin_username = access_config['admin_username']
- self.admin_password = access_config['admin_password']
- # self.tenant_id = access_config['tenant_id']
- self.vim_uuid = access_config['vim_uuid']
-
- except KeyError as exp:
- logger.error("Required VIM account details not provided: {}".format(exp))
- raise KeyError("Required VIM account details not provided: {}".format(exp))
-
- def configure_alarm(self, config_dict={}):
- """Configures or creates a new alarm using the input parameters in config_dict
- Params:
- "alarm_name": Alarm name in string format
- "description": Description of alarm in string format
- "resource_uuid": Resource UUID for which alarm needs to be configured. in string format
- "Resource type": String resource type: 'VDU' or 'host'
- "Severity": 'WARNING', 'MINOR', 'MAJOR', 'CRITICAL'
- "metric_name": Metric key in string format
- "operation": One of ('GE', 'LE', 'GT', 'LT', 'EQ')
- "threshold_value": Defines the threshold (up to 2 fraction digits) that,
- if crossed, will trigger the alarm.
- "statistic": AVERAGE, MINIMUM, MAXIMUM, COUNT, SUM
-
- Default parameters for each alarm are read from the plugin specific config file.
- Dict of default parameters is as follows:
- default_params keys = {'cancel_cycles','wait_cycles','resource_kind','adapter_kind',
- 'alarm_type','alarm_subType',impact}
-
- Returns the UUID of created alarm or None
- """
- # 1) get alarm & metrics parameters from plugin specific file
- def_a_params = self.get_default_Params(config_dict['alarm_name'])
- if not def_a_params:
- logger.warning("Alarm not supported: {}".format(config_dict['alarm_name']))
- return None
- metric_key_params = self.get_default_Params(config_dict['metric_name'])
- if not metric_key_params:
- logger.warning("Metric not supported: {}".format(config_dict['metric_name']))
- return None
-
- # 1.2) Check if alarm definition already exists
- vrops_alarm_name = def_a_params['vrops_alarm'] + '-' + config_dict['resource_uuid']
- alert_def_list = self.get_alarm_defination_by_name(vrops_alarm_name)
- if alert_def_list:
- logger.warning("Alarm already exists: {}. Try updating by update_alarm_request"
- .format(vrops_alarm_name))
- return None
-
- # 2) create symptom definition
- symptom_params = {'cancel_cycles': (def_a_params['cancel_period'] / 300) * def_a_params['cancel_cycles'],
- 'wait_cycles': (def_a_params['period'] / 300) * def_a_params['evaluation'],
- 'resource_kind_key': def_a_params['resource_kind'],
- 'adapter_kind_key': def_a_params['adapter_kind'],
- 'symptom_name': vrops_alarm_name,
- 'severity': severity_mano2vrops[config_dict['severity'].upper()],
- 'metric_key': metric_key_params['metric_key'],
- 'operation': OPERATION_MAPPING[config_dict['operation']],
- 'threshold_value': config_dict['threshold_value']}
-
- symptom_uuid = self.create_symptom(symptom_params)
- if symptom_uuid is not None:
- logger.info("Symptom defined: {} with ID: {}".format(symptom_params['symptom_name'], symptom_uuid))
- else:
- logger.warning("Failed to create Symptom: {}".format(symptom_params['symptom_name']))
- return None
- # 3) create alert definition
- # To Do - Get type & subtypes for all 5 alarms
- alarm_params = {'name': vrops_alarm_name,
- 'description': config_dict['description']
- if 'description' in config_dict and config_dict['description'] is not None else config_dict[
- 'alarm_name'],
- 'adapterKindKey': def_a_params['adapter_kind'],
- 'resourceKindKey': def_a_params['resource_kind'],
- 'waitCycles': 1, 'cancelCycles': 1,
- 'type': def_a_params['alarm_type'], 'subType': def_a_params['alarm_subType'],
- 'severity': severity_mano2vrops[config_dict['severity'].upper()],
- 'symptomDefinitionId': symptom_uuid,
- 'impact': def_a_params['impact']}
-
- alarm_def = self.create_alarm_definition(alarm_params)
- if alarm_def is None:
- logger.warning("Failed to create Alert: {}".format(alarm_params['name']))
- return None
-
- logger.info("Alarm defined: {} with ID: {}".format(alarm_params['name'], alarm_def))
-
- # 4) Find vm_moref_id from vApp uuid in vCD
- vm_moref_id = self.get_vm_moref_id(config_dict['resource_uuid'])
- if vm_moref_id is None:
- logger.warning("Failed to find vm morefid for vApp in vCD: {}".format(config_dict['resource_uuid']))
- return None
-
- # 5) Based on vm_moref_id, find VM's corresponding resource_id in vROPs to set notification
- resource_id = self.get_vm_resource_id(vm_moref_id)
- if resource_id is None:
- logger.warning("Failed to find resource in vROPs: {}".format(config_dict['resource_uuid']))
- return None
-
- # 6) Configure alarm notification for a particular VM using it's resource_id
- notification_id = self.create_alarm_notification_rule(vrops_alarm_name, alarm_def, resource_id)
- if notification_id is None:
- return None
- else:
- alarm_def_uuid = alarm_def.split('-', 1)[1]
- logger.info("Alarm definition created with notification: {} with ID: {}"
- .format(alarm_params['name'], alarm_def_uuid))
- self.database_manager.save_alarm(alarm_params['name'],
- self.vim_uuid,
- config_dict['threshold_value'],
- config_dict['operation'],
- config_dict['metric_name'].lower(),
- config_dict['vdu_name'].lower(),
- config_dict['vnf_member_index'].lower(),
- config_dict['ns_id'].lower()
- )
-
- # Return alarm definition UUID by removing 'AlertDefinition' from UUID
- return (alarm_def_uuid)
-
- def get_default_Params(self, metric_alarm_name):
- """
- Read the default config parameters from plugin specific file stored with plugin file.
- Params:
- metric_alarm_name: Name of the alarm, whose config parameters to be read from the config file.
- """
- a_params = {}
- try:
- source = open(CONFIG_FILE_PATH, 'r')
- except IOError as exp:
- msg = ("Could not read Config file: {}, nException: {}"
- .format(CONFIG_FILE_PATH, exp))
- logger.error(msg)
- raise IOError(msg)
-
- tree = XmlElementTree.parse(source)
- alarms = tree.getroot()
- for alarm in alarms:
- if alarm.tag.lower() == metric_alarm_name.lower():
- for param in alarm:
- if param.tag in ("period", "evaluation", "cancel_period", "alarm_type",
- "cancel_cycles", "alarm_subType"):
- a_params[param.tag] = int(param.text)
- elif param.tag in ("enabled", "repeat"):
- if param.text.lower() == "true":
- a_params[param.tag] = True
- else:
- a_params[param.tag] = False
- else:
- a_params[param.tag] = param.text
- source.close()
- return a_params
-
- def create_symptom(self, symptom_params):
- """Create Symptom definition for an alarm
- Params:
- symptom_params: Dict of parameters required for defining a symptom as follows
- cancel_cycles
- wait_cycles
- resource_kind_key = "VirtualMachine"
- adapter_kind_key = "VMWARE"
- symptom_name = Test_Memory_Usage_TooHigh
- severity
- metric_key
- operation = GT_EQ
- threshold_value = 85
- Returns the uuid of Symptom definition
- """
- symptom_id = None
-
- try:
- api_url = '/suite-api/api/symptomdefinitions'
- headers = {'Content-Type': 'application/json', 'Accept': 'application/json'}
- data = {
- "id": None,
- "name": symptom_params['symptom_name'],
- "adapterKindKey": symptom_params['adapter_kind_key'],
- "resourceKindKey": symptom_params['resource_kind_key'],
- "waitCycles": symptom_params['wait_cycles'],
- "cancelCycles": symptom_params['cancel_cycles'],
- "state": {
- "severity": symptom_params['severity'],
- "condition": {
- "type": "CONDITION_HT",
- "key": symptom_params['metric_key'],
- "operator": symptom_params['operation'],
- "value": symptom_params['threshold_value'],
- "valueType": "NUMERIC",
- "instanced": False,
- "thresholdType": "STATIC"
- }
- }
- }
-
- resp = requests.post(self.vrops_site + api_url,
- auth=(self.vrops_user, self.vrops_password),
- headers=headers,
- verify=False,
- data=json.dumps(data))
-
- if resp.status_code != 201:
- logger.warning("Failed to create Symptom definition: {}, response {}"
- .format(symptom_params['symptom_name'], resp.content))
- return None
-
- resp_data = json.loads(resp.content)
- if resp_data.get('id') is not None:
- symptom_id = resp_data['id']
-
- return symptom_id
-
- except Exception as exp:
- logger.warning("Error creating symptom definition : {} n{}"
- .format(exp, traceback.format_exc()))
-
- def create_alarm_definition(self, alarm_params):
- """
- Create an alarm definition in vROPs
- Params:
- 'name': Alarm Name,
- 'description':Alarm description,
- 'adapterKindKey': Adapter type in vROPs "VMWARE",
- 'resourceKindKey':Resource type in vROPs "VirtualMachine",
- 'waitCycles': No of wait cycles,
- 'cancelCycles': No of cancel cycles,
- 'type': Alarm type,
- 'subType': Alarm subtype,
- 'severity': Severity in vROPs "CRITICAL",
- 'symptomDefinitionId':symptom Definition uuid,
- 'impact': impact 'risk'
- Returns:
- 'alarm_uuid': returns alarm uuid
- """
-
- alarm_uuid = None
-
- try:
- api_url = '/suite-api/api/alertdefinitions'
- headers = {'Content-Type': 'application/json', 'Accept': 'application/json'}
- data = {
- "name": alarm_params['name'],
- "description": alarm_params['description'],
- "adapterKindKey": alarm_params['adapterKindKey'],
- "resourceKindKey": alarm_params['resourceKindKey'],
- "waitCycles": 1,
- "cancelCycles": 1,
- "type": alarm_params['type'],
- "subType": alarm_params['subType'],
- "states": [
- {
- "severity": alarm_params['severity'],
- "base-symptom-set":
- {
- "type": "SYMPTOM_SET",
- "relation": "SELF",
- "aggregation": "ALL",
- "symptomSetOperator": "AND",
- "symptomDefinitionIds": [alarm_params['symptomDefinitionId']]
- },
- "impact": {
- "impactType": "BADGE",
- "detail": alarm_params['impact']
- }
- }
- ]
- }
-
- resp = requests.post(self.vrops_site + api_url,
- auth=(self.vrops_user, self.vrops_password),
- headers=headers,
- verify=False,
- data=json.dumps(data))
-
- if resp.status_code != 201:
- logger.warning("Failed to create Alarm definition: {}, response {}"
- .format(alarm_params['name'], resp.content))
- return None
-
- resp_data = json.loads(resp.content)
- if resp_data.get('id') is not None:
- alarm_uuid = resp_data['id']
-
- return alarm_uuid
-
- except Exception as exp:
- logger.warning("Error creating alarm definition : {} n{}".format(exp, traceback.format_exc()))
-
- def configure_rest_plugin(self):
- """
- Creates REST Plug-in for vROPs outbound alerts
-
- Returns Plugin ID
- """
- plugin_id = None
- plugin_name = 'MON_module_REST_Plugin'
- plugin_id = self.check_if_plugin_configured(plugin_name)
-
- # If REST plugin not configured, configure it
- if plugin_id is not None:
- return plugin_id
- else:
- try:
- cert_file_string = open(SSL_CERTIFICATE_FILE_PATH, "rb").read()
- except IOError as exp:
- msg = ("Could not read SSL certificate file: {}".format(SSL_CERTIFICATE_FILE_PATH))
- logger.error(msg)
- raise IOError(msg)
- cert = load_certificate(FILETYPE_PEM, cert_file_string)
- certificate = cert.digest("sha1")
- api_url = '/suite-api/api/alertplugins'
- headers = {'Content-Type': 'application/json', 'Accept': 'application/json'}
- data = {
- "pluginTypeId": "RestPlugin",
- "name": plugin_name,
- "configValues": [
- {
- "name": "Url",
- "value": webhook_url
- },
- {
- "name": "Content-type",
- "value": "application/json"
- },
- {
- "name": "Certificate",
- "value": certificate
- },
- {
- "name": "ConnectionCount",
- "value": "20"
- }
- ]
- }
-
- resp = requests.post(self.vrops_site + api_url,
- auth=(self.vrops_user, self.vrops_password),
- headers=headers,
- verify=False,
- data=json.dumps(data))
-
- if resp.status_code is not 201:
- logger.warning("Failed to create REST Plugin: {} for url: {}, nresponse code: {},"
- " nresponse content: {}".format(plugin_name, webhook_url,
- resp.status_code, resp.content))
- return None
-
- resp_data = json.loads(resp.content)
- if resp_data.get('pluginId') is not None:
- plugin_id = resp_data['pluginId']
-
- if plugin_id is None:
- logger.warning("Failed to get REST Plugin ID for {}, url: {}".format(plugin_name, webhook_url))
- return None
- else:
- logger.info(
- "Created REST Plugin: {} with ID : {} for url: {}".format(plugin_name, plugin_id, webhook_url))
- status = self.enable_rest_plugin(plugin_id, plugin_name)
- if status is False:
- logger.warning(
- "Failed to enable created REST Plugin: {} for url: {}".format(plugin_name, webhook_url))
- return None
- else:
- logger.info("Enabled REST Plugin: {} for url: {}".format(plugin_name, webhook_url))
- return plugin_id
-
- def check_if_plugin_configured(self, plugin_name):
- """Check if the REST plugin is already created
- Returns: plugin_id: if already created, None: if needs to be created
- """
- plugin_id = None
- # Find the REST Plugin id details for - MON_module_REST_Plugin
- api_url = '/suite-api/api/alertplugins'
- headers = {'Accept': 'application/json'}
-
- resp = requests.get(self.vrops_site + api_url,
- auth=(self.vrops_user, self.vrops_password),
- verify=False, headers=headers)
-
- if resp.status_code is not 200:
- logger.warning("Failed to REST GET Alarm plugin details nResponse code: {} nResponse content: {}"
- .format(resp.status_code, resp.content))
- return None
-
- # Look for specific plugin & parse pluginId for 'MON_module_REST_Plugin'
- plugins_list = json.loads(resp.content)
- if plugins_list.get('notificationPluginInstances') is not None:
- for notify_plugin in plugins_list['notificationPluginInstances']:
- if notify_plugin.get('name') is not None and notify_plugin['name'] == plugin_name:
- plugin_id = notify_plugin.get('pluginId')
-
- if plugin_id is None:
- logger.warning("REST plugin {} not found".format(plugin_name))
- return None
- else:
- logger.info("Found REST Plugin: {}".format(plugin_name))
- return plugin_id
-
- def enable_rest_plugin(self, plugin_id, plugin_name):
- """
- Enable the REST plugin using plugin_id
- Params: plugin_id: plugin ID string that is to be enabled
- Returns: status (Boolean) - True for success, False for failure
- """
-
- if plugin_id is None or plugin_name is None:
- logger.debug("enable_rest_plugin() : Plugin ID or plugin_name not provided for {} plugin"
- .format(plugin_name))
- return False
-
- try:
- api_url = "/suite-api/api/alertplugins/{}/enable/True".format(plugin_id)
-
- resp = requests.put(self.vrops_site + api_url,
- auth=(self.vrops_user, self.vrops_password),
- verify=False)
-
- if resp.status_code is not 204:
- logger.warning("Failed to enable REST plugin {}. nResponse code {} nResponse Content: {}"
- .format(plugin_name, resp.status_code, resp.content))
- return False
-
- logger.info("Enabled REST plugin {}.".format(plugin_name))
- return True
-
- except Exception as exp:
- logger.warning("Error enabling REST plugin for {} plugin: Exception: {} n{}"
- .format(plugin_name, exp, traceback.format_exc()))
-
- def create_alarm_notification_rule(self, alarm_name, alarm_id, resource_id):
- """
- Create notification rule for each alarm
- Params:
- alarm_name
- alarm_id
- resource_id
-
- Returns:
- notification_id: notification_id or None
- """
- notification_name = 'notify_' + alarm_name
- notification_id = None
- plugin_name = 'MON_module_REST_Plugin'
-
- # 1) Find the REST Plugin id details for - MON_module_REST_Plugin
- plugin_id = self.check_if_plugin_configured(plugin_name)
- if plugin_id is None:
- logger.warning("Failed to get REST plugin_id for : {}".format('MON_module_REST_Plugin'))
- return None
-
- # 2) Create Alarm notification rule
- api_url = '/suite-api/api/notifications/rules'
- headers = {'Content-Type': 'application/json', 'Accept': 'application/json'}
- data = {
- "name": notification_name,
- "pluginId": plugin_id,
- "resourceFilter": {
- "matchResourceIdOnly": True,
- "resourceId": resource_id
- },
- "alertDefinitionIdFilters": {
- "values": [alarm_id]
- }
- }
-
- resp = requests.post(self.vrops_site + api_url,
- auth=(self.vrops_user, self.vrops_password),
- headers=headers,
- verify=False,
- data=json.dumps(data))
-
- if resp.status_code is not 201:
- logger.warning("Failed to create Alarm notification rule {} for {} alarm."
- " nResponse code: {} nResponse content: {}"
- .format(notification_name, alarm_name, resp.status_code, resp.content))
- return None
-
- # parse notification id from response
- resp_data = json.loads(resp.content)
- if resp_data.get('id') is not None:
- notification_id = resp_data['id']
-
- logger.info("Created Alarm notification rule {} for {} alarm.".format(notification_name, alarm_name))
- return notification_id
-
- def get_vm_moref_id(self, vapp_uuid):
- """
- Get the moref_id of given VM
- """
- try:
- if vapp_uuid:
- vm_details = self.get_vapp_details_rest(vapp_uuid)
- if vm_details and "vm_vcenter_info" in vm_details:
- vm_moref_id = vm_details["vm_vcenter_info"].get("vm_moref_id", None)
- logger.info("Found vm_moref_id: {} for vApp UUID: {}".format(vm_moref_id, vapp_uuid))
- return vm_moref_id
-
- except Exception as exp:
- logger.warning("Error occurred while getting VM moref ID for VM : {} n{}"
- .format(exp, traceback.format_exc()))
-
- def get_vapp_details_rest(self, vapp_uuid=None):
- """
- Method retrieve vapp detail from vCloud director
-
- Args:
- vapp_uuid - is vapp identifier.
-
- Returns:
- Returns VM MOref ID or return None
- """
-
- parsed_respond = {}
- vca = None
-
- if vapp_uuid is None:
- return parsed_respond
-
- vca = self.connect_as_admin()
- if not vca:
- logger.warning("Failed to connect to vCD")
- return parsed_respond
-
- url_list = [self.vcloud_site, '/api/vApp/vapp-', vapp_uuid]
- get_vapp_restcall = ''.join(url_list)
-
- if vca._session:
- headers = {'Accept': 'application/*+xml;version=' + API_VERSION,
- 'x-vcloud-authorization': vca._session.headers['x-vcloud-authorization']}
- response = requests.get(get_vapp_restcall,
- headers=headers,
- verify=False)
-
- if response.status_code != 200:
- logger.warning("REST API call {} failed. Return status code {}"
- .format(get_vapp_restcall, response.content))
- return parsed_respond
-
- try:
- xmlroot_respond = XmlElementTree.fromstring(response.content)
-
- namespaces = {'vm': 'http://www.vmware.com/vcloud/v1.5',
- "vmext": "http://www.vmware.com/vcloud/extension/v1.5",
- "xmlns": "http://www.vmware.com/vcloud/v1.5"
- }
-
- # parse children section for other attrib
- children_section = xmlroot_respond.find('vm:Children/', namespaces)
- if children_section is not None:
- vCloud_extension_section = children_section.find('xmlns:VCloudExtension', namespaces)
- if vCloud_extension_section is not None:
- vm_vcenter_info = {}
- vim_info = vCloud_extension_section.find('vmext:VmVimInfo', namespaces)
- vmext = vim_info.find('vmext:VmVimObjectRef', namespaces)
- if vmext is not None:
- vm_vcenter_info["vm_moref_id"] = vmext.find('vmext:MoRef', namespaces).text
- parsed_respond["vm_vcenter_info"] = vm_vcenter_info
-
- except Exception as exp:
- logger.warning("Error occurred calling rest api for getting vApp details: {} n{}"
- .format(exp, traceback.format_exc()))
-
- return parsed_respond
-
- def connect_as_admin(self):
- """ Method connect as pvdc admin user to vCloud director.
- There are certain action that can be done only by provider vdc admin user.
- Organization creation / provider network creation etc.
-
- Returns:
- The return vca object that letter can be used to connect to vcloud direct as admin for provider vdc
- """
-
- logger.debug("Logging into vCD org as admin.")
-
- try:
- host = self.vcloud_site
- org = 'System'
- client_as_admin = Client(host, verify_ssl_certs=False)
- client_as_admin.set_credentials(BasicLoginCredentials(self.admin_username, org,
- self.admin_password))
- return client_as_admin
-
- except Exception as e:
- logger.warning("Can't connect to a vCloud director as: {} with exception {}"
- .format(self.admin_username, e))
-
- def get_vm_resource_id(self, vm_moref_id):
- """ Find resource ID in vROPs using vm_moref_id
- """
- if vm_moref_id is None:
- return None
-
- api_url = '/suite-api/api/resources?resourceKind=VirtualMachine'
- headers = {'Accept': 'application/json'}
-
- resp = requests.get(self.vrops_site + api_url,
- auth=(self.vrops_user, self.vrops_password),
- verify=False, headers=headers)
-
- if resp.status_code is not 200:
- logger.warning("Failed to get resource details from vROPs for {}"
- " nResponse code:{} nResponse Content: {}"
- .format(vm_moref_id, resp.status_code, resp.content))
- return None
-
- vm_resource_id = None
- try:
- resp_data = json.loads(resp.content)
- if resp_data.get('resourceList') is not None:
- resource_list = resp_data.get('resourceList')
- for resource in resource_list:
- if resource.get('resourceKey') is not None:
- resource_details = resource['resourceKey']
- if resource_details.get('resourceIdentifiers') is not None:
- resource_identifiers = resource_details['resourceIdentifiers']
- for resource_identifier in resource_identifiers:
- if resource_identifier['identifierType']['name'] == 'VMEntityObjectID':
- if resource_identifier.get('value') is not None and \
- resource_identifier['value'] == vm_moref_id:
- vm_resource_id = resource['identifier']
- logger.info("Found VM resource ID: {} for vm_moref_id: {}"
- .format(vm_resource_id, vm_moref_id))
-
- except Exception as exp:
- logger.warning("get_vm_resource_id: Error in parsing {} n{}"
- .format(exp, traceback.format_exc()))
-
- return vm_resource_id
-
- def get_metrics_data(self, metric={}):
- """Get an individual metric's data of a resource.
- Params:
- 'metric_name': Normalized name of metric (string)
- 'resource_uuid': Resource UUID (string)
- 'period': Time period in Period Unit for which metrics data to be collected from
- Monitoring tool from now.
- 'period_unit': Period measurement unit can be one of 'HR', 'DAY', 'MONTH', 'YEAR'
-
- Return a dict that contains:
- 'metric_name': Normalized name of metric (string)
- 'resource_uuid': Resource UUID (string)
- 'tenant_id': tenent id name in which the resource is present in string format
- 'metrics_data': Dictionary containing time_series & metrics_series data.
- 'time_series': List of individual time stamp values in msec
- 'metrics_series': List of individual metrics data values
- Raises an exception upon error or when network is not found
- """
- return_data = {}
- return_data['schema_version'] = "1.0"
- return_data['schema_type'] = 'read_metric_data_response'
- return_data['vim_uuid'] = metric['vim_uuid']
- return_data['metric_name'] = metric['metric_name']
- # To do - No metric_uuid in vROPs, thus returning '0'
- return_data['metric_uuid'] = '0'
- return_data['correlation_id'] = metric['correlation_id']
- return_data['resource_uuid'] = metric['resource_uuid']
- return_data['metrics_data'] = {'time_series': [], 'metrics_series': []}
- # To do - Need confirmation about uuid & id
- ##if 'tenant_uuid' in metric and metric['tenant_uuid'] is not None:
- ## return_data['tenant_uuid'] = metric['tenant_uuid']
- ##else:
- ## return_data['tenant_uuid'] = None
- return_data['unit'] = None
- # return_data['tenant_id'] = self.tenant_id
- # logger.warning("return_data: {}".format(return_data))
-
- # 1) Get metric details from plugin specific file & format it into vROPs metrics
- metric_key_params = self.get_default_Params(metric['metric_name'])
-
- if not metric_key_params:
- logger.warning("Metric not supported: {}".format(metric['metric_name']))
- # To Do: Return message
- return return_data
-
- return_data['unit'] = metric_key_params['unit']
-
- # 2) Find the resource id in vROPs based on OSM resource_uuid
- # 2.a) Find vm_moref_id from vApp uuid in vCD
- vm_moref_id = self.get_vm_moref_id(metric['resource_uuid'])
- if vm_moref_id is None:
- logger.warning("Failed to find vm morefid for vApp in vCD: {}".format(metric['resource_uuid']))
- return return_data
- # 2.b) Based on vm_moref_id, find VM's corresponding resource_id in vROPs to set notification
- resource_id = self.get_vm_resource_id(vm_moref_id)
- if resource_id is None:
- logger.warning("Failed to find resource in vROPs: {}".format(metric['resource_uuid']))
- return return_data
-
- # 3) Calculate begin & end time for period & period unit
- end_time = int(round(time.time() * 1000))
- if metric['collection_unit'] == 'YR':
- time_diff = PERIOD_MSEC[metric['collection_unit']]
- else:
- time_diff = metric['collection_period'] * PERIOD_MSEC[metric['collection_unit']]
- begin_time = end_time - time_diff
-
- # 4) Get the metrics data
- logger.info("metric_key_params['metric_key'] = {}".format(metric_key_params['metric_key']))
- logger.info("end_time: {}, begin_time: {}".format(end_time, begin_time))
-
- url_list = ['/suite-api/api/resources/', resource_id, '/stats?statKey=',
- metric_key_params['metric_key'], '&begin=', str(begin_time), '&end=', str(end_time)]
- api_url = ''.join(url_list)
- headers = {'Accept': 'application/json'}
-
- resp = requests.get(self.vrops_site + api_url,
- auth=(self.vrops_user, self.vrops_password),
- verify=False, headers=headers)
-
- if resp.status_code is not 200:
- logger.warning(
- "Failed to retrieve Metric data from vROPs for {} nResponse code:{} nResponse Content: {}"
- .format(metric['metric_name'], resp.status_code, resp.content))
- return return_data
-
- # 5) Convert to required format
- metrics_data = {}
- json_data = json.loads(resp.content)
- for resp_key, resp_val in six.iteritems(json_data):
- if resp_key == 'values':
- data = json_data['values'][0]
- for data_k, data_v in six.iteritems(data):
- if data_k == 'stat-list':
- stat_list = data_v
- for stat_list_k, stat_list_v in six.iteritems(stat_list):
- for stat_keys, stat_vals in six.iteritems(stat_list_v[0]):
- if stat_keys == 'timestamps':
- metrics_data['time_series'] = stat_list_v[0]['timestamps']
- if stat_keys == 'data':
- metrics_data['metrics_series'] = stat_list_v[0]['data']
-
- return_data['metrics_data'] = metrics_data
-
- return return_data
-
- def update_alarm_configuration(self, new_alarm_config):
- """Update alarm configuration (i.e. Symptom & alarm) as per request
- """
- if new_alarm_config.get('alarm_uuid') is None:
- logger.warning("alarm_uuid is required to update an Alarm")
- return None
- # 1) Get Alarm details from it's uuid & find the symptom definition
- alarm_details_json, alarm_details = self.get_alarm_defination_details(new_alarm_config['alarm_uuid'])
- if alarm_details_json is None:
- return None
-
- try:
- # 2) Update the symptom definition
- if alarm_details['alarm_id'] is not None and alarm_details['symptom_definition_id'] is not None:
- symptom_defination_id = alarm_details['symptom_definition_id']
- else:
- logger.info("Symptom Definition ID not found for {}".format(new_alarm_config['alarm_uuid']))
- return None
-
- symptom_uuid = self.update_symptom_defination(symptom_defination_id, new_alarm_config)
-
- # 3) Update the alarm definition & Return UUID if successful update
- if symptom_uuid is None:
- logger.info("Symptom Definition details not found for {}"
- .format(new_alarm_config['alarm_uuid']))
- return None
- else:
- alarm_uuid = self.reconfigure_alarm(alarm_details_json, new_alarm_config)
- if alarm_uuid is None:
- return None
- else:
- return alarm_uuid
- except:
- logger.error("Exception while updating alarm: {}".format(traceback.format_exc()))
-
- def get_alarm_defination_details(self, alarm_uuid):
- """Get alarm details based on alarm UUID
- """
- if alarm_uuid is None:
- logger.warning("get_alarm_defination_details: Alarm UUID not provided")
- return None, None
-
- alarm_details = {}
- json_data = {}
- api_url = '/suite-api/api/alertdefinitions/AlertDefinition-'
- headers = {'Accept': 'application/json'}
-
- resp = requests.get(self.vrops_site + api_url + alarm_uuid,
- auth=(self.vrops_user, self.vrops_password),
- verify=False, headers=headers)
-
- if resp.status_code is not 200:
- logger.warning("Alarm to be updated not found: {} nResponse code:{} nResponse Content: {}"
- .format(alarm_uuid, resp.status_code, resp.content))
- return None, None
-
- try:
- json_data = json.loads(resp.content)
- if json_data['id'] is not None:
- alarm_details['alarm_id'] = json_data['id']
- alarm_details['alarm_name'] = json_data['name']
- alarm_details['adapter_kind'] = json_data['adapterKindKey']
- alarm_details['resource_kind'] = json_data['resourceKindKey']
- alarm_details['type'] = json_data['type']
- alarm_details['sub_type'] = json_data['subType']
- alarm_details['symptom_definition_id'] = \
- json_data['states'][0]['base-symptom-set']['symptomDefinitionIds'][0]
- except Exception as exp:
- logger.warning("Exception while retrieving alarm definition details: {}".format(exp))
- return None, None
-
- return json_data, alarm_details
-
- def get_alarm_defination_by_name(self, alarm_name):
- """Get alarm details based on alarm name
- """
- status = False
- alert_match_list = []
-
- if alarm_name is None:
- logger.warning("get_alarm_defination_by_name: Alarm name not provided")
- return alert_match_list
-
- json_data = {}
- api_url = '/suite-api/api/alertdefinitions'
- headers = {'Accept': 'application/json'}
-
- resp = requests.get(self.vrops_site + api_url,
- auth=(self.vrops_user, self.vrops_password),
- verify=False, headers=headers)
-
- if resp.status_code is not 200:
- logger.warning("get_alarm_defination_by_name: Error in response: {} nResponse code:{}"
- " nResponse Content: {}".format(alarm_name, resp.status_code, resp.content))
- return alert_match_list
-
- try:
- json_data = json.loads(resp.content)
- if json_data['alertDefinitions'] is not None:
- alerts_list = json_data['alertDefinitions']
- alert_match_list = list(filter(lambda alert: alert['name'] == alarm_name, alerts_list))
- status = False if not alert_match_list else True
- # logger.debug("Found alert_match_list: {}for larm_name: {}, nstatus: {}".format(alert_match_list, alarm_name,status))
-
- return alert_match_list
-
- except Exception as exp:
- logger.warning("Exception while searching alarm definition: {}".format(exp))
- return alert_match_list
-
- def update_symptom_defination(self, symptom_uuid, new_alarm_config):
- """Update symptom definition based on new alarm input configuration
- """
- # 1) Get symptom definition details
- symptom_details = self.get_symptom_defination_details(symptom_uuid)
- # print " n nsymptom_details: {}".format(symptom_details)
- if symptom_details is None:
- return None
-
- if 'severity' in new_alarm_config and new_alarm_config['severity'] is not None:
- symptom_details['state']['severity'] = severity_mano2vrops[new_alarm_config['severity']]
- if 'operation' in new_alarm_config and new_alarm_config['operation'] is not None:
- symptom_details['state']['condition']['operator'] = OPERATION_MAPPING[new_alarm_config['operation']]
- if 'threshold_value' in new_alarm_config and new_alarm_config['threshold_value'] is not None:
- symptom_details['state']['condition']['value'] = new_alarm_config['threshold_value']
- # Find vrops metric key from metric_name, if required
- """
- if 'metric_name' in new_alarm_config and new_alarm_config['metric_name'] is not None:
- metric_key_params = self.get_default_Params(new_alarm_config['metric_name'])
- if not metric_key_params:
- logger.warning("Metric not supported: {}".format(config_dict['metric_name']))
- return None
- symptom_details['state']['condition']['key'] = metric_key_params['metric_key']
- """
- logger.info("Fetched Symptom details : {}".format(symptom_details))
-
- api_url = '/suite-api/api/symptomdefinitions'
- headers = {'Content-Type': 'application/json', 'Accept': 'application/json'}
- data = json.dumps(symptom_details)
- resp = requests.put(self.vrops_site + api_url,
- auth=(self.vrops_user, self.vrops_password),
- headers=headers,
- verify=False,
- data=data)
-
- if resp.status_code != 200:
- logger.warning("Failed to update Symptom definition: {}, response {}"
- .format(symptom_uuid, resp.content))
- return None
-
- if symptom_uuid is not None:
- logger.info("Symptom definition updated {} for alarm: {}"
- .format(symptom_uuid, new_alarm_config['alarm_uuid']))
- return symptom_uuid
- else:
- logger.warning("Failed to update Symptom Definition {} for : {}"
- .format(symptom_uuid, new_alarm_config['alarm_uuid']))
- return None
-
- def get_symptom_defination_details(self, symptom_uuid):
- """Get symptom definition details
- """
- symptom_details = {}
- if symptom_uuid is None:
- logger.warning("get_symptom_defination_details: Symptom UUID not provided")
- return None
-
- api_url = '/suite-api/api/symptomdefinitions/'
- headers = {'Accept': 'application/json'}
-
- resp = requests.get(self.vrops_site + api_url + symptom_uuid,
- auth=(self.vrops_user, self.vrops_password),
- verify=False, headers=headers)
-
- if resp.status_code is not 200:
- logger.warning("Symptom definition not found {} nResponse code:{} nResponse Content: {}"
- .format(symptom_uuid, resp.status_code, resp.content))
- return None
-
- symptom_details = json.loads(resp.content)
- # print "New symptom Details: {}".format(symptom_details)
- return symptom_details
-
- def reconfigure_alarm(self, alarm_details_json, new_alarm_config):
- """Reconfigure alarm definition as per input
- """
- if 'severity' in new_alarm_config and new_alarm_config['severity'] is not None:
- alarm_details_json['states'][0]['severity'] = new_alarm_config['severity']
- if 'description' in new_alarm_config and new_alarm_config['description'] is not None:
- alarm_details_json['description'] = new_alarm_config['description']
-
- api_url = '/suite-api/api/alertdefinitions'
- headers = {'Content-Type': 'application/json', 'Accept': 'application/json'}
- data = json.dumps(alarm_details_json)
- resp = requests.put(self.vrops_site + api_url,
- auth=(self.vrops_user, self.vrops_password),
- headers=headers,
- verify=False,
- data=data)
-
- if resp.status_code != 200:
- logger.warning("Failed to update Alarm definition: {}, response code {}, response content: {}"
- .format(alarm_details_json['id'], resp.status_code, resp.content))
- return None
- else:
- parsed_alarm_details = json.loads(resp.content)
- alarm_def_uuid = parsed_alarm_details['id'].split('-', 1)[1]
- logger.info("Successfully updated Alarm definition: {}".format(alarm_def_uuid))
- return alarm_def_uuid
-
- def delete_alarm_configuration(self, delete_alarm_req_dict):
- """Delete complete alarm configuration
- """
- if delete_alarm_req_dict['alarm_uuid'] is None:
- logger.info("delete_alarm_configuration: Alarm UUID not provided")
- return None
- # 1)Get alarm & symptom definition details
- alarm_details_json, alarm_details = self.get_alarm_defination_details(delete_alarm_req_dict['alarm_uuid'])
- if alarm_details is None or alarm_details_json is None:
- return None
-
- # 2) Delete alarm notification
- rule_id = self.delete_notification_rule(alarm_details['alarm_name'])
- if rule_id is None:
- return None
-
- # 3) Delete alarm configuration
- alarm_id = self.delete_alarm_defination(alarm_details['alarm_id'])
- if alarm_id is None:
- return None
-
- # 4) Delete alarm symptom
- symptom_id = self.delete_symptom_definition(alarm_details['symptom_definition_id'])
- if symptom_id is None:
- return None
- else:
- logger.info("Completed deleting alarm configuration: {}"
- .format(delete_alarm_req_dict['alarm_uuid']))
- return delete_alarm_req_dict['alarm_uuid']
-
- def delete_notification_rule(self, alarm_name):
- """Deleted notification rule defined for a particular alarm
- """
- rule_id = self.get_notification_rule_id_by_alarm_name(alarm_name)
- if rule_id is None:
- return None
- else:
- api_url = '/suite-api/api/notifications/rules/'
- headers = {'Accept': 'application/json'}
- resp = requests.delete(self.vrops_site + api_url + rule_id,
- auth=(self.vrops_user, self.vrops_password),
- verify=False, headers=headers)
- if resp.status_code is not 204:
- logger.warning("Failed to delete notification rules for {}".format(alarm_name))
- return None
- else:
- logger.info("Deleted notification rules for {}".format(alarm_name))
- return rule_id
-
- def get_notification_rule_id_by_alarm_name(self, alarm_name):
- """Find created Alarm notification rule id by alarm name
- """
- alarm_notify_id = 'notify_' + alarm_name
- api_url = '/suite-api/api/notifications/rules'
- headers = {'Content-Type': 'application/json', 'Accept': 'application/json'}
- resp = requests.get(self.vrops_site + api_url,
- auth=(self.vrops_user, self.vrops_password),
- verify=False, headers=headers)
-
- if resp.status_code is not 200:
- logger.warning("Failed to get notification rules details for {}"
- .format(alarm_name))
- return None
-
- notifications = json.loads(resp.content)
- if notifications is not None and 'notification-rule' in notifications:
- notifications_list = notifications['notification-rule']
- for dict in notifications_list:
- if dict['name'] is not None and dict['name'] == alarm_notify_id:
- notification_id = dict['id']
- logger.info("Found Notification id to be deleted: {} for {}"
- .format(notification_id, alarm_name))
- return notification_id
-
- logger.warning("Notification id to be deleted not found for {}"
- .format(alarm_name))
- return None
-
- def delete_alarm_defination(self, alarm_id):
- """Delete created Alarm definition
- """
- api_url = '/suite-api/api/alertdefinitions/'
- headers = {'Accept': 'application/json'}
- resp = requests.delete(self.vrops_site + api_url + alarm_id,
- auth=(self.vrops_user, self.vrops_password),
- verify=False, headers=headers)
- if resp.status_code is not 204:
- logger.warning("Failed to delete alarm definition {}".format(alarm_id))
- return None
- else:
- logger.info("Deleted alarm definition {}".format(alarm_id))
- return alarm_id
-
- def delete_symptom_definition(self, symptom_id):
- """Delete symptom definition
- """
- api_url = '/suite-api/api/symptomdefinitions/'
- headers = {'Accept': 'application/json'}
- resp = requests.delete(self.vrops_site + api_url + symptom_id,
- auth=(self.vrops_user, self.vrops_password),
- verify=False, headers=headers)
- if resp.status_code is not 204:
- logger.warning("Failed to delete symptom definition {}".format(symptom_id))
- return None
- else:
- logger.info("Deleted symptom definition {}".format(symptom_id))
- return symptom_id
-
- def verify_metric_support(self, metric_info):
- """Verify, if Metric is supported by vROPs plugin, verify metric unit & return status
- Returns:
- status: True if supported, False if not supported
- """
- status = False
- if 'metric_name' not in metric_info:
- logger.debug("Metric name not provided: {}".format(metric_info))
- return status
- metric_key_params = self.get_default_Params(metric_info['metric_name'].lower())
- if not metric_key_params:
- logger.warning("Metric not supported: {}".format(metric_info['metric_name']))
- return status
- else:
- # If Metric is supported, verify optional metric unit & return status
- if 'metric_unit' in metric_info:
- if metric_key_params.get('unit') == metric_info['metric_unit']:
- logger.info("Metric is supported with unit: {}".format(metric_info['metric_name']))
- status = True
- else:
- logger.debug("Metric supported but there is unit mismatch for: {}."
- "Supported unit: {}"
- .format(metric_info['metric_name'], metric_key_params['unit']))
- status = True
- return status
-
- def get_triggered_alarms_list(self, list_alarm_input):
- """Get list of triggered alarms on a resource based on alarm input request.
- """
- # TO Do - Need to add filtering of alarms based on Severity & alarm name
-
- triggered_alarms_list = []
- if list_alarm_input.get('resource_uuid') is None:
- logger.warning("Resource UUID is required to get triggered alarms list")
- return triggered_alarms_list
-
- # 1)Find vROPs resource ID using RO resource UUID
- vrops_resource_id = self.get_vrops_resourceid_from_ro_uuid(list_alarm_input['resource_uuid'])
- if vrops_resource_id is None:
- return triggered_alarms_list
-
- # 2)Get triggered alarms on particular resource
- triggered_alarms_list = self.get_triggered_alarms_on_resource(list_alarm_input['resource_uuid'],
- vrops_resource_id)
- return triggered_alarms_list
-
- def get_vrops_resourceid_from_ro_uuid(self, ro_resource_uuid):
- """Fetch vROPs resource ID using resource UUID from RO/SO
- """
- # 1) Find vm_moref_id from vApp uuid in vCD
- vm_moref_id = self.get_vm_moref_id(ro_resource_uuid)
- if vm_moref_id is None:
- logger.warning("Failed to find vm morefid for vApp in vCD: {}".format(ro_resource_uuid))
- return None
-
- # 2) Based on vm_moref_id, find VM's corresponding resource_id in vROPs to set notification
- vrops_resource_id = self.get_vm_resource_id(vm_moref_id)
- if vrops_resource_id is None:
- logger.warning("Failed to find resource in vROPs: {}".format(ro_resource_uuid))
- return None
- return vrops_resource_id
-
- def get_triggered_alarms_on_resource(self, ro_resource_uuid, vrops_resource_id):
- """Get triggered alarms on particular resource & return list of dictionary of alarms
- """
- resource_alarms = []
- api_url = '/suite-api/api/alerts?resourceId='
- headers = {'Accept': 'application/json'}
- resp = requests.get(self.vrops_site + api_url + vrops_resource_id,
- auth=(self.vrops_user, self.vrops_password),
- verify=False, headers=headers)
-
- if resp.status_code is not 200:
- logger.warning("Failed to get triggered alarms for {}"
- .format(ro_resource_uuid))
- return None
-
- all_alerts = json.loads(resp.content)
- if 'alerts' in all_alerts:
- if not all_alerts['alerts']:
- logger.info("No alarms present on resource {}".format(ro_resource_uuid))
- return resource_alarms
- all_alerts_list = all_alerts['alerts']
- for alarm in all_alerts_list:
- # logger.info("Triggered Alarm {}".format(alarm))
- if alarm['alertDefinitionName'] is not None and \
- len(alarm['alertDefinitionName'].split('-', 1)) == 2:
- if alarm['alertDefinitionName'].split('-', 1)[1] == ro_resource_uuid:
- alarm_instance = {'alarm_uuid': alarm['alertDefinitionId'].split('-', 1)[1],
- 'resource_uuid': ro_resource_uuid,
- 'alarm_instance_uuid': alarm['alertId'],
- 'vim_type': 'VMware'}
- # find severity of alarm
- severity = None
- for key, value in six.iteritems(severity_mano2vrops):
- if value == alarm['alertLevel']:
- severity = key
- if severity is None:
- severity = 'INDETERMINATE'
- alarm_instance['severity'] = severity
- alarm_instance['status'] = alarm['status']
- alarm_instance['start_date'] = self.convert_date_time(alarm['startTimeUTC'])
- alarm_instance['update_date'] = self.convert_date_time(alarm['updateTimeUTC'])
- alarm_instance['cancel_date'] = self.convert_date_time(alarm['cancelTimeUTC'])
- logger.info("Triggered Alarm on resource {}".format(alarm_instance))
- resource_alarms.append(alarm_instance)
- if not resource_alarms:
- logger.info("No alarms present on resource {}".format(ro_resource_uuid))
- return resource_alarms
-
- def convert_date_time(self, date_time):
- """Convert the input UTC time in msec to OSM date time format
- """
- date_time_formatted = '0000-00-00T00:00:00'
- if date_time != 0:
- complete_datetime = datetime.datetime.fromtimestamp(date_time / 1000.0, tz=pytz.utc).isoformat('T')
- date_time_formatted = complete_datetime.split('.', 1)[0]
- return date_time_formatted
+++ /dev/null
-# -*- coding: utf-8 -*-
-
-##
-# Copyright 2016-2017 VMware Inc.
-# This file is part of ETSI OSM
-# All Rights Reserved.
-#
-# 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: osslegalrouting@vmware.com
-##
-
-"""
-Monitoring plugin receiver that consumes the request messages &
-responds using producer for vROPs
-"""
-
-import json
-import logging
-import os
-import sys
-import traceback
-from io import UnsupportedOperation
-
-import six
-
-from osm_mon.core.settings import Config
-from osm_mon.plugins.vRealiseOps.mon_plugin_vrops import MonPlugin
-
-sys.path.append(os.path.join(os.path.dirname(os.path.abspath(__file__)), '..', '..', '..'))
-
-from osm_mon.core.auth import AuthManager
-
-from xml.etree import ElementTree as XmlElementTree
-
-schema_version = "1.0"
-req_config_params = ('vrops_site', 'vrops_user', 'vrops_password',
- 'vcloud-site', 'admin_username', 'admin_password',
- 'vcenter_ip', 'vcenter_port', 'vcenter_user', 'vcenter_password',
- 'vim_tenant_name', 'orgname')
-MODULE_DIR = os.path.dirname(__file__)
-CONFIG_FILE_NAME = 'vrops_config.xml'
-CONFIG_FILE_PATH = os.path.join(MODULE_DIR, CONFIG_FILE_NAME)
-
-cfg = Config.instance()
-logging.basicConfig(stream=sys.stdout,
- format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
- datefmt='%m/%d/%Y %I:%M:%S %p',
- level=logging.getLevelName(cfg.OSMMON_LOG_LEVEL))
-
-logger = logging.getLogger(__name__)
-
-
-class PluginReceiver:
- """MON Plugin receiver receiving request messages & responding using producer for vROPs
- telemetry plugin
- """
-
- def __init__(self):
- """Constructor of PluginReceiver
- """
- self._cfg = Config.instance()
-
- def handle_alarm_requests(self, key: str, values: dict, vim_uuid: str):
- values['vim_uuid'] = vim_uuid
- if key == "create_alarm_request":
- config_alarm_info = values
- alarm_uuid = self.create_alarm(config_alarm_info)
- logger.info("Alarm created with alarm uuid: {}".format(alarm_uuid))
- # Publish message using producer
- return self.publish_create_alarm_status(alarm_uuid, config_alarm_info)
- elif key == "update_alarm_request":
- update_alarm_info = values
- alarm_uuid = self.update_alarm(update_alarm_info)
- logger.info("Alarm definition updated : alarm uuid: {}".format(alarm_uuid))
- # Publish message using producer
- return self.publish_update_alarm_status(alarm_uuid, update_alarm_info)
- elif key == "delete_alarm_request":
- delete_alarm_info = values
- alarm_uuid = self.delete_alarm(delete_alarm_info)
- logger.info("Alarm definition deleted : alarm uuid: {}".format(alarm_uuid))
- # Publish message using producer
- return self.publish_delete_alarm_status(alarm_uuid, delete_alarm_info)
- elif key == "list_alarm_request":
- request_input = values
- triggered_alarm_list = self.list_alarms(request_input)
- # Publish message using producer
- return self.publish_list_alarm_response(triggered_alarm_list, request_input)
- else:
- raise UnsupportedOperation("Unknown key, no action will be performed")
-
- def handle_metric_requests(self, key: str, values: dict, vim_uuid: str):
- values['vim_uuid'] = vim_uuid
- if key == "read_metric_data_request":
- metric_request_info = values
- access_config = self.get_vim_access_config(metric_request_info['vim_uuid'])
- mon_plugin_obj = MonPlugin(access_config)
- metrics_data = mon_plugin_obj.get_metrics_data(metric_request_info)
- logger.info("Collected Metrics Data: {}".format(metrics_data))
- # Publish message using producer
- return self.publish_metrics_data_status(metrics_data)
- elif key == "create_metric_request":
- metric_info = values
- metric_status = self.verify_metric(metric_info)
- # Publish message using producer
- return self.publish_create_metric_response(metric_info, metric_status)
- elif key == "update_metric_request":
- metric_info = values
- metric_status = self.verify_metric(metric_info)
- # Publish message using producer
- return self.publish_update_metric_response(metric_info, metric_status)
- elif key == "delete_metric_request":
- metric_info = values
- # Deleting Metric Data is not allowed. Publish status as False
- logger.warning("Deleting Metric is not allowed by VMware vROPs plugin: {}"
- .format(metric_info['metric_name']))
- # Publish message using producer
- return self.publish_delete_metric_response(metric_info)
-
- else:
- raise UnsupportedOperation("Unknown key, no action will be performed")
-
- def create_alarm(self, config_alarm_info):
- """Create alarm using vROPs plugin
- """
- access_config = self.get_vim_access_config(config_alarm_info['vim_uuid'])
- mon_plugin = MonPlugin(access_config)
- mon_plugin.configure_rest_plugin()
- alarm_uuid = mon_plugin.configure_alarm(config_alarm_info['alarm_create_request'])
- return alarm_uuid
-
- def publish_create_alarm_status(self, alarm_uuid, config_alarm_info):
- """Publish create alarm status using producer
- """
- topic = 'alarm_response'
- msg_key = 'create_alarm_response'
- response_msg = {"schema_version": schema_version,
- "schema_type": "create_alarm_response",
- "vim_uuid": config_alarm_info["vim_uuid"],
- "alarm_create_response":
- {"correlation_id": config_alarm_info["alarm_create_request"]["correlation_id"],
- "alarm_uuid": alarm_uuid,
- "status": True if alarm_uuid else False
- }
- }
- logger.info("Publishing response:\nTopic={}\nKey={}\nValue={}"
- .format(topic, msg_key, response_msg))
-
- return response_msg
-
- def update_alarm(self, update_alarm_info):
- """Update already created alarm
- """
- access_config = self.get_vim_access_config(update_alarm_info['vim_uuid'])
- mon_plugin = MonPlugin(access_config)
- alarm_uuid = mon_plugin.update_alarm_configuration(update_alarm_info['alarm_update_request'])
- return alarm_uuid
-
- def publish_update_alarm_status(self, alarm_uuid, update_alarm_info):
- """Publish update alarm status requests using producer
- """
- topic = 'alarm_response'
- msg_key = 'update_alarm_response'
- response_msg = {"schema_version": schema_version,
- "schema_type": "update_alarm_response",
- "vim_uuid": update_alarm_info["vim_uuid"],
- "alarm_update_response":
- {"correlation_id": update_alarm_info["alarm_update_request"]["correlation_id"],
- "alarm_uuid": update_alarm_info["alarm_update_request"]["alarm_uuid"] \
- if update_alarm_info["alarm_update_request"].get('alarm_uuid') is not None else None,
- "status": True if alarm_uuid else False
- }
- }
- logger.info("Publishing response:\nTopic={}\nKey={}\nValue={}"
- .format(topic, msg_key, response_msg))
-
- return response_msg
-
- def delete_alarm(self, delete_alarm_info):
- """Delete alarm configuration
- """
- access_config = self.get_vim_access_config(delete_alarm_info['vim_uuid'])
- mon_plugin = MonPlugin(access_config)
- alarm_uuid = mon_plugin.delete_alarm_configuration(delete_alarm_info['alarm_delete_request'])
- return alarm_uuid
-
- def publish_delete_alarm_status(self, alarm_uuid, delete_alarm_info):
- """Publish update alarm status requests using producer
- """
- topic = 'alarm_response'
- msg_key = 'delete_alarm_response'
- response_msg = {"schema_version": schema_version,
- "schema_type": "delete_alarm_response",
- "vim_uuid": delete_alarm_info['vim_uuid'],
- "alarm_deletion_response":
- {"correlation_id": delete_alarm_info["alarm_delete_request"]["correlation_id"],
- "alarm_uuid": delete_alarm_info["alarm_delete_request"]["alarm_uuid"],
- "status": True if alarm_uuid else False
- }
- }
- logger.info("Publishing response:\nTopic={}\nKey={}\nValue={}"
- .format(topic, msg_key, response_msg))
-
- return response_msg
-
- def publish_metrics_data_status(self, metrics_data):
- """Publish the requested metric data using producer
- """
- topic = 'metric_response'
- msg_key = 'read_metric_data_response'
- logger.info("Publishing response:\nTopic={}\nKey={}\nValue={}"
- .format(topic, msg_key, metrics_data))
-
- return metrics_data
-
- def verify_metric(self, metric_info):
- """Verify if metric is supported or not
- """
- access_config = self.get_vim_access_config(metric_info['vim_uuid'])
- mon_plugin = MonPlugin(access_config)
- if 'metric_create_request' in metric_info:
- metric_key_status = mon_plugin.verify_metric_support(metric_info['metric_create_request'])
- else:
- metric_key_status = mon_plugin.verify_metric_support(metric_info['metric_update_request'])
- return metric_key_status
-
- def publish_create_metric_response(self, metric_info, metric_status):
- """Publish create metric response
- """
- topic = 'metric_response'
- msg_key = 'create_metric_response'
- response_msg = {"schema_version": schema_version,
- "schema_type": "create_metric_response",
- ##"vim_uuid":metric_info['vim_uuid'],
- ##"correlation_id":metric_info['correlation_id'],
- "metric_create_response":
- {
- ##"metric_uuid":'0',
- ##"resource_uuid":metric_info['metric_create']['resource_uuid'],
- ##"vim_uuid":metric_info['vim_uuid'], #May be required. TODO - Confirm
- "correlation_id": metric_info['correlation_id'],
- "status": metric_status
- }
- }
- logger.info("Publishing response:\nTopic={}\nKey={}\nValue={}"
- .format(topic, msg_key, response_msg))
-
- return response_msg
-
- def publish_update_metric_response(self, metric_info, metric_status):
- """Publish update metric response
- """
- topic = 'metric_response'
- msg_key = 'update_metric_response'
- response_msg = {"schema_version": schema_version,
- "schema_type": "metric_update_response",
- "vim_uuid": metric_info['vim_uuid'],
- "metric_update_response":
- {
- "metric_uuid": '0',
- "correlation_id": metric_info['correlation_id'],
- "resource_uuid": metric_info['metric_create']['resource_uuid'],
- "status": metric_status
- }
- }
- logger.info("Publishing response:\nTopic={}\nKey={}\nValue={}"
- .format(topic, msg_key, response_msg))
-
- return response_msg
-
- def publish_delete_metric_response(self, metric_info):
- """Publish delete metric response
- """
- topic = 'metric_response'
- msg_key = 'delete_metric_response'
- if 'tenant_uuid' in metric_info and metric_info['tenant_uuid'] is not None:
- tenant_uuid = metric_info['tenant_uuid']
- else:
- tenant_uuid = None
-
- response_msg = {"schema_version": schema_version,
- "schema_type": "delete_metric_response",
- "vim_uuid": metric_info['vim_uuid'],
- "correlation_id": metric_info['correlation_id'],
- "metric_name": metric_info['metric_name'],
- "metric_uuid": '0',
- "resource_uuid": metric_info['resource_uuid'],
- "tenant_uuid": tenant_uuid,
- "status": False
- }
- logger.info("Publishing response:\nTopic={}\nKey={}\nValue={}"
- .format(topic, msg_key, response_msg))
-
- return response_msg
-
- def list_alarms(self, list_alarm_input):
- """Collect list of triggered alarms based on input
- """
- access_config = self.get_vim_access_config(list_alarm_input['vim_uuid'])
- mon_plugin = MonPlugin(access_config)
- triggered_alarms = mon_plugin.get_triggered_alarms_list(list_alarm_input['alarm_list_request'])
- return triggered_alarms
-
- def publish_list_alarm_response(self, triggered_alarm_list, list_alarm_input):
- """Publish list of triggered alarms
- """
- topic = 'alarm_response'
- msg_key = 'list_alarm_response'
- response_msg = {"schema_version": schema_version,
- "schema_type": "list_alarm_response",
- "vim_type": "VMware",
- "vim_uuid": list_alarm_input['vim_uuid'],
- "correlation_id": list_alarm_input['alarm_list_request']['correlation_id'],
- "list_alarm_response": triggered_alarm_list
- }
- logger.info("Publishing response:\nTopic={}\nKey={}\nValue={}"
- .format(topic, msg_key, response_msg))
-
- return response_msg
-
- def update_access_credentials(self, access_info):
- """Verify if all the required access config params are provided and
- updates access config in default vrops config file
- """
- update_status = False
- # Check if all the required config params are passed in request
- if not all(keys in access_info for keys in req_config_params):
- logger.debug("All required Access Config Parameters not provided")
- logger.debug("List of required Access Config Parameters: {}".format(req_config_params))
- logger.debug("List of given Access Config Parameters: {}".format(access_info))
- return update_status
-
- wr_status = self.write_access_config(access_info)
- return wr_status # True/False
-
- def write_access_config(self, access_info):
- """Write access configuration to vROPs config file.
- """
- wr_status = False
- try:
- tree = XmlElementTree.parse(CONFIG_FILE_PATH)
- root = tree.getroot()
- alarmParams = {}
- for config in root:
- if config.tag == 'Access_Config':
- for param in config:
- for key, val in six.iteritems(access_info):
- if param.tag == key:
- # print param.tag, val
- param.text = val
-
- tree.write(CONFIG_FILE_PATH)
- wr_status = True
- except Exception as exp:
- logger.warning("Failed to update Access Config Parameters: {}".format(exp))
-
- return wr_status
-
- def publish_access_update_response(self, access_update_status, access_info_req):
- """Publish access update response
- """
- topic = 'access_credentials'
- msg_key = 'vim_access_credentials_response'
- response_msg = {"schema_version": schema_version,
- "schema_type": "vim_access_credentials_response",
- "correlation_id": access_info_req['access_config']['correlation_id'],
- "status": access_update_status
- }
- logger.info("Publishing response:\nTopic={}\nKey={}\nValue={}" \
- .format(topic, msg_key, response_msg))
- # Core Add producer
- return response_msg
-
- def get_vim_access_config(self, vim_uuid):
- """Get VIM access configuration & account details from path: VIM_ACCOUNTS_FILE_PATH
- """
- vim_account = {}
- auth_manager = AuthManager()
- vim_account_details = auth_manager.get_credentials(vim_uuid)
-
- try:
- if vim_account_details is not None:
- vim_account['name'] = vim_account_details.name
- vim_account['vim_tenant_name'] = vim_account_details.tenant_name
- vim_account['vim_type'] = vim_account_details.type
- vim_account['vim_url'] = vim_account_details.url
- vim_account['org_user'] = vim_account_details.user
- vim_account['org_password'] = vim_account_details.password
- vim_account['vim_uuid'] = vim_account_details.uuid
-
- vim_config = json.loads(vim_account_details.config)
- vim_account['admin_username'] = vim_config['admin_username']
- vim_account['admin_password'] = vim_config['admin_password']
- vim_account['vrops_site'] = vim_config['vrops_site']
- vim_account['vrops_user'] = vim_config['vrops_user']
- vim_account['vrops_password'] = vim_config['vrops_password']
- vim_account['vcenter_ip'] = vim_config['vcenter_ip']
- vim_account['vcenter_port'] = vim_config['vcenter_port']
- vim_account['vcenter_user'] = vim_config['vcenter_user']
- vim_account['vcenter_password'] = vim_config['vcenter_password']
-
- if vim_config['nsx_manager'] is not None:
- vim_account['nsx_manager'] = vim_config['nsx_manager']
- if vim_config['nsx_user'] is not None:
- vim_account['nsx_user'] = vim_config['nsx_user']
- if vim_config['nsx_password'] is not None:
- vim_account['nsx_password'] = vim_config['nsx_password']
- if vim_config['orgname'] is not None:
- vim_account['orgname'] = vim_config['orgname']
- except Exception as exp:
- logger.error("VIM account details not sufficient: {}".format(exp))
- return vim_account
-
-
-"""
-def main():
- #log.basicConfig(filename='mon_vrops_log.log',level=log.DEBUG)
- set_logger()
- plugin_rcvr = PluginReceiver()
- plugin_rcvr.consume()
-
-if __name__ == "__main__":
- main()
-"""
+++ /dev/null
-#!/usr/bin/env bash
-
-##
-# Copyright 2016-2017 VMware Inc.
-# This file is part of ETSI OSM
-# All Rights Reserved.
-#
-# 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: osslegalrouting@vmware.com
-##
-
-BASEDIR="$( cd "$( dirname "${BASH_SOURCE[0]}" )" && pwd )"
-SSL_Cert_Dir="${BASEDIR}/SSL_certificate"
-THISHOST=$(hostname -f)
-Domain_Name="${THISHOST}"
-#Domain_Name="www.vrops_webservice.com"
-WebServiceFile="${BASEDIR}/vrops_webservice"
-
-echo '
- #################################################################
- ##### Installing Require Packages #####
- #################################################################'
-
-#Function to install packages using apt-get
-function install_packages(){
- [ -x /usr/bin/apt-get ] && apt-get install -y $*
-
- #check properly installed
- for PACKAGE in $*
- do
- PACKAGE_INSTALLED="no"
- [ -x /usr/bin/apt-get ] && dpkg -l $PACKAGE &>> /dev/null && PACKAGE_INSTALLED="yes"
- if [ "$PACKAGE_INSTALLED" = "no" ]
- then
- echo "failed to install package '$PACKAGE'. Revise network connectivity and try again" >&2
- exit 1
- fi
- done
- }
-
-apt-get update # To get the latest package lists
-
-[ "$_DISTRO" == "Ubuntu" ] && install_packages "python3-yaml python3-bottle python3-jsonschema python3-requests libxml2-dev libxslt-dev python3-dev python3-pip openssl"
-[ "$_DISTRO" == "CentOS" -o "$_DISTRO" == "Red" ] && install_packages "python3-jsonschema python3-requests libxslt-devel libxml2-devel python3-devel python3-pip openssl"
-#The only way to install python-bottle on Centos7 is with easy_install or pip
-[ "$_DISTRO" == "CentOS" -o "$_DISTRO" == "Red" ] && easy_install -U bottle
-
-#required for vmware connector TODO move that to separete opt in install script
-pip3 install pip==9.0.3
-pip3 install cherrypy
-
-echo '
- #################################################################
- ##### Genrate SSL Certificate #####
- #################################################################'
-#Create SSL Certifcate folder and file
-mkdir "${SSL_Cert_Dir}"
-
-openssl genrsa -out "${SSL_Cert_Dir}/${Domain_Name}".key 2048
-openssl req -new -x509 -key "${SSL_Cert_Dir}/${Domain_Name}".key -out "${SSL_Cert_Dir}/${Domain_Name}".cert -days 3650 -subj /CN="${Domain_Name}"
-
-echo '
- #################################################################
- ##### Start Web Service #####
- #################################################################'
-
-nohup python3 "${WebServiceFile}" &
-
-echo '
- #################################################################
- ##### Done #####
- #################################################################'
-
-
+++ /dev/null
-#!/usr/bin/env python
-# -*- coding: utf-8 -*-
-
-##
-# Copyright 2016-2017 VMware Inc.
-# This file is part of ETSI OSM
-# All Rights Reserved.
-#
-# 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: osslegalrouting@vmware.com
-##
-
-"""
- Webservice for vRealize Operations (vROPs) to post/notify alarms details.
-
-"""
-from osm_mon.core.settings import Config
-
-__author__ = "Arpita Kate"
-__date__ = "$15-Sept-2017 16:09:29$"
-__version__ = '0.1'
-
-import json
-import logging
-import os
-import sys
-from datetime import datetime
-from socket import getfqdn
-
-import requests
-from bottle import (ServerAdapter, route, run, server_names, default_app,
- request, response)
-
-sys.path.append(os.path.join(os.path.dirname(os.path.abspath(__file__)), '..', '..', '..', '..'))
-from osm_mon.core.message_bus.producer import Producer
-
-# from core.message_bus.producer import KafkaProducer
-
-sys.path.append(os.path.join(os.path.dirname(os.path.abspath(__file__)), '..', '..', '..'))
-from osm_mon.core.database import DatabaseManager
-
-try:
- from cheroot.wsgi import Server as WSGIServer
- from cheroot.ssl.pyopenssl import pyOpenSSLAdapter
-except ImportError:
- from cherrypy.wsgiserver import CherryPyWSGIServer as WSGIServer
- from cherrypy.wsgiserver.ssl_pyopenssl import pyOpenSSLAdapter
-
-# Set Constants
-BASE_DIR = os.path.dirname(os.path.dirname(__file__))
-CERT_DIR = os.path.join(BASE_DIR, "SSL_certificate")
-certificate_name = getfqdn() + ".cert"
-key_name = getfqdn() + ".key"
-CERTIFICATE = os.path.join(CERT_DIR, certificate_name)
-KEY = os.path.join(CERT_DIR, key_name)
-# CERTIFICATE = os.path.join(CERT_DIR, "www.vrops_webservice.com.cert")
-# KEY = os.path.join(CERT_DIR, "www.vrops_webservice.com.key")
-CONFIG_FILE = os.path.join(BASE_DIR, '../vrops_config.xml')
-# Severity Mapping from vROPs to OSM
-VROPS_SEVERITY_TO_OSM_MAPPING = {
- "ALERT_CRITICALITY_LEVEL_CRITICAL": "CRITICAL",
- "ALERT_CRITICALITY_LEVEL_WARNING": "WARNING",
- "ALERT_CRITICALITY_LEVEL_IMMEDIATE": "MAJOR",
- "ALERT_CRITICALITY_LEVEL_INFO": "INDETERMINATE",
- "ALERT_CRITICALITY_LEVEL_AUTO": "INDETERMINATE",
- "ALERT_CRITICALITY_LEVEL_UNKNOWN": "INDETERMINATE",
- "ALERT_CRITICALITY_LEVEL_NONE": "INDETERMINATE"
-}
-
-# Set logger
-cfg = Config.instance()
-logging.basicConfig(stream=sys.stdout,
- format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
- datefmt='%m/%d/%Y %I:%M:%S %p',
- level=logging.getLevelName(cfg.OSMMON_LOG_LEVEL))
-
-logger = logging.getLogger(__name__)
-
-
-def format_datetime(str_date):
- """
- Method to format datetime
- Args:
- str_date - datetime string
- Returns:
- formated datetime
- """
- date_fromat = "%Y-%m-%dT%H:%M:%S"
- formated_datetime = None
- try:
- datetime_obj = datetime.fromtimestamp(float(str_date) / 1000.)
- formated_datetime = datetime_obj.strftime(date_fromat)
- except Exception as exp:
- logger.error('Exception: {} occured while converting date {} into format {}'.format(
- exp, str_date, date_fromat))
-
- return formated_datetime
-
-
-def get_alarm_config(alarm_name):
- """
- Method to get configuration parameters
- Args:
- None
- Returns:
- dictionary of config parameters
- """
- vim_account = {}
- database_manager = DatabaseManager()
- alarm = database_manager.get_alarm(alarm_name, 'VMware')
- vim_account_details = alarm.credentials
-
- try:
- if vim_account_details is not None:
- vim_account['name'] = vim_account_details.name
- vim_account['vim_tenant_name'] = vim_account_details.tenant_name
- vim_account['vim_type'] = vim_account_details.type
- vim_account['vim_uuid'] = vim_account_details.uuid
- vim_account['vim_url'] = vim_account_details.url
- vim_account['org_user'] = vim_account_details.user
- vim_account['org_password'] = vim_account_details.password
-
- vim_config = json.loads(vim_account_details.config)
- vim_account['tenant_id'] = vim_config['tenant_id']
- vim_account['admin_username'] = vim_config['admin_username']
- vim_account['admin_password'] = vim_config['admin_password']
- vim_account['vrops_site'] = vim_config['vrops_site']
- vim_account['vrops_user'] = vim_config['vrops_user']
- vim_account['vrops_password'] = vim_config['vrops_password']
- vim_account['vcenter_ip'] = vim_config['vcenter_ip']
- vim_account['vcenter_port'] = vim_config['vcenter_port']
- vim_account['vcenter_user'] = vim_config['vcenter_user']
- vim_account['vcenter_password'] = vim_config['vcenter_password']
- if vim_config['nsx_manager'] is not None:
- vim_account['nsx_manager'] = vim_config['nsx_manager']
- if vim_config['nsx_user'] is not None:
- vim_account['nsx_user'] = vim_config['nsx_user']
- if vim_config['nsx_password'] is not None:
- vim_account['nsx_password'] = vim_config['nsx_password']
- if vim_config['orgname'] is not None:
- vim_account['orgname'] = vim_config['orgname']
- except Exception as exp:
- logger.error("VIM account details not sufficient: {}".format(exp))
- return vim_account
-
-
-def get_alarm_definationID(alarm_instance_uuid, access_config):
- """
- Method to get alarm/alert defination ID
- Args:
- alarm_instance_uuid : UUID of alarm
- Returns:
- alarm defination ID
- """
- alarm_definationID = None
- if alarm_instance_uuid:
- try:
- # access_config = get_alarm_config()
- headers = {'Accept': 'application/json'}
- api_url = '{}/suite-api/api/alerts/{}' \
- .format(access_config.get('vrops_site'), alarm_instance_uuid)
- api_response = requests.get(api_url,
- auth=(access_config.get('vrops_user'),
- access_config.get('vrops_password')),
- verify=False,
- headers=headers
- )
-
- if api_response.status_code == 200:
- data = api_response.json()
- if data.get("alertDefinitionId") is not None:
- alarm_definationID = '-'.join(data.get("alertDefinitionId").split('-')[1:])
- else:
- logger.error("Failed to get alert definition ID for alarm {}"
- .format(alarm_instance_uuid))
- except Exception as exp:
- logger.error("Exception occured while getting alert definition ID for alarm : {}"
- .format(exp, alarm_instance_uuid))
-
- return alarm_definationID
-
-
-@route('/notify/<alarmID>', method='POST')
-def notify_alarm(alarmID):
- """
- Method notify alarm details by publishing message at Kafka message bus
- Args:
- alarmID - Name of alarm
- Returns:
- response code
- """
- logger.info("Request:{} from:{} {} {} " \
- .format(request, request.remote_addr, request.method, request.url))
- response.headers['Content-Type'] = 'application/json'
- try:
- postdata = json.loads(request.body.read())
- notify_details = {}
- vim_access_config = get_alarm_config(postdata.get('alertName'))
- # Parse notify data
- notify_details['vim_uuid'] = vim_access_config.get('vim_uuid')
- notify_details['alarm_uuid'] = get_alarm_definationID(postdata.get('alertId'),
- vim_access_config)
- notify_details['description'] = postdata.get('info')
- notify_details['alarm_instance_uuid'] = alarmID
- notify_details['resource_uuid'] = '-'.join(postdata.get('alertName').split('-')[1:])
- notify_details['tenant_uuid'] = vim_access_config.get('tenant_id')
- notify_details['vim_type'] = "VMware"
- notify_details['severity'] = VROPS_SEVERITY_TO_OSM_MAPPING.get(postdata.get('criticality'),
- 'INDETERMINATE')
- notify_details['status'] = postdata.get('status')
- if postdata.get('startDate'):
- notify_details['start_date_time'] = format_datetime(postdata.get('startDate'))
- if postdata.get('updateDate'):
- notify_details['update_date_time'] = format_datetime(postdata.get('updateDate'))
- if postdata.get('cancelDate'):
- notify_details['cancel_date_time'] = format_datetime(postdata.get('cancelDate'))
-
- alarm_details = {'schema_version': 1.0,
- 'schema_type': "notify_alarm",
- 'notify_details': notify_details
- }
- alarm_data = json.dumps(alarm_details)
- logger.info("Alarm details: {}".format(alarm_data))
-
- # Publish Alarm details
- producer = Producer()
- producer.send(topic='alarm_response', key=notify_alarm, value=alarm_data)
- producer.flush()
-
- # return 201 on Success
- response.status = 201
-
- except Exception as exp:
- logger.error('Exception: {} occured while notifying alarm {}.'.format(exp, alarmID))
- # return 500 on Error
- response.status = 500
-
- return response
-
-
-class SSLWebServer(ServerAdapter):
- """
- CherryPy web server with SSL support.
- """
-
- def run(self, handler):
- """
- Runs a CherryPy Server using the SSL certificate.
- """
- server = WSGIServer((self.host, self.port), handler)
- server.ssl_adapter = pyOpenSSLAdapter(
- certificate=CERTIFICATE,
- private_key=KEY,
- # certificate_chain="intermediate_cert.crt"
- )
-
- try:
- server.start()
- logger.info("Started vROPs Web Service")
- except Exception as exp:
- server.stop()
- logger.error("Exception: {} Stopped vROPs Web Service".format(exp))
-
-
-if __name__ == "__main__":
- # Start SSL Web Service
- logger.info("Start vROPs Web Service")
- app = default_app()
- server_names['sslwebserver'] = SSLWebServer
- run(app=app, host=getfqdn(), port=8080, server='sslwebserver')
+++ /dev/null
-<alarmsDefaultConfig>
- <Average_Memory_Usage_Above_Threshold>
- <vrops_alarm>Avg_Mem_Usage_Above_Thr</vrops_alarm>
- <period>300</period>
- <evaluation>2</evaluation>
- <cancel_period>300</cancel_period>
- <cancel_cycles>2</cancel_cycles>
- <enabled>true</enabled>
- <repeat>false</repeat>
- <action>acknowledge</action>
- <resource_kind>VirtualMachine</resource_kind>
- <adapter_kind>VMWARE</adapter_kind>
- <alarm_type>16</alarm_type>
- <alarm_subType>19</alarm_subType>
- <impact>risk</impact>
- <unit>%</unit>
- </Average_Memory_Usage_Above_Threshold>
- <Read_Latency_Above_Threshold>
- <vrops_alarm>RD_Latency_Above_Thr</vrops_alarm>
- <period>300</period>
- <evaluation>3</evaluation>
- <cancel_period>300</cancel_period>
- <cancel_cycles>3</cancel_cycles>
- <enabled>true</enabled>
- <repeat>false</repeat>
- <action>acknowledge</action>
- <resource_kind>VirtualMachine</resource_kind>
- <adapter_kind>VMWARE</adapter_kind>
- <alarm_type>18</alarm_type>
- <alarm_subType>19</alarm_subType>
- <impact>risk</impact>
- <unit>msec</unit>
- </Read_Latency_Above_Threshold>
- <Write_Latency_Above_Threshold>
- <vrops_alarm>WR_Latency_Above_Thr</vrops_alarm>
- <period>300</period>
- <evaluation>3</evaluation>
- <cancel_period>300</cancel_period>
- <cancel_cycles>3</cancel_cycles>
- <enabled>true</enabled>
- <repeat>false</repeat>
- <action>acknowledge</action>
- <resource_kind>VirtualMachine</resource_kind>
- <adapter_kind>VMWARE</adapter_kind>
- <alarm_type>18</alarm_type>
- <alarm_subType>19</alarm_subType>
- <impact>risk</impact>
- <unit>msec</unit>
- </Write_Latency_Above_Threshold>
- <Net_Packets_Dropped>
- <vrops_alarm>Net_Packets_Dropped</vrops_alarm>
- <period>300</period>
- <evaluation>1</evaluation>
- <cancel_period>300</cancel_period>
- <cancel_cycles>1</cancel_cycles>
- <enabled>true</enabled>
- <repeat>false</repeat>
- <action>acknowledge</action>
- <resource_kind>VirtualMachine</resource_kind>
- <adapter_kind>VMWARE</adapter_kind>
- <alarm_type>19</alarm_type>
- <alarm_subType>19</alarm_subType>
- <impact>risk</impact>
- <unit>nos</unit>
- </Net_Packets_Dropped>
- <CPU_Utilization_Above_Threshold>
- <vrops_alarm>CPU_Utilization_Above_Thr</vrops_alarm>
- <period>300</period>
- <evaluation>1</evaluation>
- <cancel_period>300</cancel_period>
- <cancel_cycles>1</cancel_cycles>
- <enabled>true</enabled>
- <repeat>false</repeat>
- <action>acknowledge</action>
- <resource_kind>VirtualMachine</resource_kind>
- <adapter_kind>VMWARE</adapter_kind>
- <alarm_type>16</alarm_type>
- <alarm_subType>19</alarm_subType>
- <impact>risk</impact>
- <unit>msec</unit>
- </CPU_Utilization_Above_Threshold>
- <average_memory_utilization>
- <metric_key>mem|usage_average</metric_key>
- <unit>%</unit>
- </average_memory_utilization>
- <cpu_utilization>
- <metric_key>cpu|usage_average</metric_key>
- <unit>%</unit>
- </cpu_utilization>
- <read_latency_0>
- <metric_key>virtualDisk:scsi0:0|totalReadLatency_average</metric_key>
- <unit>msec</unit>
- </read_latency_0>
- <write_latency_0>
- <metric_key>virtualDisk:scsi0:0|totalWriteLatency_average</metric_key>
- <unit>msec</unit>
- </write_latency_0>
- <read_latency_1>
- <metric_key>virtualDisk:scsi0:1|totalReadLatency_average</metric_key>
- <unit>msec</unit>
- </read_latency_1>
- <write_latency_1>
- <metric_key>virtualDisk:scsi0:1|totalWriteLatency_average</metric_key>
- <unit>msec</unit>
- </write_latency_1>
- <packets_dropped_0>
- <metric_key>net:4000|dropped</metric_key>
- <unit>nos</unit>
- </packets_dropped_0>
- <packets_dropped_1>
- <metric_key>net:4001|dropped</metric_key>
- <unit>nos</unit>
- </packets_dropped_1>
- <packets_dropped_2>
- <metric_key>net:4002|dropped</metric_key>
- <unit>nos</unit>
- </packets_dropped_2>
- <packets_received>
- <metric_key>net:Aggregate of all instances|packetsRxPerSec</metric_key>
- <unit>nos</unit>
- </packets_received>
- <packets_sent>
- <metric_key>net:Aggregate of all instances|packetsTxPerSec</metric_key>
- <unit>nos</unit>
- </packets_sent>
- <Access_Config>
- <vrops_site>https://192.169.241.123</vrops_site>
- <vrops_user>admin</vrops_user>
- <vrops_password>vmware</vrops_password>
- <vcloud-site>https://192.169.241.15</vcloud-site>
- <admin_username>admin</admin_username>
- <admin_password>vmware</admin_password>
- <nsx_manager>https://192.169.241.181</nsx_manager>
- <nsx_user>admin</nsx_user>
- <nsx_password>VMware1!</nsx_password>
- <vcenter_ip>192.169.241.13</vcenter_ip>
- <vcenter_port>443</vcenter_port>
- <vcenter_user>admin</vcenter_user>
- <vcenter_password>vmware</vcenter_password>
- <vim_tenant_name>Org2</vim_tenant_name>
- <orgname>Org2</orgname>
- <tenant_id>Org2</tenant_id>
- </Access_Config>
-</alarmsDefaultConfig>
\ No newline at end of file
+++ /dev/null
-{
-"schema_version": "1.0",
-"schema_type": "alarm_ack",
-"vim_type": "AWS",
-"ack_details":
-{
-"alarm_uuid": "CPU_Utilization_i-098da78cbd8304e17",
-"resource_uuid": "i-098da78cbd8304e17",
-"tenant_uuid": ""
-}
-}
\ No newline at end of file
+++ /dev/null
-{
-"schema_version": "1.0",
-"schema_type": "create_alarm_request",
-"vim_type": "AWS",
-"alarm_create_request":
-{
-"correlation_id": "SO123",
-"alarm_name": "CPU_Utilization_Above_Threshold",
-"resource_uuid": "i-098da78cbd8304e17",
-"description": "",
-"severity": "Critical",
-"operation": "GE",
-"threshold_value": 1.5,
-"unit": "",
-"metric_name": "CPU_UTILIZATION",
-"statistic": "MAXIMUM"
-}
-}
+++ /dev/null
-{
-"schema_version": "1.0",
-"schema_type": "create_alarm_request",
-"vim_type": "AWS",
-"alarm_create_request":
-{
-"correlation_id": "SO123",
-"alarm_name": "CPU_Utilization_Above_Threshold1",
-"resource_uuid": "i-098da78cbd8304e17",
-"description": "",
-"severity": "Critical",
-"operation": "GE",
-"threshold_value": 1.5,
-"unit": "",
-"metric_name": "CPU_UTILIZATION",
-"statistic": "MAXIMUM"
-}
-}
+++ /dev/null
-{
-"schema_version": "1.0",
-"schema_type": "create_alarm_request",
-"vim_type": "AWS",
-"alarm_create_request":
-{
-"correlation_id": "SO123",
-"alarm_name": "CPU_Utilization_Above_Threshold",
-"resource_uuid": "i-09462760703837b26",
-"description": "",
-"severity": "Critical",
-"operation": "GE",
-"threshold_value": 1.5,
-"unit": "",
-"metric_name": "CPU_UTILIZATION",
-"statistic": "MAXIMUM"
-}
-}
+++ /dev/null
-{
-"schema_version": "1.0",
-"schema_type": "create_alarm_request",
-"vim_type": "AWS",
-"alarm_create_request":
-{
-"correlation_id": "SO123",
-"alarm_name": "CPU_Utilization_Above_Threshold",
-"resource_uuid": "i-098da78cbd8304e17",
-"description": "",
-"severity": "Critical",
-"operation": "GE",
-"threshold_value": 1.5,
-"unit": "",
-"metric_name": "CPU_UTILIZATION",
-"statistic": "MAXIMUM"
-}
-}
+++ /dev/null
-{
-"schema_version": "1.0",
-"schema_type": "create_alarm_request",
-"vim_type": "AWS",
-"alarm_create_request":
-{
-"correlation_id": "SO123",
-"alarm_name": "CPU_Utilization_Above_Threshold2",
-"resource_uuid": "i-098da78cbd8304e17",
-"description": "",
-"severity": "Critical",
-"operation": "Greaterthan",
-"threshold_value": 1.5,
-"unit": "",
-"metric_name": "CPU_UTILIZATION",
-"statistic": "MAXIMUM"
-}
-}
+++ /dev/null
-{
-"schema_version": "1.0",
-"schema_type": "create_alarm_request",
-"vim_type": "AWS",
-"alarm_create_request":
-{
-"correlation_id": "SO123",
-"alarm_name": "CPU_Utilization_Above_Threshold2",
-"resource_uuid": "i-098da78cbd8304e17",
-"description": "",
-"severity": "Critical",
-"operation": "GE",
-"threshold_value": 1.5,
-"unit": "",
-"metric_name": "CPU_UTILIZATION",
-"statistic": "MAXIMUM"
-}
-}
+++ /dev/null
-{
-"schema_version": "1.0",
-"schema_type": "create_alarm_request",
-"vim_type": "AWS",
-"alarm_create_request":
-{
-"correlation_id": "SO123",
-"alarm_name": "CPU_Utilization_Above_Threshold2",
-"resource_uuid": "i-098da78cbd8304e17",
-"description": "",
-"severity": "Critical",
-"operation": "GE",
-"threshold_value": 1.5,
-"unit": "",
-"metric_name": "CPU_UTILIZATION",
-"statistic": "MAX"
-}
-}
+++ /dev/null
-{
-"schema_version": "1.0",
-"schema_type": "create_alarm_request",
-"vim_type": "AWS",
-"alarm_create_request":
-{
-"correlation_id": "SO123",
-"alarm_name": "CPU_Utilization_Above_Threshold2",
-"resource_uuid": "i-098da78cbd8304e17",
-"description": "",
-"severity": "Critical",
-"operation": "GE",
-"threshold_value": 1.5,
-"unit": "",
-"metric_name": "CPU_UTILIZATION",
-"statistic": "MAXIMUM"
-}
-}
+++ /dev/null
-{
-"schema_version": "1.0",
-"schema_type": "create_metrics_request",
-"tenant_uuid": "",
-"correlation_id": "SO123",
-"vim_type": "AWS",
-"metric_create":
-{
-"metric_name": "CPU_UTILIZ",
-"metric_unit": "",
-"resource_uuid": "i-098da78cbd8304e17"
-}
-}
\ No newline at end of file
+++ /dev/null
-{
-"schema_version": "1.0",
-"schema_type": "create_metrics_request",
-"tenant_uuid": "",
-"correlation_id": "SO123",
-"vim_type": "AWS",
-"metric_create":
-{
-"metric_name": "CPU_UTILIZATION",
-"metric_unit": "",
-"resource_uuid": "i-098da78cbd8304e17"
-}
-}
\ No newline at end of file
+++ /dev/null
-{
-"schema_version": "1.0",
-"schema_type": "delete_alarm_request",
-"vim_type": "AWS",
-"alarm_delete_request":
-{
-"alarm_uuid": "CPU_Utilization_Above_Threshold_i-098da78cbd8304e16",
-"correlation_id": "SO123"
-}
-}
\ No newline at end of file
+++ /dev/null
-{
-"schema_version": "1.0",
-"schema_type": "delete_alarm_request",
-"vim_type": "AWS",
-"alarm_delete_request":
-{
-"alarm_uuid": "CPU_Utilization_Above_Threshold_i-098da78cbd8304e17",
-"correlation_id": "SO123"
-}
-}
\ No newline at end of file
+++ /dev/null
-{
-"schema_version": "1.0",
-"schema_type": "delete_alarm_request",
-"vim_type": "AWS",
-"alarm_delete_request":
-{
-"alarm_uuid": "CPU_Utilization_Above_Threshold1_i-098da78cbd8304e17",
-"correlation_id": "SO123"
-}
-}
\ No newline at end of file
+++ /dev/null
-{
-"schema_version": "1.0",
-"schema_type": "delete_alarm_request",
-"vim_type": "AWS",
-"alarm_delete_request":
-{
-"alarm_uuid": "CPU_Utilization_Above_Threshold_i-09462760703837b26",
-"correlation_id": "SO123"
-}
-}
\ No newline at end of file
+++ /dev/null
-{
-"schema_version": "1.0",
-"schema_type": "delete_alarm_request",
-"vim_type": "AWS",
-"alarm_delete_request":
-{
-"alarm_uuid": "CPU_Utilization_Above_Threshold2_i-098da78cbd8304e17",
-"correlation_id": "SO123"
-}
-}
\ No newline at end of file
+++ /dev/null
-{
-"schema_version": "1.0",
-"schema_type": "delete_alarm_request",
-"vim_type": "AWS",
-"alarm_delete_request":
-{
-"alarm_uuid": "CPU_Utilization_Above_Threshold4_i-098da78cbd8304e17",
-"correlation_id": "SO123"
-}
-}
\ No newline at end of file
+++ /dev/null
-{
-"schema_version": "1.0",
-"schema_type": "delete_metric_data_request",
-"metric_name": "CPU_UTILIATION",
-"metric_uuid": "",
-"resource_uuid": "i-098da78cbd8304e17",
-"tenant_uuid": "",
-"correlation_uuid": "S0123",
-"vim_type": "AWS"
-}
\ No newline at end of file
+++ /dev/null
-{
-"schema_version": "1.0",
-"schema_type": "delete_metric_data_request",
-"metric_name": "CPU_UTILIZATION",
-"metric_uuid": "",
-"resource_uuid": "i-098da78cbd8304e17",
-"tenant_uuid": "",
-"correlation_uuid": "S0123",
-"vim_type": "AWS"
-}
\ No newline at end of file
+++ /dev/null
-{
-"schema_version": "1.0",
-"schema_type": "list_alarm_request",
-"vim_type": "AWS",
-"alarm_list_request":
-{
-"correlation_id": "SO123",
-"resource_uuid": "",
-"alarm_name": "",
-"severity": ""
-}
-}
\ No newline at end of file
+++ /dev/null
-{
-"schema_version": "1.0",
-"schema_type": "list_alarm_request",
-"vim_type": "AWS",
-"alarm_list_request":
-{
-"correlation_id": "SO123",
-"resource_uuid": "i-098da78cbd8304e17",
-"alarm_name": "",
-"severity": ""
-}
-}
\ No newline at end of file
+++ /dev/null
-{
-"schema_version": "1.0",
-"schema_type": "list_alarm_request",
-"vim_type": "AWS",
-"alarm_list_request":
-{
-"correlation_id": "SO123",
-"resource_uuid": "i-098da78cbd8304e17",
-"alarm_name": "",
-"severity": "Critical"
-}
-}
\ No newline at end of file
+++ /dev/null
-{
-"schema_version": "1.0",
-"schema_type": "list_metrics_request",
-"vim_type": "AWS",
-"metrics_list_request":
-{
-"metric_name": "CPU_UTILZATION",
-"correlation_id": "SO123",
-"resource_uuid": "i-098da78cbd8304e17"
-}
-}
\ No newline at end of file
+++ /dev/null
-{
-"schema_version": "1.0",
-"schema_type": "list_metrics_request",
-"vim_type": "AWS",
-"metrics_list_request":
-{
-"metric_name": "CPU_UTILIZATION",
-"correlation_id": "SO123",
-"resource_uuid": "i-098da78cbd8304e17"
-}
-}
\ No newline at end of file
+++ /dev/null
-{
-"schema_version": "1.0",
-"schema_type": "read_metric_data_request",
-"metric_name": "CPU_UTILIZATION",
-"metric_uuid": "0",
-"resource_uuid": "i-098da78cbd8304e17",
-"tenant_uuid": "",
-"correlation_uuid": "SO123",
-"vim_type":"AWS",
-"collection_period":"3500" ,
-"collection_unit": ""
-}
\ No newline at end of file
+++ /dev/null
-{
-"schema_version": "1.0",
-"schema_type": "read_metric_data_request",
-"metric_name": "CPU_UTILIZATION",
-"metric_uuid": "0",
-"resource_uuid": "i-098da78cbd8304e17",
-"tenant_uuid": "",
-"correlation_uuid": "SO123",
-"vim_type":"AWS",
-"collection_period":"3600" ,
-"collection_unit": ""
-}
\ No newline at end of file
+++ /dev/null
-{
-"schema_version": "1.0",
-"schema_type": "read_metric_data_request",
-"metric_name": "CPU_UTLIZATION",
-"metric_uuid": "0",
-"resource_uuid": "i-098da78cbd8304e17",
-"tenant_uuid": "",
-"correlation_uuid": "SO123",
-"vim_type":"AWS",
-"collection_period":"3600" ,
-"collection_unit": ""
-}
\ No newline at end of file
+++ /dev/null
-{
-"schema_version": "1.0",
-"schema_type": "read_metric_data_request",
-"metric_name": "CPU_UTILIZATION",
-"metric_uuid": "0",
-"resource_uuid": "i-098da78cbd8304e17",
-"tenant_uuid": "",
-"correlation_uuid": "SO123",
-"vim_type":"AWS",
-"collection_period":"3600" ,
-"collection_unit": ""
-}
\ No newline at end of file
+++ /dev/null
-{
-"schema_version": "1.0",
-"schema_type": "update_alarm_request",
-"vim_type": "AWS",
-"alarm_update_request":
-{
-"correlation_id": "SO123",
-"alarm_uuid": "CPU_Utilization_Above_Threshold_i-098da78cbd8304e13",
-"description": "",
-"severity": "Critical",
-"operation": "LE",
-"threshold_value": 1.5,
-"unit": "",
-"metric_name": "CPU_UTILIZATION",
-"statistic": "MAXIMUM"
-}
-}
\ No newline at end of file
+++ /dev/null
-{
-"schema_version": "1.0",
-"schema_type": "update_alarm_request",
-"vim_type": "AWS",
-"alarm_update_request":
-{
-"correlation_id": "SO123",
-"alarm_uuid": "CPU_Utilization_Above_Threshold4_i-098da78cbd8304e17",
-"description": "",
-"severity": "Critical",
-"operation": "LE",
-"threshold_value": 1.5,
-"unit": "",
-"metric_name": "CPU_UTILIZATION",
-"statistic": "MAXIMUM"
-}
-}
\ No newline at end of file
+++ /dev/null
-{
-"schema_version": "1.0",
-"schema_type": "update_alarm_request",
-"vim_type": "AWS",
-"alarm_update_request":
-{
-"correlation_id": "SO123",
-"alarm_uuid": "CPU_Utilization_Above_Threshold_i-098da78cbd8304e17",
-"description": "",
-"severity": "Critical",
-"operation": "Less",
-"threshold_value": 1.5,
-"unit": "",
-"metric_name": "CPU_UTILIZATION",
-"statistic": "MAXIMUM"
-}
-}
\ No newline at end of file
+++ /dev/null
-{
-"schema_version": "1.0",
-"schema_type": "update_alarm_request",
-"vim_type": "AWS",
-"alarm_update_request":
-{
-"correlation_id": "SO123",
-"alarm_uuid": "CPU_Utilization_Above_Threshold_i-098da78cbd8304e17",
-"description": "",
-"severity": "Critical",
-"operation": "LE",
-"threshold_value": 1.5,
-"unit": "",
-"metric_name": "CPU_UTILIZATION",
-"statistic": "MAXIMUM"
-}
-}
\ No newline at end of file
+++ /dev/null
-{
-"schema_version": "1.0",
-"schema_type": "update_alarm_request",
-"vim_type": "AWS",
-"alarm_update_request":
-{
-"correlation_id": "SO123",
-"alarm_uuid": "CPU_Utilization_Above_Threshold_i-098da78cbd8304e17",
-"description": "",
-"severity": "Critical",
-"operation": "LE",
-"threshold_value": 1.5,
-"unit": "",
-"metric_name": "CPU_UTILIZATION",
-"statistic": "MAX"
-}
-}
\ No newline at end of file
+++ /dev/null
-{
-"schema_version": "1.0",
-"schema_type": "update_alarm_request",
-"vim_type": "AWS",
-"alarm_update_request":
-{
-"correlation_id": "SO123",
-"alarm_uuid": "CPU_Utilization_Above_Threshold_i-098da78cbd8304e17",
-"description": "",
-"severity": "Critical",
-"operation": "LE",
-"threshold_value": 1.5,
-"unit": "",
-"metric_name": "CPU_UTILIZATION",
-"statistic": "MAXIMUM"
-}
-}
\ No newline at end of file
+++ /dev/null
-{
-"schema_version": "1.0",
-"schema_type": "create_alarm_request",
-"vim_type": "AWS",
-"alarm_create_request":
-{
-"correlation_id": "SO123",
-"alarm_name": "CPU_Utilization_Above_Threshold4",
-"resource_uuid": "i-098da78cbd8304e17",
-"description": "",
-"severity": "Critical",
-"operation": "GE",
-"threshold_value": 1.5,
-"unit": "",
-"metric_name": "CPU_UTILIZATION",
-"statistic": "MAXIMUM"
-}
-}
+++ /dev/null
-{
-"schema_version": "1.0",
-"schema_type": "create_metrics_request",
-"tenant_uuid": "",
-"correlation_id": "SO123",
-"vim_type": "AWS",
-"metric_create":
-{
-"metric_name": "CPU_UTILIZ",
-"metric_unit": "",
-"resource_uuid": "i-098da78cbd8304e17"
-}
-}
\ No newline at end of file
+++ /dev/null
-{
-"schema_version": "1.0",
-"schema_type": "create_metrics_request",
-"tenant_uuid": "",
-"correlation_id": "SO123",
-"vim_type": "AWS",
-"metric_create":
-{
-"metric_name": "CPU_UTILIZATION",
-"metric_unit": "",
-"resource_uuid": "i-098da78cbd8304e17"
-}
-}
\ No newline at end of file
+++ /dev/null
-from connection import Connection
-import unittest
-import sys
-import jsmin
-import json
-import os
-import time
-from jsmin import jsmin
-sys.path.append("../../test/core/")
-from test_producer import KafkaProducer
-from kafka import KafkaConsumer
-try:
- import boto
- import boto.ec2
- import boto.vpc
- import boto.ec2.cloudwatch
- import boto.ec2.connection
-except:
- exit("Boto not avialable. Try activating your virtualenv OR `pip install boto`")
-
-#--------------------------------------------------------------------------------------------------------------------------------------
-
-# Test Producer object to generate request
-
-producer = KafkaProducer('create_alarm_request')
-obj = Connection()
-connections = obj.setEnvironment()
-connections_res = obj.connection_instance()
-cloudwatch_conn = connections_res['cloudwatch_connection']
-
-#--------------------------------------------------------------------------------------------------------------------------------------
-
-'''Test E2E Flow : Test cases has been tested one at a time.
-1) Commom Request is generated using request function in test_producer.py(/test/core)
-2) The request is then consumed by the comsumer (plugin)
-3) The response is sent back on the message bus in plugin_alarm.py using
- response functions in producer.py(/core/message-bus)
-4) The response is then again consumed by the unit_tests_alarms.py
- and the test cases has been applied on the response.
-'''
-
-class config_alarm_name_test(unittest.TestCase):
-
-
- def setUp(self):
- pass
- #To generate a request of testing new alarm name and new instance id in create alarm request
- def test_differentName_differentInstance(self):
- time.sleep(2)
- producer.request("test_schemas/create_alarm/create_alarm_differentName_differentInstance.json",'create_alarm_request', '','alarm_request')
- server = {'server': 'localhost:9092', 'topic': 'alarm_request'}
-
- _consumer = KafkaConsumer(bootstrap_servers=server['server'])
- _consumer.subscribe(['alarm_response'])
-
- for message in _consumer:
- if message.key == "create_alarm_response":
- info = json.loads(json.loads(message.value))
- print(info)
- time.sleep(1)
- self.assertTrue(info['alarm_create_response']['status'])
- return
-
- #To generate a request of testing new alarm name and existing instance id in create alarm request
- def test_differentName_sameInstance(self):
- time.sleep(2)
- producer.request("test_schemas/create_alarm/create_alarm_differentName_sameInstance.json",'create_alarm_request', '','alarm_request')
- server = {'server': 'localhost:9092', 'topic': 'alarm_request'}
-
- _consumer = KafkaConsumer(bootstrap_servers=server['server'])
- _consumer.subscribe(['alarm_response'])
-
- for message in _consumer:
- if message.key == "create_alarm_response":
- info = json.loads(json.loads(message.value))
- print(info)
- time.sleep(1)
- producer.request("test_schemas/delete_alarm/name_valid_delete1.json",'delete_alarm_request','','alarm_request')
- self.assertTrue(info['alarm_create_response']['status'])
- return
-
- #To generate a request of testing existing alarm name and new instance id in create alarm request
- def test_sameName_differentInstance(self):
- time.sleep(2)
- producer.request("test_schemas/create_alarm/create_alarm_sameName_differentInstance.json",'create_alarm_request', '','alarm_request')
- server = {'server': 'localhost:9092', 'topic': 'alarm_request'}
-
- _consumer = KafkaConsumer(bootstrap_servers=server['server'])
- _consumer.subscribe(['alarm_response'])
-
- for message in _consumer:
- if message.key == "create_alarm_response":
- info = json.loads(json.loads(message.value))
- print(info)
- time.sleep(1)
- producer.request("test_schemas/delete_alarm/name_valid_delete2.json",'delete_alarm_request', '','alarm_request')
- self.assertTrue(info['alarm_create_response']['status'])
- return
-
- #To generate a request of testing existing alarm name and existing instance id in create alarm request
- def test_sameName_sameInstance(self):
- time.sleep(2)
- producer.request("test_schemas/create_alarm/create_alarm_sameName_sameInstance.json",'create_alarm_request', '','alarm_request')
- server = {'server': 'localhost:9092', 'topic': 'alarm_request'}
-
- _consumer = KafkaConsumer(bootstrap_servers=server['server'])
- _consumer.subscribe(['alarm_response'])
-
- for message in _consumer:
- if message.key == "create_alarm_response":
- info = json.loads(json.loads(message.value))
- print(info, "---")
- time.sleep(1)
- producer.request("test_schemas/delete_alarm/name_valid.json",'delete_alarm_request', '','alarm_request')
- self.assertEqual(info, None)
- return
-
- #To generate a request of testing valid statistics in create alarm request
- def test_statisticValid(self):
- time.sleep(2)
- producer.request("test_schemas/create_alarm/statistic_valid.json",'create_alarm_request', '','alarm_request')
- server = {'server': 'localhost:9092', 'topic': 'alarm_request'}
-
- _consumer = KafkaConsumer(bootstrap_servers=server['server'])
- _consumer.subscribe(['alarm_response'])
-
- for message in _consumer:
- if message.key == "create_alarm_response":
- info = json.loads(json.loads(message.value))
- print(info)
- time.sleep(1)
- producer.request("test_schemas/delete_alarm/name_valid_delete3.json",'delete_alarm_request', '','alarm_request')
- self.assertTrue(info['alarm_create_response']['status'])
- return
-
- #To generate a request of testing Invalid statistics in create alarm request
- def test_statisticValidNot(self):
- time.sleep(2)
- producer.request("test_schemas/create_alarm/statistic_invalid.json",'create_alarm_request', '','alarm_request')
- server = {'server': 'localhost:9092', 'topic': 'alarm_request'}
-
- _consumer = KafkaConsumer(bootstrap_servers=server['server'])
- _consumer.subscribe(['alarm_response'])
-
- for message in _consumer:
- if message.key == "create_alarm_response":
- info = json.loads(json.loads(message.value))
- print(info, "---")
- time.sleep(1)
- producer.request("test_schemas/delete_alarm/name_valid_delete3.json",'delete_alarm_request', '','alarm_request')
- self.assertEqual(info, None)
- return
-
- #To generate a request of testing valid operation in create alarm request
- def test_operationValid(self):
- time.sleep(2)
- producer.request("test_schemas/create_alarm/operation_valid.json",'create_alarm_request', '','alarm_request')
- server = {'server': 'localhost:9092', 'topic': 'alarm_request'}
-
- _consumer = KafkaConsumer(bootstrap_servers=server['server'])
- _consumer.subscribe(['alarm_response'])
-
- for message in _consumer:
- if message.key == "create_alarm_response":
- info = json.loads(json.loads(message.value))
- print(info)
- time.sleep(1)
- producer.request("test_schemas/delete_alarm/name_valid_delete3.json",'delete_alarm_request', '','alarm_request')
- self.assertTrue(info['alarm_create_response']['status'])
- return
-
- #To generate a request of testing Invalid operation in create alarm request
- def test_operationValidNot(self):
- time.sleep(2)
- producer.request("test_schemas/create_alarm/operation_invalid.json",'create_alarm_request', '','alarm_request')
- server = {'server': 'localhost:9092', 'topic': 'alarm_request'}
-
- _consumer = KafkaConsumer(bootstrap_servers=server['server'])
- _consumer.subscribe(['alarm_response'])
-
- for message in _consumer:
- if message.key == "create_alarm_response":
- info = json.loads(json.loads(message.value))
- print(info)
- time.sleep(1)
- self.assertEqual(info,None)
- return
-
-
-#--------------------------------------------------------------------------------------------------------------------------------------
-class update_alarm_name_test(unittest.TestCase):
-
- #To generate a request of testing valid alarm_id in update alarm request
- def test_nameValid(self):
- producer.request("test_schemas/update_alarm/update_alarm_new_alarm.json",'create_alarm_request', '','alarm_request')
- time.sleep(2)
- producer.request("test_schemas/update_alarm/name_valid.json",'update_alarm_request', '','alarm_request')
- server = {'server': 'localhost:9092', 'topic': 'alarm_request'}
-
- _consumer = KafkaConsumer(bootstrap_servers=server['server'])
- _consumer.subscribe(['alarm_response'])
-
- for message in _consumer:
- if message.key == "update_alarm_response":
- info = json.loads(json.loads(json.loads(message.value)))
- print(info)
- time.sleep(1)
- producer.request("test_schemas/delete_alarm/name_valid_delete4.json",'delete_alarm_request', '','alarm_request')
- self.assertTrue(info['alarm_update_response']['status'])
- return
-
- #To generate a request of testing invalid alarm_id in update alarm request
- def test_nameInvalid(self):
- time.sleep(2)
- producer.request("test_schemas/update_alarm/name_invalid.json",'update_alarm_request', '','alarm_request')
- server = {'server': 'localhost:9092', 'topic': 'alarm_request'}
-
- _consumer = KafkaConsumer(bootstrap_servers=server['server'])
- _consumer.subscribe(['alarm_response'])
-
- for message in _consumer:
- if message.key == "update_alarm_response":
- info = json.loads(json.loads(json.loads(message.value)))
- print(info)
- time.sleep(1)
- self.assertEqual(info,None)
- return
-
- #To generate a request of testing valid statistics in update alarm request
- def test_statisticValid(self):
- producer.request("test_schemas/create_alarm/create_alarm_differentName_differentInstance.json",'create_alarm_request', '','alarm_request')
- time.sleep(2)
- producer.request("test_schemas/update_alarm/statistic_valid.json",'update_alarm_request', '','alarm_request')
- server = {'server': 'localhost:9092', 'topic': 'alarm_request'}
-
- _consumer = KafkaConsumer(bootstrap_servers=server['server'])
- _consumer.subscribe(['alarm_response'])
-
- for message in _consumer:
- if message.key == "update_alarm_response":
- info = json.loads(json.loads(json.loads(message.value)))
- print(info)
- time.sleep(1)
- producer.request("test_schemas/delete_alarm/name_valid.json",'delete_alarm_request', '','alarm_request')
- self.assertTrue(info['alarm_update_response']['status'])
- return
-
- #To generate a request of testing Invalid statistics in update alarm request
- def test_statisticInvalid(self):
- time.sleep(2)
- producer.request("test_schemas/update_alarm/statistic_invalid.json",'update_alarm_request', '','alarm_request')
- server = {'server': 'localhost:9092', 'topic': 'alarm_request'}
-
- _consumer = KafkaConsumer(bootstrap_servers=server['server'])
- _consumer.subscribe(['alarm_response'])
-
- for message in _consumer:
- if message.key == "update_alarm_response":
- info = json.loads(json.loads(json.loads(message.value)))
- print(info)
- time.sleep(1)
- self.assertEqual(info,None)
- return
-
- #To generate a request of testing valid operation in update alarm request
- def test_operationValid(self):
- producer.request("test_schemas/create_alarm/create_alarm_differentName_differentInstance.json",'create_alarm_request', '','alarm_request')
- time.sleep(2)
- producer.request("test_schemas/update_alarm/operation_valid.json",'update_alarm_request', '','alarm_request')
- server = {'server': 'localhost:9092', 'topic': 'alarm_request'}
-
- _consumer = KafkaConsumer(bootstrap_servers=server['server'])
- _consumer.subscribe(['alarm_response'])
-
- for message in _consumer:
- if message.key == "update_alarm_response":
- info = json.loads(json.loads(json.loads(message.value)))
- print(info)
- time.sleep(1)
- producer.request("test_schemas/delete_alarm/name_valid.json",'delete_alarm_request', '','alarm_request')
- self.assertTrue(info['alarm_update_response']['status'])
- return
-
-#--------------------------------------------------------------------------------------------------------------------------------------
-class delete_alarm_test(unittest.TestCase):
-
- #To generate a request of testing valid alarm_id in delete alarm request
- def test_nameValid(self):
- producer.request("test_schemas/create_alarm/create_alarm_differentName_differentInstance.json",'create_alarm_request', '','alarm_request')
- time.sleep(2)
- producer.request("test_schemas/delete_alarm/name_valid.json",'delete_alarm_request', '','alarm_request')
- server = {'server': 'localhost:9092', 'topic': 'alarm_request'}
-
- _consumer = KafkaConsumer(bootstrap_servers=server['server'])
- _consumer.subscribe(['alarm_response'])
-
- for message in _consumer:
- if message.key == "delete_alarm_response":
- info = json.loads(json.loads(json.loads(message.value)))
- print(info)
- time.sleep(1)
- self.assertTrue(info['alarm_deletion_response']['status'])
- return
-
- #To generate a request of testing Invalid alarm_id in delete alarm request
- def test_nameInvalid(self):
- time.sleep(2)
- producer.request("test_schemas/delete_alarm/name_invalid.json",'delete_alarm_request', '','alarm_request')
- server = {'server': 'localhost:9092', 'topic': 'alarm_request'}
-
- _consumer = KafkaConsumer(bootstrap_servers=server['server'])
- _consumer.subscribe(['alarm_response'])
-
- for message in _consumer:
- if message.key == "delete_alarm_response":
- info = json.loads(json.loads(json.loads(message.value)))
- print(info)
- time.sleep(1)
- self.assertEqual(info,None)
- return
-
-#--------------------------------------------------------------------------------------------------------------------------------------
-class list_alarm_test(unittest.TestCase):
-
- #To generate a request of testing valid input fields in alarm list request
- def test_valid_no_arguments(self):
- time.sleep(2)
- producer.request("test_schemas/list_alarm/list_alarm_valid_no_arguments.json",'alarm_list_request', '','alarm_request')
- server = {'server': 'localhost:9092', 'topic': 'alarm_request'}
-
- _consumer = KafkaConsumer(bootstrap_servers=server['server'])
- _consumer.subscribe(['alarm_response'])
-
- for message in _consumer:
- if message.key == "list_alarm_response":
- info = json.loads(json.loads(json.loads(message.value)))
- print(info)
- time.sleep(1)
- self.assertEqual(type(info),dict)
- return
-
- #To generate a request of testing valid input fields in alarm list request
- def test_valid_one_arguments(self):
- time.sleep(2)
- producer.request("test_schemas/list_alarm/list_alarm_valid_one_arguments.json",'alarm_list_request', '','alarm_request')
- server = {'server': 'localhost:9092', 'topic': 'alarm_request'}
-
- _consumer = KafkaConsumer(bootstrap_servers=server['server'])
- _consumer.subscribe(['alarm_response'])
-
- for message in _consumer:
- if message.key == "list_alarm_response":
- info = json.loads(json.loads(json.loads(message.value)))
- print(info)
- time.sleep(1)
- self.assertEqual(type(info),dict)
- return
-
- #To generate a request of testing valid input fields in alarm list request
- def test_valid_two_arguments(self):
- time.sleep(2)
- producer.request("test_schemas/list_alarm/list_alarm_valid_two_arguments.json",'alarm_list_request', '','alarm_request')
- server = {'server': 'localhost:9092', 'topic': 'alarm_request'}
-
- _consumer = KafkaConsumer(bootstrap_servers=server['server'])
- _consumer.subscribe(['alarm_response'])
-
- for message in _consumer:
- if message.key == "list_alarm_response":
- info = json.loads(json.loads(json.loads(message.value)))
- print(info)
- time.sleep(1)
- self.assertEqual(type(info),dict)
- return
-
-
-#--------------------------------------------------------------------------------------------------------------------------------------
-class alarm_details_test(unittest.TestCase):
-
- #To generate a request of testing valid input fields in acknowledge alarm
- def test_Valid(self):
- time.sleep(2)
- producer.request("test_schemas/alarm_details/acknowledge_alarm.json",'acknowledge_alarm', '','alarm_request')
- server = {'server': 'localhost:9092', 'topic': 'alarm_request'}
-
- _consumer = KafkaConsumer(bootstrap_servers=server['server'])
- _consumer.subscribe(['alarm_response'])
-
- for message in _consumer:
- if message.key == "notify_alarm":
- info = json.loads(json.loads(json.loads(message.value)))
- print(info)
- time.sleep(1)
- self.assertEqual(type(info),dict)
- return
-
-if __name__ == '__main__':
-
- # Saving test reults in Log file
-
- log_file = 'log_file.txt'
- f = open(log_file, "w")
- runner = unittest.TextTestRunner(f)
- unittest.main(testRunner=runner)
- f.close()
-
- # For printing results on Console
- # unittest.main()
+++ /dev/null
-from connection import Connection
-import unittest
-import sys
-import jsmin
-import json
-import os
-import time
-from jsmin import jsmin
-sys.path.append("../../test/core/")
-from test_producer import KafkaProducer
-from kafka import KafkaConsumer
-try:
- import boto
- import boto.ec2
- import boto.vpc
- import boto.ec2.cloudwatch
- import boto.ec2.connection
-except:
- exit("Boto not avialable. Try activating your virtualenv OR `pip install boto`")
-
-#--------------------------------------------------------------------------------------------------------------------------------------
-
-# Test Producer object to generate request
-
-producer = KafkaProducer('')
-obj = Connection()
-connections = obj.setEnvironment()
-connections_res = obj.connection_instance()
-cloudwatch_conn = connections_res['cloudwatch_connection']
-
-# Consumer Object to consume response from message bus
-server = {'server': 'localhost:9092', 'topic': 'metric_request'}
-_consumer = KafkaConsumer(bootstrap_servers=server['server'])
-_consumer.subscribe(['metric_response'])
-
-#--------------------------------------------------------------------------------------------------------------------------------------
-
-'''Test E2E Flow : Test cases has been tested one at a time.
-1) Commom Request is generated using request function in test_producer.py(/core/message-bus)
-2) The request is then consumed by the comsumer (plugin)
-3) The response is sent back on the message bus in plugin_metrics.py using
- response functions in producer.py(/core/message-bus)
-4) The response is then again consumed by the unit_tests_metrics.py
- and the test cases has been applied on the response.
-'''
-class test_create_metrics(unittest.TestCase):
-
- def test_status_positive(self):
- time.sleep(2)
- # To generate Request of testing valid meric_name in create metrics requests
- producer.request("create_metrics/create_metric_req_valid.json",'create_metric_request', '','metric_request')
-
- for message in _consumer:
- if message.key == "create_metric_response":
- resp = json.loads(json.loads(json.loads(message.value)))
- time.sleep(1)
- self.assertTrue(resp['metric_create_response']['status'])
- self.assertEqual(resp['metric_create_response']['metric_uuid'],0)
- return
-
- def test_status_negative(self):
- time.sleep(2)
- # To generate Request of testing invalid meric_name in create metrics requests
- producer.request("create_metrics/create_metric_req_invalid.json",'create_metric_request', '','metric_request')
-
- for message in _consumer:
- if message.key == "create_metric_response":
- resp = json.loads(json.loads(json.loads(message.value)))
- time.sleep(1)
- self.assertFalse(resp['metric_create_response']['status'])
- self.assertEqual(resp['metric_create_response']['metric_uuid'],None)
- return
-
-class test_metrics_data(unittest.TestCase):
-
- def test_met_name_positive(self):
- time.sleep(2)
- # To generate Request of testing valid meric_name in read_metric_data_request
- producer.request("read_metrics_data/read_metric_name_req_valid.json",'read_metric_data_request', '','metric_request')
- for message in _consumer:
- if message.key == "read_metric_data_response":
- resp = json.loads(json.loads(json.loads(message.value)))
- time.sleep(1)
- self.assertEqual(type(resp['metrics_data']),dict)
- return
-
- def test_met_name_negative(self):
- time.sleep(2)
- # To generate Request of testing invalid meric_name in read_metric_data_request
- producer.request("read_metrics_data/read_metric_name_req_invalid.json",'read_metric_data_request', '','metric_request')
- for message in _consumer:
- if message.key == "read_metric_data_response":
- resp = json.loads(json.loads(json.loads(message.value)))
- time.sleep(1)
- self.assertFalse(resp['metrics_data'])
- return
-
- def test_coll_period_positive(self):
- # To generate Request of testing valid collection_period in read_metric_data_request
- # For AWS metric_data_stats collection period should be a multiple of 60
- time.sleep(2)
- producer.request("read_metrics_data/read_coll_period_req_valid.json",'read_metric_data_request', '','metric_request')
- for message in _consumer:
- if message.key == "read_metric_data_response":
- resp = json.loads(json.loads(json.loads(message.value)))
- time.sleep(1)
- self.assertEqual(type(resp),dict)
- return
-
- def test_coll_period_negative(self):
- time.sleep(2)
- # To generate Request of testing invalid collection_period in read_metric_data_request
- producer.request("read_metrics_data/read_coll_period_req_invalid.json",'read_metric_data_request', '','metric_request')
- for message in _consumer:
- if message.key == "read_metric_data_response":
- resp = json.loads(json.loads(json.loads(message.value)))
- time.sleep(1)
- self.assertFalse(resp['metrics_data'])
- return
-
-class test_update_metrics(unittest.TestCase):
-
- def test_upd_status_positive(self):
- time.sleep(2)
- # To generate Request of testing valid meric_name in update metrics requests
- producer.request("update_metrics/update_metric_req_valid.json",'update_metric_request', '','metric_request')
- for message in _consumer:
- if message.key == "update_metric_response":
- resp = json.loads(json.loads(json.loads(message.value)))
- time.sleep(1)
- self.assertTrue(resp['metric_update_response']['status'])
- self.assertEqual(resp['metric_update_response']['metric_uuid'],0)
- return
-
- def test_upd_status_negative(self):
- time.sleep(2)
- # To generate Request of testing invalid meric_name in update metrics requests
- producer.request("update_metrics/update_metric_req_invalid.json",'update_metric_request', '','metric_request')
- for message in _consumer:
- if message.key == "update_metric_response":
- resp = json.loads(json.loads(json.loads(message.value)))
- time.sleep(1)
- self.assertFalse(resp['metric_update_response']['status'])
- self.assertEqual(resp['metric_update_response']['metric_uuid'],None)
- return
-
-class test_delete_metrics(unittest.TestCase):
-
- def test_del_met_name_positive(self):
- time.sleep(2)
- # To generate Request of testing valid meric_name in delete metrics requests
- producer.request("delete_metrics/delete_metric_req_valid.json",'delete_metric_request', '','metric_request')
- for message in _consumer:
- if message.key == "delete_metric_response":
- resp = json.loads(json.loads(json.loads(message.value)))
- time.sleep(1)
- self.assertFalse(resp['status'])
- return
-
- def test_del_met_name_negative(self):
- time.sleep(2)
- # To generate Request of testing invalid meric_name in delete metrics requests
- producer.request("delete_metrics/delete_metric_req_invalid.json",'delete_metric_request', '','metric_request')
- for message in _consumer:
- if message.key == "delete_metric_response":
- resp = json.loads(json.loads(json.loads(message.value)))
- time.sleep(1)
- self.assertFalse(resp)
- return
-
-class test_list_metrics(unittest.TestCase):
-
- def test_list_met_name_positive(self):
- time.sleep(2)
- # To generate Request of testing valid meric_name in list metrics requests
- producer.request("list_metrics/list_metric_req_valid.json",'list_metric_request', '','metric_request')
- for message in _consumer:
- if message.key == "list_metrics_response":
- resp = json.loads(json.loads(json.loads(message.value)))
- time.sleep(1)
- self.assertEqual(type(resp['metrics_list']),list)
- return
-
- def test_list_met_name_negitive(self):
- time.sleep(2)
- # To generate Request of testing invalid meric_name in list metrics requests
- producer.request("list_metrics/list_metric_req_invalid.json",'list_metric_request', '','metric_request')
- for message in _consumer:
- if message.key == "list_metrics_response":
- resp = json.loads(json.loads(json.loads(message.value)))
- time.sleep(1)
- self.assertFalse(resp['metrics_list'])
- return
-
-
-if __name__ == '__main__':
-
- # Saving test reults in Log file
-
- log_file = 'log_file.txt'
- f = open(log_file, "w")
- runner = unittest.TextTestRunner(f)
- unittest.main(testRunner=runner)
- f.close()
-
- # For printing results on Console
- # unittest.main()
-
+++ /dev/null
-# Copyright 2017 Intel Research and Development Ireland Limited
-# *************************************************************
-
-# This file is part of OSM Monitoring module
-# All Rights Reserved to Intel Corporation
-
-# 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: helena.mcgough@intel.com or adrian.hoban@intel.com
-##
+++ /dev/null
-# -*- 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
-import sys
-
-from osm_mon.core.settings import Config
-
-cfg = Config.instance()
-logging.basicConfig(stream=sys.stdout,
- format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
- datefmt='%m/%d/%Y %I:%M:%S %p',
- level=logging.getLevelName(cfg.OSMMON_LOG_LEVEL))
-log = logging.getLogger(__name__)
+++ /dev/null
-# Copyright 2017 Intel Research and Development Ireland Limited
-# *************************************************************
-
-# This file is part of OSM Monitoring module
-# All Rights Reserved to Intel Corporation
-
-# 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: helena.mcgough@intel.com or adrian.hoban@intel.com
-
-# __author__ = "Helena McGough"
-"""Test an end to end Openstack alarm requests."""
-
-import json
-import logging
-import unittest
-
-import mock
-from kafka import KafkaConsumer
-from kafka import KafkaProducer
-from kafka.errors import KafkaError
-
-from osm_mon.core.auth import AuthManager
-from osm_mon.core.database import DatabaseManager, VimCredentials
-from osm_mon.plugins.OpenStack import response
-from osm_mon.plugins.OpenStack.Aodh import alarm_handler
-from osm_mon.plugins.OpenStack.common import Common
-
-log = logging.getLogger(__name__)
-
-mock_creds = VimCredentials()
-mock_creds.config = '{}'
-
-
-@mock.patch.object(DatabaseManager, "save_alarm", mock.Mock())
-@mock.patch.object(Common, "get_auth_token", mock.Mock())
-@mock.patch.object(Common, "get_endpoint", mock.Mock())
-class AlarmIntegrationTest(unittest.TestCase):
- def setUp(self):
- try:
- self.producer = KafkaProducer(bootstrap_servers='localhost:9092',
- key_serializer=str.encode,
- value_serializer=str.encode
- )
- self.req_consumer = KafkaConsumer(bootstrap_servers='localhost:9092',
- key_deserializer=bytes.decode,
- value_deserializer=bytes.decode,
- auto_offset_reset='earliest',
- consumer_timeout_ms=60000)
- self.req_consumer.subscribe(['alarm_request'])
- except KafkaError:
- self.skipTest('Kafka server not present.')
- # Set up common and alarming class instances
- self.alarms = alarm_handler.OpenstackAlarmHandler()
- self.openstack_auth = Common()
-
- def tearDown(self):
- self.producer.close()
- self.req_consumer.close()
-
- @mock.patch.object(Common, "perform_request")
- @mock.patch.object(AuthManager, 'get_credentials')
- @mock.patch.object(alarm_handler.OpenstackAlarmHandler, "update_alarm")
- @mock.patch.object(response.OpenStackResponseBuilder, "generate_response")
- def test_update_alarm_req(self, resp, update_alarm, get_creds, perf_req):
- """Test Aodh update alarm request message from KafkaProducer."""
- # Set-up message, producer and consumer for tests
- payload = {"alarm_update_request": {"correlation_id": 123,
- "alarm_uuid": "alarm_id",
- "metric_uuid": "metric_id"}}
-
- get_creds.return_value = mock_creds
- perf_req.return_value = type('obj', (object,), {'text': json.dumps({"metrics": {"cpu_util": "1"}})})
- resp.return_value = ''
-
- self.producer.send('alarm_request', key="update_alarm_request",
- value=json.dumps(payload))
-
- for message in self.req_consumer:
- if message.key == "update_alarm_request":
- # Mock a valid alarm update
- update_alarm.return_value = "alarm_id"
- self.alarms.handle_message(message, 'test_id')
-
- # 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)
-
- return
- self.fail("No message received in consumer")
-
- @mock.patch.object(Common, "perform_request")
- @mock.patch.object(AuthManager, 'get_credentials')
- @mock.patch.object(alarm_handler.OpenstackAlarmHandler, "configure_alarm")
- @mock.patch.object(response.OpenStackResponseBuilder, "generate_response")
- def test_create_alarm_req(self, resp, config_alarm, get_creds, perf_req):
- """Test Aodh create alarm request message from KafkaProducer."""
- # Set-up message, producer and consumer for tests
- payload = {"alarm_create_request": {"correlation_id": 123,
- "alarm_name": "my_alarm",
- "metric_name": "cpu_utilization",
- "resource_uuid": "my_resource",
- "severity": "WARNING",
- "threshold_value": 60,
- "operation": "GT",
- "vdu_name": "vdu",
- "vnf_member_index": "1",
- "ns_id": "1"}}
-
- get_creds.return_value = mock_creds
- perf_req.return_value = type('obj', (object,), {'text': json.dumps({"metrics": {"cpu_util": "1"}})})
- resp.return_value = ''
- self.producer.send('alarm_request', key="create_alarm_request",
- value=json.dumps(payload))
-
- for message in self.req_consumer:
- if message.key == "create_alarm_request":
- # Mock a valid alarm creation
- config_alarm.return_value = "alarm_id"
- self.alarms.handle_message(message, 'test_id')
-
- # 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)
-
- return
- self.fail("No message received in consumer")
-
- @mock.patch.object(Common, "perform_request")
- @mock.patch.object(AuthManager, 'get_credentials')
- @mock.patch.object(alarm_handler.OpenstackAlarmHandler, "list_alarms")
- @mock.patch.object(response.OpenStackResponseBuilder, "generate_response")
- def test_list_alarm_req(self, resp, list_alarm, get_creds, perf_req):
- """Test Aodh list alarm request message from KafkaProducer."""
- # Set-up message, producer and consumer for tests
- payload = {"alarm_list_request": {"correlation_id": 123,
- "resource_uuid": "resource_id", }}
-
- self.producer.send('alarm_request', key="list_alarm_request",
- value=json.dumps(payload))
-
- get_creds.return_value = mock_creds
- perf_req.return_value = type('obj', (object,), {'text': json.dumps([])})
- resp.return_value = ''
-
- for message in self.req_consumer:
- if message.key == "list_alarm_request":
- # Mock an empty list generated by the request
- list_alarm.return_value = []
- self.alarms.handle_message(message, 'test_id')
-
- # Response message is generated
- resp.assert_called_with(
- 'list_alarm_response', alarm_list=[],
- cor_id=123)
-
- return
- self.fail("No message received in consumer")
-
- @mock.patch.object(Common, "perform_request")
- @mock.patch.object(AuthManager, 'get_credentials')
- @mock.patch.object(alarm_handler.OpenstackAlarmHandler, "delete_alarm")
- @mock.patch.object(response.OpenStackResponseBuilder, "generate_response")
- def test_delete_alarm_req(self, resp, del_alarm, get_creds, perf_req):
- """Test Aodh delete alarm request message from KafkaProducer."""
- # Set-up message, producer and consumer for tests
- payload = {"alarm_delete_request": {"correlation_id": 123,
- "alarm_uuid": "alarm_id", }}
-
- self.producer.send('alarm_request', key="delete_alarm_request",
- value=json.dumps(payload))
-
- get_creds.return_value = mock_creds
- perf_req.return_value = type('obj', (object,), {'text': json.dumps([])})
- resp.return_value = ''
-
- for message in self.req_consumer:
- if message.key == "delete_alarm_request":
- self.alarms.handle_message(message, 'test_id')
-
- # Response message is generated and sent by MON's producer
- resp.assert_called_with(
- 'delete_alarm_response', alarm_id="alarm_id",
- status=True, cor_id=123)
-
- return
- self.fail("No message received in consumer")
-
- @mock.patch.object(AuthManager, 'get_credentials')
- @mock.patch.object(alarm_handler.OpenstackAlarmHandler, "update_alarm_state")
- def test_ack_alarm_req(self, ack_alarm, get_creds):
- """Test Aodh acknowledge alarm request message from KafkaProducer."""
- # Set-up message, producer and consumer for tests
- payload = {"ack_details": {"alarm_uuid": "alarm_id", }}
-
- self.producer.send('alarm_request', key="acknowledge_alarm",
- value=json.dumps(payload))
-
- get_creds.return_value = mock_creds
- ack_alarm.return_value = True
-
- for message in self.req_consumer:
- if message.key == "acknowledge_alarm":
- self.alarms.handle_message(message, 'test_id')
- ack_alarm.assert_called_with(mock.ANY, mock.ANY, 'alarm_id', True)
- return
-
- self.fail("No message received in consumer")
+++ /dev/null
-# Copyright 2017 Intel Research and Development Ireland Limited
-# *************************************************************
-
-# This file is part of OSM Monitoring module
-# All Rights Reserved to Intel Corporation
-
-# 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: helena.mcgough@intel.com or adrian.hoban@intel.com
-
-# __author__ = "Helena McGough"
-"""Test an end to end Openstack metric requests."""
-
-import json
-
-import logging
-import unittest
-
-from kafka.errors import KafkaError
-
-from osm_mon.core.auth import AuthManager
-from osm_mon.core.database import VimCredentials
-
-from kafka import KafkaConsumer
-from kafka import KafkaProducer
-
-import mock
-
-from osm_mon.plugins.OpenStack import response
-
-from osm_mon.plugins.OpenStack.Gnocchi import metric_handler
-
-from osm_mon.plugins.OpenStack.common import Common
-
-log = logging.getLogger(__name__)
-
-mock_creds = VimCredentials()
-mock_creds.config = '{}'
-
-
-@mock.patch.object(Common, "get_auth_token", mock.Mock())
-@mock.patch.object(Common, "get_endpoint", mock.Mock())
-class MetricIntegrationTest(unittest.TestCase):
- def setUp(self):
- # Set up common and alarming class instances
- self.metric_req = metric_handler.OpenstackMetricHandler()
- self.openstack_auth = Common()
-
- try:
- self.producer = KafkaProducer(bootstrap_servers='localhost:9092',
- key_serializer=str.encode,
- value_serializer=str.encode
- )
- self.req_consumer = KafkaConsumer(bootstrap_servers='localhost:9092',
- key_deserializer=bytes.decode,
- value_deserializer=bytes.decode,
- auto_offset_reset='earliest',
- consumer_timeout_ms=60000)
- self.req_consumer.subscribe(['metric_request'])
- except KafkaError:
- self.skipTest('Kafka server not present.')
-
- @mock.patch.object(Common, "perform_request")
- @mock.patch.object(AuthManager, 'get_credentials')
- @mock.patch.object(metric_handler.OpenstackMetricHandler, "configure_metric")
- @mock.patch.object(response.OpenStackResponseBuilder, "generate_response")
- def test_create_metric_req(self, resp, config_metric, get_creds, perf_req):
- """Test Gnocchi create metric request message from producer."""
- # Set-up message, producer and consumer for tests
- payload = {"metric_create_request": {"correlation_id": 123,
- "metric_name": "cpu_utilization",
- "resource_uuid": "resource_id"}}
-
- get_creds.return_value = mock_creds
- perf_req.return_value = type('obj', (object,), {'text': json.dumps({"metrics": {"cpu_util": "1"}})})
- resp.return_value = ''
-
- self.producer.send('metric_request', key="create_metric_request",
- value=json.dumps(payload))
-
- for message in self.req_consumer:
- if message.key == "create_metric_request":
- # A valid metric is created
- config_metric.return_value = "metric_id", "resource_id"
- self.metric_req.handle_request(message, 'test_id')
-
- # 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", resource_id="resource_id")
-
- return
- self.fail("No message received in consumer")
-
- @mock.patch.object(Common, "perform_request")
- @mock.patch.object(AuthManager, 'get_credentials')
- @mock.patch.object(metric_handler.OpenstackMetricHandler, "delete_metric")
- @mock.patch.object(response.OpenStackResponseBuilder, "generate_response")
- def test_delete_metric_req(self, resp, del_metric, get_creds, perf_req):
- """Test Gnocchi delete metric request message from producer."""
- # Set-up message, producer and consumer for tests
- payload = {"vim_type": "OpenSTACK",
- "vim_uuid": "1",
- "correlation_id": 123,
- "metric_name": "cpu_utilization",
- "resource_uuid": "resource_id"}
-
- get_creds.return_value = mock_creds
- perf_req.return_value = type('obj', (object,), {'text': json.dumps({"metrics": {"cpu_util": "1"}})})
- resp.return_value = ''
-
- self.producer.send('metric_request', key="delete_metric_request",
- value=json.dumps(payload))
-
- for message in self.req_consumer:
- if message.key == "delete_metric_request":
- # Metric has been deleted
- del_metric.return_value = True
- self.metric_req.handle_request(message, 'test_id')
-
- # A response message is generated and sent by MON's producer
- resp.assert_called_with(
- 'delete_metric_response', metric_id='1',
- metric_name="cpu_utilization", status=True, resource_id="resource_id",
- cor_id=123)
-
- return
- self.fail("No message received in consumer")
-
- @mock.patch.object(Common, "perform_request")
- @mock.patch.object(AuthManager, 'get_credentials')
- @mock.patch.object(metric_handler.OpenstackMetricHandler, "read_metric_data")
- @mock.patch.object(response.OpenStackResponseBuilder, "generate_response")
- def test_read_metric_data_req(self, resp, read_data, get_creds, perf_req):
- """Test Gnocchi read metric data request message from producer."""
- # Set-up message, producer and consumer for tests
- payload = {"vim_type": "OpenSTACK",
- "vim_uuid": "test_id",
- "correlation_id": 123,
- "metric_name": "cpu_utilization",
- "resource_uuid": "resource_id"}
-
- get_creds.return_value = mock_creds
- perf_req.return_value = type('obj', (object,), {'text': json.dumps({"metrics": {"cpu_util": "1"}})})
- resp.return_value = ''
-
- self.producer.send('metric_request', key="read_metric_data_request",
- value=json.dumps(payload))
-
- for message in self.req_consumer:
- # Check the vim desired by the message
- if message.key == "read_metric_data_request":
- # Mock empty lists generated by the request message
- read_data.return_value = [], []
- self.metric_req.handle_request(message, 'test_id')
-
- # A response message is generated and sent by MON's producer
- resp.assert_called_with(
- 'read_metric_data_response', metric_id='1',
- metric_name="cpu_utilization", resource_id="resource_id", cor_id=123, times=[],
- metrics=[], status=True)
-
- return
- self.fail("No message received in consumer")
-
- @mock.patch.object(Common, "perform_request")
- @mock.patch.object(AuthManager, 'get_credentials')
- @mock.patch.object(metric_handler.OpenstackMetricHandler, "list_metrics")
- @mock.patch.object(response.OpenStackResponseBuilder, "generate_response")
- def test_list_metrics_req(self, resp, list_metrics, get_creds, perf_req):
- """Test Gnocchi list metrics request message from producer."""
- # Set-up message, producer and consumer for tests
- payload = {"vim_type": "OpenSTACK",
- "vim_uuid": "1",
- "metrics_list_request":
- {"correlation_id": 123, }}
-
- get_creds.return_value = mock_creds
- perf_req.return_value = type('obj', (object,), {'text': json.dumps({"metrics": {"cpu_util": "1"}})})
- resp.return_value = ''
-
- 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
- if message.key == "list_metric_request":
- # Mock an empty list generated by the request
- list_metrics.return_value = []
- self.metric_req.handle_request(message, 'test_id')
-
- # A response message is generated and sent by MON's producer
- resp.assert_called_with(
- 'list_metric_response', metric_list=[], cor_id=123, status=True)
-
- return
- self.fail("No message received in consumer")
-
- @mock.patch.object(Common, "perform_request")
- @mock.patch.object(AuthManager, 'get_credentials')
- @mock.patch.object(metric_handler.OpenstackMetricHandler, "get_metric_id")
- @mock.patch.object(response.OpenStackResponseBuilder, "generate_response")
- def test_update_metrics_req(self, resp, get_id, get_creds, perf_req):
- """Test Gnocchi update metric request message from KafkaProducer."""
- # Set-up message, producer and consumer for tests
- payload = {"metric_update_request": {"metric_name": "my_metric",
- "correlation_id": 123,
- "resource_uuid": "resource_id", }}
-
- get_creds.return_value = mock_creds
- perf_req.return_value = type('obj', (object,), {'text': json.dumps({"metrics": {"cpu_util": "1"}})})
- resp.return_value = ''
-
- self.producer.send('metric_request', key="update_metric_request",
- value=json.dumps(payload))
-
- for message in self.req_consumer:
- # Check the vim desired by the message
- if message.key == "update_metric_request":
- # Gnocchi doesn't support metric updates
- get_id.return_value = "metric_id"
- self.metric_req.handle_request(message, 'test_id')
-
- # Response 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,
- resource_id="resource_id", metric_id="metric_id")
-
- return
- self.fail("No message received in consumer")
+++ /dev/null
-# Copyright 2017 Intel Research and Development Ireland Limited
-# *************************************************************
-
-# This file is part of OSM Monitoring module
-# All Rights Reserved to Intel Corporation
-
-# 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: helena.mcgough@intel.com or adrian.hoban@intel.com
-##
-"""Tests for all common OpenStack methods."""
-
-from __future__ import unicode_literals
-import json
-import logging
-import socket
-import unittest
-from threading import Thread
-
-import mock
-import requests
-from kafka import KafkaProducer
-from six.moves.BaseHTTPServer import BaseHTTPRequestHandler
-from six.moves.BaseHTTPServer import HTTPServer
-
-from osm_mon.core.settings import Config
-from osm_mon.plugins.OpenStack.Aodh.alarm_handler import OpenstackAlarmHandler
-from osm_mon.plugins.OpenStack.common import Common
-from osm_mon.plugins.OpenStack.response import OpenStackResponseBuilder
-
-log = logging.getLogger(__name__)
-
-# Create an instance of the common openstack class, producer and consumer
-openstack_auth = Common()
-
-# Mock a valid get_response for alarm details
-valid_get_resp = '{"gnocchi_resources_threshold_rule":\
- {"resource_id": "my_resource_id"}}'
-
-
-class MockResponse(object):
- """Mock a response class for generating responses."""
-
- def __init__(self, text):
- """Initialise a mock response with a text attribute."""
- self.text = text
-
-
-class MockNotifierHandler(BaseHTTPRequestHandler):
- """Mock the NotifierHandler class for testing purposes."""
-
- def _set_headers(self):
- """Set the headers for a request."""
- self.send_response(200)
- self.send_header('Content-type', 'text/html')
- self.end_headers()
-
- def do_GET(self):
- """Mock functionality for GET request."""
- # self.send_response(requests.codes.ok)
- self._set_headers()
- pass
-
- def do_POST(self):
- """Mock functionality for a POST request."""
- self._set_headers()
- content_length = int(self.headers['Content-Length'])
- post_data = self.rfile.read(content_length)
- try:
- post_data = post_data.decode()
- except AttributeError:
- pass
- self.notify_alarm(json.loads(post_data))
-
- def notify_alarm(self, values):
- """Mock the notify_alarm functionality to generate a valid response."""
- cfg = Config.instance()
- self._alarming = OpenstackAlarmHandler()
- self._common = Common()
- self._response = OpenStackResponseBuilder()
- alarm_id = values['alarm_id']
-
- auth_token = Common.get_auth_token('test_id')
- endpoint = Common.get_endpoint('alarming', 'test_id')
-
- # If authenticated generate and send response message
- if auth_token is not None and endpoint is not None:
- url = "{}/v2/alarms/%s".format(endpoint) % alarm_id
-
- # Get the resource_id of the triggered alarm and the date
- result = Common.perform_request(
- url, auth_token, req_type="get")
- alarm_details = json.loads(result.text)
- gnocchi_rule = alarm_details['gnocchi_resources_threshold_rule']
- resource_id = gnocchi_rule['resource_id']
- # Mock a date for testing purposes
- a_date = "dd-mm-yyyy 00:00"
-
- # Process an alarm notification if resource_id is valid
- if resource_id is not None:
- # Try generate and send response
- try:
- resp_message = self._response.generate_response(
- 'notify_alarm',
- alarm_id=alarm_id,
- resource_id=resource_id,
- sev=values['severity'], date=a_date,
- state=values['current'], vim_type="OpenStack")
- except Exception:
- log.exception("Error generating response")
-
-
-def get_free_port():
- """Function to get a free port to run the test webserver on."""
- s = socket.socket(socket.AF_INET, type=socket.SOCK_STREAM)
- s.bind(('localhost', 0))
- address, port = s.getsockname()
- s.close()
- return port
-
-
-# Create the webserver, port and run it on its own thread
-mock_server_port = get_free_port()
-mock_server = HTTPServer(('localhost', mock_server_port), MockNotifierHandler)
-mock_server_thread = Thread(target=mock_server.serve_forever)
-mock_server_thread.setDaemon(True)
-mock_server_thread.start()
-
-
-def test_do_get():
- """Integration test for get request on notifier webserver."""
- url = 'http://localhost:{port}/users'.format(port=mock_server_port)
-
- # Send a request to the mock API server and store the response.
- response = requests.get(url)
-
- # Confirm that the request-response cycle completed successfully.
- assert response.ok
-
-
-class AlarmNotificationTest(unittest.TestCase):
- @mock.patch.object(OpenStackResponseBuilder, "generate_response")
- @mock.patch.object(Common, "perform_request")
- @mock.patch.object(Common, "get_endpoint")
- @mock.patch.object(Common, "get_auth_token")
- def test_post_notify_alarm(self, auth, endpoint, perf_req, resp):
- """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)
-
- # Generate a post request for testing
- response = requests.post(url, json.dumps(payload))
- self.assertEqual(response.status_code, 200)
- # A response message is generated with the following details
- resp.assert_called_with(
- "notify_alarm", alarm_id="my_alarm_id", resource_id="my_resource_id",
- sev="critical", date='dd-mm-yyyy 00:00', state="current_state",
- vim_type="OpenStack")
+++ /dev/null
-# -*- 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 unittest
-
-from peewee import SqliteDatabase
-
-from osm_mon.core import database
-from osm_mon.core.auth import AuthManager
-from osm_mon.core.database import DatabaseManager, VimCredentials, Alarm
-
-log = logging.getLogger(__name__)
-
-test_db = SqliteDatabase(':memory:')
-
-MODELS = [VimCredentials, Alarm]
-
-
-class VimAccountTest(unittest.TestCase):
- def setUp(self):
- super().setUp()
- database.db = test_db
- test_db.bind(MODELS)
- test_db.connect()
- test_db.drop_tables(MODELS)
- test_db.create_tables(MODELS)
- self.auth_manager = AuthManager()
- self.database_manager = DatabaseManager()
- self.database_manager.create_tables()
-
- def tearDown(self):
- super().tearDown()
- test_db.close()
-
- def test_create_edit_delete_vim_account(self):
- """Test vim_account creation message from KafkaProducer."""
- # Set-up message, producer and consumer for tests
- create_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.auth_manager.store_auth_credentials(create_payload)
-
- creds = self.auth_manager.get_credentials('test_id')
-
- self.assertIsNotNone(creds)
- self.assertEqual(creds.name, create_payload['name'])
- self.assertEqual(json.loads(creds.config), create_payload['config'])
-
- # Set-up message, producer and consumer for tests
- edit_payload = {
- "_id": "test_id",
- "name": "test_name_edited",
- "vim_type": "openstack",
- "vim_url": "auth_url",
- "vim_user": "user",
- "vim_password": "password",
- "vim_tenant_name": "tenant",
- "config":
- {
- "foo_edited": "bar_edited"
- }
- }
-
- self.auth_manager.store_auth_credentials(edit_payload)
-
- creds = self.auth_manager.get_credentials('test_id')
-
- self.assertEqual(creds.name, edit_payload['name'])
- self.assertEqual(json.loads(creds.config), edit_payload['config'])
-
- delete_payload = {
- "_id": "test_id"
- }
-
- self.auth_manager.delete_auth_credentials(delete_payload)
-
- creds = self.auth_manager.get_credentials('test_id')
- self.assertIsNone(creds)
+++ /dev/null
-# -*- 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
-import sys
-
-from osm_mon.core.settings import Config
-
-cfg = Config.instance()
-logging.basicConfig(stream=sys.stdout,
- format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
- datefmt='%m/%d/%Y %I:%M:%S %p',
- level=logging.getLevelName(cfg.OSMMON_LOG_LEVEL))
-log = logging.getLogger(__name__)
+++ /dev/null
-# Copyright 2017 iIntel Research and Development Ireland Limited
-# **************************************************************
-
-# This file is part of OSM Monitoring module
-# All Rights Reserved to Intel Corporation
-
-# 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: helena.mcgough@intel.com or adrian.hoban@intel.com
-##
-"""Tests for all alarm request message keys."""
-
-import json
-import logging
-import unittest
-from io import UnsupportedOperation
-
-import mock
-
-from osm_mon.core.auth import AuthManager
-from osm_mon.core.database import VimCredentials, DatabaseManager
-from osm_mon.plugins.OpenStack.Aodh import alarm_handler as alarm_req
-from osm_mon.plugins.OpenStack.Aodh.alarm_handler import OpenstackAlarmHandler
-from osm_mon.plugins.OpenStack.common import Common
-
-log = logging.getLogger(__name__)
-
-mock_creds = VimCredentials()
-mock_creds.config = '{}'
-
-
-class Message(object):
- """A class to mock a message object value for alarm requests."""
-
- def __init__(self):
- """Initialize a mocked message instance."""
- self.topic = 'alarm_request'
- self.key = None
- self.value = json.dumps({'mock_value': 'mock_details'})
-
-
-class TestAlarmKeys(unittest.TestCase):
- """Integration test for alarm request keys."""
-
- def setUp(self):
- """Setup the tests for alarm request keys."""
- super(TestAlarmKeys, self).setUp()
- self.alarming = alarm_req.OpenstackAlarmHandler()
- self.alarming.common = Common()
-
- @mock.patch.object(AuthManager, 'get_credentials')
- @mock.patch.object(Common, 'get_endpoint')
- @mock.patch.object(Common, 'get_auth_token')
- def test_alarming_authentication(self, get_token, get_endpoint, get_creds):
- """Test getting an auth_token and endpoint for alarm requests."""
- # if auth_token is None environment variables are used to authenticate
- get_creds.return_value = mock_creds
-
- with self.assertRaises(UnsupportedOperation):
- self.alarming.handle_message('', {}, 'test_id')
-
- get_token.assert_called_with('test_id', verify_ssl=True)
- get_endpoint.assert_any_call('alarming', 'test_id', verify_ssl=True)
-
- @mock.patch.object(Common, 'get_endpoint', mock.Mock())
- @mock.patch.object(Common, 'get_auth_token', mock.Mock())
- @mock.patch.object(AuthManager, 'get_credentials')
- @mock.patch.object(alarm_req.OpenstackAlarmHandler, 'delete_alarm')
- def test_delete_alarm_key(self, del_alarm, get_creds):
- """Test the functionality for a create alarm request."""
- value = {'alarm_delete_request': {
- 'correlation_id': 1,
- 'alarm_uuid': 'my_alarm_id'
- }}
-
- get_creds.return_value = mock_creds
- del_alarm.return_value = {}
-
- # Call the alarming functionality and check delete request
- self.alarming.handle_message('delete_alarm_request', value, 'test_id')
- del_alarm.assert_called_with(mock.ANY, mock.ANY, 'my_alarm_id', True)
-
- @mock.patch.object(Common, 'get_endpoint', mock.Mock())
- @mock.patch.object(Common, 'get_auth_token', mock.Mock())
- @mock.patch.object(AuthManager, 'get_credentials')
- @mock.patch.object(alarm_req.OpenstackAlarmHandler, 'list_alarms')
- def test_list_alarm_key(self, list_alarm, get_creds):
- """Test the functionality for a list alarm request."""
- value = {'alarm_list_request': {'correlation_id': 1}}
-
- get_creds.return_value = mock_creds
-
- list_alarm.return_value = []
-
- # Call the alarming functionality and check list functionality
- self.alarming.handle_message('list_alarm_request', value, 'test_id')
- list_alarm.assert_called_with(mock.ANY, mock.ANY, {'correlation_id': 1}, True)
-
- @mock.patch.object(Common, 'get_auth_token', mock.Mock())
- @mock.patch.object(Common, 'get_endpoint', mock.Mock())
- @mock.patch.object(AuthManager, 'get_credentials')
- @mock.patch.object(alarm_req.OpenstackAlarmHandler, 'update_alarm_state')
- def test_ack_alarm_key(self, ack_alarm, get_creds):
- """Test the functionality for an acknowledge alarm request."""
- value = {'ack_details': {'alarm_uuid': 'my_alarm_id'}}
-
- get_creds.return_value = mock_creds
-
- # Call alarming functionality and check acknowledge functionality
- self.alarming.handle_message('acknowledge_alarm_request', value, 'test_id')
- ack_alarm.assert_called_with(mock.ANY, mock.ANY, 'my_alarm_id', True)
-
- @mock.patch.object(Common, 'get_auth_token', mock.Mock())
- @mock.patch.object(Common, 'get_endpoint', mock.Mock())
- @mock.patch.object(DatabaseManager, 'save_alarm', mock.Mock())
- @mock.patch.object(Common, "perform_request")
- @mock.patch.object(AuthManager, 'get_credentials')
- @mock.patch.object(alarm_req.OpenstackAlarmHandler, 'configure_alarm')
- def test_config_alarm_key(self, config_alarm, get_creds, perf_req):
- """Test the functionality for a create alarm request."""
- value = {'alarm_create_request': {'correlation_id': 1, 'threshold_value': 50,
- 'operation': 'GT', 'metric_name': 'cpu_utilization',
- 'vdu_name': 'vdu',
- 'vnf_member_index': '1',
- 'ns_id': '1',
- 'resource_uuid': '123'}}
- mock_perf_req_return_value = {"metrics": {"cpu_util": 123}}
- perf_req.return_value = type('obj', (object,), {'text': json.dumps(mock_perf_req_return_value, sort_keys=True)})
- get_creds.return_value = mock_creds
-
- # Call alarming functionality and check config alarm call
- config_alarm.return_value = 'my_alarm_id'
- self.alarming.handle_message('create_alarm_request', value, 'test_id')
- config_alarm.assert_called_with(mock.ANY, mock.ANY, {'correlation_id': 1, 'threshold_value': 50,
- 'operation': 'GT',
- 'metric_name': 'cpu_utilization',
- 'vdu_name': 'vdu',
- 'vnf_member_index': '1', 'ns_id': '1',
- 'resource_uuid': '123'}, {}, True)
+++ /dev/null
-# Copyright 2017 iIntel Research and Development Ireland Limited
-# **************************************************************
-
-# This file is part of OSM Monitoring module
-# All Rights Reserved to Intel Corporation
-
-# 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: helena.mcgough@intel.com or adrian.hoban@intel.com
-##
-"""Tests for all alarm request message keys."""
-
-import json
-import logging
-import unittest
-
-import mock
-
-from osm_mon.core.settings import Config
-from osm_mon.plugins.OpenStack.Aodh import alarm_handler as alarm_req
-from osm_mon.plugins.OpenStack.common import Common
-
-log = logging.getLogger(__name__)
-
-auth_token = mock.ANY
-alarm_endpoint = "alarm_endpoint"
-metric_endpoint = "metric_endpoint"
-
-
-class Response(object):
- """Mock a response message class."""
-
- def __init__(self, result):
- """Initialise the response text and status code."""
- self.text = json.dumps(result)
- self.status_code = "MOCK_STATUS_CODE"
-
-
-class TestAlarming(unittest.TestCase):
- """Tests for alarming class functions."""
-
- maxDiff = None
-
- def setUp(self):
- """Setup for tests."""
- super(TestAlarming, self).setUp()
- self.alarming = alarm_req.OpenstackAlarmHandler()
-
- @mock.patch.object(Common, "perform_request")
- def test_config_invalid_alarm_req(self, perf_req):
- """Test configure an invalid alarm request."""
- # Configuring with invalid metric name results in failure
- values = {"alarm_name": "my_alarm",
- "metric_name": "my_metric",
- "resource_uuid": "my_r_id"}
- with self.assertRaises(KeyError):
- self.alarming.configure_alarm(alarm_endpoint, auth_token, values, {}, True)
- perf_req.assert_not_called()
- perf_req.reset_mock()
-
- # Configuring with missing metric name results in failure
- values = {"alarm_name": "disk_write_ops",
- "resource_uuid": "my_r_id"}
-
- with self.assertRaises(KeyError):
- self.alarming.configure_alarm(alarm_endpoint, auth_token, values, {}, True)
- perf_req.assert_not_called()
-
- @mock.patch.object(Common, "perform_request")
- def test_config_valid_alarm_req(self, perf_req):
- """Test config a valid alarm."""
- values = {"alarm_name": "disk_write_ops",
- "metric_name": "disk_write_ops",
- "resource_uuid": "my_r_id",
- "statistic": "AVERAGE",
- "threshold_value": 60,
- "operation": "GT"}
-
- perf_req.return_value = type('obj', (object,), {'text': '{"alarm_id":"1"}'})
-
- self.alarming.configure_alarm(alarm_endpoint, auth_token, values, {}, True)
- payload = {"name": "disk_write_ops",
- "gnocchi_resources_threshold_rule": {"resource_type": "generic", "comparison_operator": "gt",
- "granularity": 300, "metric": "disk.write.requests",
- "aggregation_method": "mean", "threshold": 60,
- "resource_id": "my_r_id"},
- "alarm_actions": ["http://localhost:8662"], "repeat_actions": True, "state": "ok", "type": "gnocchi_resources_threshold",
- "severity": "critical"}
- perf_req.assert_called_with(
- "alarm_endpoint/v2/alarms/", auth_token,
- req_type="post", payload=json.dumps(payload, sort_keys=True), verify_ssl=True)
-
- @mock.patch.object(Common, "perform_request")
- def test_delete_alarm_req(self, perf_req):
- """Test delete alarm request."""
- self.alarming.delete_alarm(alarm_endpoint, auth_token, "my_alarm_id", True)
-
- perf_req.assert_called_with(
- "alarm_endpoint/v2/alarms/my_alarm_id", auth_token, req_type="delete", verify_ssl=True)
-
- @mock.patch.object(Common, "perform_request")
- def test_invalid_list_alarm_req(self, perf_req):
- """Test invalid list alarm_req."""
- # Request will not be performed without a resource_id
- list_details = {"mock_details": "invalid_details"}
- with self.assertRaises(KeyError):
- self.alarming.list_alarms(alarm_endpoint, auth_token, list_details, True)
- perf_req.assert_not_called()
-
- @mock.patch.object(Common, "perform_request")
- def test_valid_list_alarm_req(self, perf_req):
- """Test valid list alarm request."""
- # Minimum requirement for an alarm list is resource_id
- list_details = {"resource_uuid": "mock_r_id", "alarm_name": "mock_alarm", "severity": "critical"}
-
- mock_perf_req_return_value = [
- {"alarm_id": "1", "name": "mock_alarm", "severity": "critical",
- "gnocchi_resources_threshold_rule": {"resource_id": "mock_r_id"}}]
- perf_req.return_value = type('obj', (object,),
- {'text': json.dumps(mock_perf_req_return_value)})
-
- alarm_list = self.alarming.list_alarms(alarm_endpoint, auth_token, list_details, True)
-
- self.assertDictEqual(alarm_list[0], mock_perf_req_return_value[0])
-
- perf_req.assert_called_with(
- "alarm_endpoint/v2/alarms/", auth_token, req_type="get", verify_ssl=True)
- perf_req.reset_mock()
-
- # Check list with alarm_name defined
- list_details = {"resource_uuid": "mock_r_id",
- "alarm_name": "mock_alarm",
- "severity": "critical"}
- alarm_list = self.alarming.list_alarms(alarm_endpoint, auth_token, list_details, True)
-
- self.assertDictEqual(alarm_list[0], mock_perf_req_return_value[0])
-
- perf_req.assert_called_with(
- "alarm_endpoint/v2/alarms/", auth_token, req_type="get", verify_ssl=True)
-
- @mock.patch.object(Common, "perform_request")
- def test_ack_alarm_req(self, perf_req):
- """Test update alarm state for acknowledge alarm request."""
- resp = Response({})
- perf_req.return_value = resp
-
- self.alarming.update_alarm_state(alarm_endpoint, auth_token, "my_alarm_id", True)
-
- perf_req.assert_called_with(
- "alarm_endpoint/v2/alarms/my_alarm_id/state", auth_token, req_type="put",
- payload=json.dumps("ok"), verify_ssl=True)
-
- @mock.patch.object(Common, "perform_request")
- def test_update_alarm_invalid(self, perf_req):
- """Test update alarm with invalid get response."""
- values = {"alarm_uuid": "my_alarm_id"}
-
- perf_req.return_value = type('obj', (object,), {'invalid_prop': 'Invalid response'})
-
- with self.assertRaises(Exception):
- self.alarming.update_alarm(alarm_endpoint, auth_token, values, {}, True)
- perf_req.assert_called_with(mock.ANY, auth_token, req_type="get")
-
- @mock.patch.object(Common, "perform_request")
- def test_update_alarm_invalid_payload(self, perf_req):
- """Test update alarm with invalid payload."""
- resp = Response({"name": "my_alarm",
- "state": "alarm",
- "gnocchi_resources_threshold_rule":
- {"resource_id": "my_resource_id",
- "metric": "my_metric"}})
- perf_req.return_value = resp
- values = {"alarm_uuid": "my_alarm_id"}
-
- with self.assertRaises(Exception):
- self.alarming.update_alarm(alarm_endpoint, auth_token, values, {}, True)
- perf_req.assert_called_with(mock.ANY, auth_token, req_type="get")
- self.assertEqual(perf_req.call_count, 1)
-
- @mock.patch.object(alarm_req.OpenstackAlarmHandler, "check_payload")
- @mock.patch.object(Common, "perform_request")
- def test_update_alarm_valid(self, perf_req, check_pay):
- """Test valid update alarm request."""
- resp = Response({"alarm_id": "1",
- "name": "my_alarm",
- "state": "alarm",
- "gnocchi_resources_threshold_rule":
- {"resource_id": "my_resource_id",
- "metric": "disk.write.requests"}})
- perf_req.return_value = resp
- values = {"alarm_uuid": "my_alarm_id"}
-
- self.alarming.update_alarm(alarm_endpoint, auth_token, values, {}, True)
-
- check_pay.assert_called_with(values, "disk_write_ops", "my_resource_id",
- "my_alarm", alarm_state="alarm")
-
- self.assertEqual(perf_req.call_count, 2)
- # Second call is the update request
- perf_req.assert_called_with(
- 'alarm_endpoint/v2/alarms/my_alarm_id', auth_token,
- req_type="put", payload=check_pay.return_value, verify_ssl=True)
-
- @mock.patch.object(Config, "instance")
- def test_check_valid_payload(self, cfg):
- """Test the check payload function for a valid payload."""
- values = {"severity": "warning",
- "statistic": "COUNT",
- "threshold_value": 12,
- "operation": "GT",
- "granularity": 300,
- "resource_type": "generic"}
- cfg.return_value.OS_NOTIFIER_URI = "http://localhost:8662"
- payload = self.alarming.check_payload(
- values, "disk_write_ops", "r_id", "alarm_name")
-
- self.assertDictEqual(
- json.loads(payload), {"name": "alarm_name",
- "gnocchi_resources_threshold_rule":
- {"resource_id": "r_id",
- "metric": "disk.write.requests",
- "comparison_operator": "gt",
- "aggregation_method": "count",
- "threshold": 12,
- "granularity": 300,
- "resource_type": "generic"},
- "severity": "low",
- "state": "ok",
- "type": "gnocchi_resources_threshold",
- "alarm_actions": ["http://localhost:8662"],
- "repeat_actions": True})
-
- @mock.patch.object(Config, "instance")
- @mock.patch.object(Common, "perform_request")
- def test_check_valid_state_payload(self, perform_req, cfg):
- """Test the check payload function for a valid payload with state."""
- values = {"severity": "warning",
- "statistic": "COUNT",
- "threshold_value": 12,
- "operation": "GT",
- "granularity": 300,
- "resource_type": "generic"}
- cfg.return_value.OS_NOTIFIER_URI = "http://localhost:8662"
- payload = self.alarming.check_payload(
- values, "disk_write_ops", "r_id", "alarm_name", alarm_state="alarm")
-
- self.assertEqual(
- json.loads(payload), {"name": "alarm_name",
- "gnocchi_resources_threshold_rule":
- {"resource_id": "r_id",
- "metric": "disk.write.requests",
- "comparison_operator": "gt",
- "aggregation_method": "count",
- "threshold": 12,
- "granularity": 300,
- "resource_type": "generic"},
- "severity": "low",
- "state": "alarm",
- "type": "gnocchi_resources_threshold",
- "alarm_actions": ["http://localhost:8662"],
- "repeat_actions": True})
-
- def test_check_invalid_payload(self):
- """Test the check payload function for an invalid payload."""
- values = {"alarm_values": "mock_invalid_details"}
- with self.assertRaises(Exception):
- self.alarming.check_payload(values, "my_metric", "r_id", "alarm_name")
-
- @mock.patch.object(Common, "perform_request")
- def test_get_alarm_state(self, perf_req):
- """Test the get alarm state function."""
- perf_req.return_value = type('obj', (object,), {'text': '{"alarm_id":"1"}'})
-
- self.alarming.get_alarm_state(alarm_endpoint, auth_token, "alarm_id")
-
- perf_req.assert_called_with(
- "alarm_endpoint/v2/alarms/alarm_id/state", auth_token, req_type="get")
-
- @mock.patch.object(Common, "perform_request")
- def test_check_for_metric(self, perf_req):
- """Test the check for metric function."""
- mock_perf_req_return_value = {"metrics": {"cpu_util": 123}}
- perf_req.return_value = type('obj', (object,), {'text': json.dumps(mock_perf_req_return_value)})
-
- self.alarming.check_for_metric(auth_token, metric_endpoint, "cpu_utilization", "r_id", True)
-
- perf_req.assert_called_with(
- "metric_endpoint/v1/resource/generic/r_id", auth_token, req_type="get", verify_ssl=True)
+++ /dev/null
-# Copyright 2017 Intel Research and Development Ireland Limited
-# *************************************************************
-
-# This file is part of OSM Monitoring module
-# All Rights Reserved to Intel Corporation
-
-# 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: helena.mcgough@intel.com or adrian.hoban@intel.com
-##
-"""Tests for all common OpenStack methods."""
-
-import json
-import logging
-import unittest
-
-import mock
-import requests
-from keystoneclient.v3 import client
-
-from osm_mon.core.auth import AuthManager
-from osm_mon.core.database import VimCredentials
-from osm_mon.plugins.OpenStack.common import Common
-
-__author__ = "Helena McGough"
-
-log = logging.getLogger(__name__)
-
-
-class Message(object):
- """Mock a message for an access credentials request."""
-
- def __init__(self):
- """Initialise the topic and value of access_cred message."""
- self.topic = "access_credentials"
- self.value = json.dumps({"mock_value": "mock_details",
- "vim_type": "OPENSTACK",
- "access_config":
- {"openstack_site": "my_site",
- "user": "my_user",
- "password": "my_password",
- "vim_tenant_name": "my_tenant"}})
-
-
-class TestCommon(unittest.TestCase):
- """Test the common class for OpenStack plugins."""
-
- def setUp(self):
- """Test Setup."""
- super(TestCommon, self).setUp()
- self.common = Common()
- self.creds = VimCredentials()
- self.creds.id = 'test_id'
- self.creds.user = 'user'
- self.creds.url = 'url'
- self.creds.password = 'password'
- self.creds.tenant_name = 'tenant_name'
-
- @mock.patch.object(AuthManager, "get_credentials")
- @mock.patch.object(client.Client, "get_raw_token_from_identity_service")
- def test_get_auth_token(self, get_token, get_creds):
- """Test generating a new authentication token."""
- get_creds.return_value = self.creds
- Common.get_auth_token('test_id')
- get_creds.assert_called_with('test_id')
- get_token.assert_called_with(auth_url='url', password='password', project_name='tenant_name', username='user',
- project_domain_id='default', user_domain_id='default')
-
- @mock.patch.object(requests, 'post')
- def test_post_req(self, post):
- """Testing a post request."""
- Common.perform_request("url", "auth_token", req_type="post",
- payload="payload")
-
- post.assert_called_with("url", data="payload", headers=mock.ANY,
- timeout=mock.ANY, verify=True)
-
- @mock.patch.object(requests, 'get')
- def test_get_req(self, get):
- """Testing a get request."""
- # Run the defualt get request without any parameters
- Common.perform_request("url", "auth_token", req_type="get")
-
- get.assert_called_with("url", params=None, headers=mock.ANY,
- timeout=mock.ANY, verify=True)
-
- # Test with some parameters specified
- get.reset_mock()
- Common.perform_request("url", "auth_token", req_type="get",
- params="some parameters")
-
- get.assert_called_with("url", params="some parameters",
- headers=mock.ANY, timeout=mock.ANY, verify=True)
-
- @mock.patch.object(requests, 'put')
- def test_put_req(self, put):
- """Testing a put request."""
- Common.perform_request("url", "auth_token", req_type="put",
- payload="payload")
- put.assert_called_with("url", data="payload", headers=mock.ANY,
- timeout=mock.ANY, verify=True)
-
- @mock.patch.object(requests, 'delete')
- def test_delete_req(self, delete):
- """Testing a delete request."""
- Common.perform_request("url", "auth_token", req_type="delete")
-
- delete.assert_called_with("url", headers=mock.ANY, timeout=mock.ANY, verify=True)
+++ /dev/null
-# Copyright 2017 iIntel Research and Development Ireland Limited
-# *************************************************************
-
-# This file is part of OSM Monitoring module
-# All Rights Reserved to Intel Corporation
-
-# 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: helena.mcgough@intel.com or adrian.hoban@intel.com
-##
-"""Tests for all metric request message keys."""
-
-import json
-import logging
-import unittest
-
-import mock
-
-from osm_mon.core.auth import AuthManager
-from osm_mon.plugins.OpenStack.Gnocchi import metric_handler as metric_req
-from osm_mon.plugins.OpenStack.common import Common
-
-log = logging.getLogger(__name__)
-
-# Mock auth_token and endpoint
-endpoint = mock.ANY
-auth_token = mock.ANY
-
-# Mock a valid metric list for some tests, and a resultant list
-metric_list = [{"name": "disk.write.requests",
- "id": "metric_id",
- "unit": "units",
- "resource_id": "r_id"}]
-result_list = ["metric_id", "r_id", "units", "disk_write_ops"]
-
-
-class Response(object):
- """Mock a response object for requests."""
-
- def __init__(self):
- """Initialise test and status code values."""
- self.text = json.dumps([{"id": "test_id"}])
- self.status_code = "STATUS_CODE"
-
-
-def perform_request_side_effect(*args, **kwargs):
- resp = Response()
- if 'marker' in args[0]:
- resp.text = json.dumps([])
- if 'resource/generic' in args[0]:
- resp.text = json.dumps({'metrics': {'cpu_util': 'test_id'}})
- return resp
-
-
-class TestMetricCalls(unittest.TestCase):
- """Integration test for metric request keys."""
-
- def setUp(self):
- """Setup the tests for metric request keys."""
- super(TestMetricCalls, self).setUp()
- self.metrics = metric_req.OpenstackMetricHandler()
- self.metrics._common = Common()
-
- @mock.patch.object(metric_req.OpenstackMetricHandler, "get_metric_id")
- @mock.patch.object(Common, "perform_request")
- def test_invalid_config_metric_req(
- self, perf_req, get_metric):
- """Test the configure metric function, for an invalid metric."""
- # Test invalid configuration for creating a metric
- values = {"metric_details": "invalid_metric"}
-
- with self.assertRaises(ValueError):
- self.metrics.configure_metric(endpoint, auth_token, values, verify_ssl=False)
-
- perf_req.assert_not_called()
-
- # Test with an invalid metric name, will not perform request
- values = {"resource_uuid": "r_id"}
-
- with self.assertRaises(ValueError):
- self.metrics.configure_metric(endpoint, auth_token, values, verify_ssl=False)
-
- perf_req.assert_not_called()
-
- # If metric exists, it won't be recreated
- get_metric.return_value = "metric_id"
-
- with self.assertRaises(ValueError):
- self.metrics.configure_metric(endpoint, auth_token, values, verify_ssl=False)
-
- perf_req.assert_not_called()
-
- @mock.patch.object(metric_req.OpenstackMetricHandler, "get_metric_id")
- @mock.patch.object(Common, "perform_request")
- @mock.patch.object(AuthManager, "get_credentials")
- def test_valid_config_metric_req(
- self, get_creds, perf_req, get_metric):
- """Test the configure metric function, for a valid metric."""
- # Test valid configuration and payload for creating a metric
- get_creds.return_value = type('obj', (object,), {'config': '{"insecure":true}'})
- values = {"resource_uuid": "r_id",
- "metric_unit": "units",
- "metric_name": "cpu_util"}
- get_metric.return_value = None
- payload = {"id": "r_id",
- "metrics": {"cpu_util":
- {"archive_policy_name": "high",
- "name": "cpu_util",
- "unit": "units"}}}
-
- perf_req.return_value = type('obj', (object,), {'text': '{"metrics":{"cpu_util":1}, "id":1}'})
-
- self.metrics.configure_metric(endpoint, auth_token, values, verify_ssl=False)
-
- perf_req.assert_called_with(
- "<ANY>/v1/resource/generic", auth_token, req_type="post", verify_ssl=False,
- payload=json.dumps(payload, sort_keys=True))
-
- @mock.patch.object(Common, "perform_request")
- def test_delete_metric_req(self, perf_req):
- """Test the delete metric function."""
- mock_response = Response()
- mock_response.status_code = 200
- perf_req.return_value = mock_response
-
- self.metrics.delete_metric(endpoint, auth_token, "metric_id", verify_ssl=False)
-
- perf_req.assert_called_with(
- "<ANY>/v1/metric/metric_id", auth_token, req_type="delete", verify_ssl=False)
-
- @mock.patch.object(Common, "perform_request")
- def test_delete_metric_invalid_status(self, perf_req):
- """Test invalid response for delete request."""
- perf_req.return_value = type('obj', (object,), {"status_code": "404"})
-
- with self.assertRaises(ValueError):
- self.metrics.delete_metric(endpoint, auth_token, "metric_id", verify_ssl=False)
-
- @mock.patch.object(metric_req.OpenstackMetricHandler, "response_list")
- @mock.patch.object(Common, "perform_request")
- def test_complete_list_metric_req(self, perf_req, resp_list):
- """Test the complete list metric function."""
- # Test listing metrics without any configuration options
- values = {}
- perf_req.side_effect = perform_request_side_effect
- self.metrics.list_metrics(endpoint, auth_token, values, verify_ssl=False)
-
- perf_req.assert_any_call(
- "<ANY>/v1/metric?sort=name:asc", auth_token, req_type="get", verify_ssl=False)
- resp_list.assert_called_with([{u'id': u'test_id'}])
-
- @mock.patch.object(metric_req.OpenstackMetricHandler, "response_list")
- @mock.patch.object(Common, "perform_request")
- def test_resource_list_metric_req(self, perf_req, resp_list):
- """Test the resource list metric function."""
- # Test listing metrics with a resource id specified
- values = {"resource_uuid": "resource_id"}
- perf_req.side_effect = perform_request_side_effect
- self.metrics.list_metrics(endpoint, auth_token, values, verify_ssl=False)
-
- perf_req.assert_any_call(
- "<ANY>/v1/metric/test_id", auth_token, req_type="get", verify_ssl=False)
-
- @mock.patch.object(metric_req.OpenstackMetricHandler, "response_list")
- @mock.patch.object(Common, "perform_request")
- def test_name_list_metric_req(self, perf_req, resp_list):
- """Test the metric_name list metric function."""
- # Test listing metrics with a metric_name specified
- values = {"metric_name": "disk_write_bytes"}
- perf_req.side_effect = perform_request_side_effect
- self.metrics.list_metrics(endpoint, auth_token, values, verify_ssl=False)
-
- perf_req.assert_any_call(
- "<ANY>/v1/metric?sort=name:asc", auth_token, req_type="get", verify_ssl=False)
- resp_list.assert_called_with(
- [{u'id': u'test_id'}], metric_name="disk_write_bytes")
-
- @mock.patch.object(metric_req.OpenstackMetricHandler, "response_list")
- @mock.patch.object(Common, "perform_request")
- def test_combined_list_metric_req(self, perf_req, resp_list):
- """Test the combined resource and metric list metric function."""
- # Test listing metrics with a resource id and metric name specified
-
- values = {"resource_uuid": "resource_id",
- "metric_name": "cpu_utilization"}
- perf_req.side_effect = perform_request_side_effect
- self.metrics.list_metrics(endpoint, auth_token, values, verify_ssl=False)
-
- perf_req.assert_any_call(
- "<ANY>/v1/metric/test_id", auth_token, req_type="get", verify_ssl=False)
-
- @mock.patch.object(Common, "perform_request")
- def test_get_metric_id(self, perf_req):
- """Test get_metric_id function."""
- mock_response = Response()
- mock_response.text = json.dumps({'metrics': {'my_metric': 'id'}})
- perf_req.return_value = mock_response
- self.metrics.get_metric_id(endpoint, auth_token, "my_metric", "r_id", verify_ssl=False)
-
- perf_req.assert_called_with(
- "<ANY>/v1/resource/generic/r_id", auth_token, req_type="get", verify_ssl=False)
-
- @mock.patch.object(metric_req.OpenstackMetricHandler, "get_metric_id")
- @mock.patch.object(Common, "perform_request")
- def test_valid_read_data_req(self, perf_req, get_metric):
- """Test the read metric data function, for a valid call."""
- values = {"metric_name": "disk_write_ops",
- "resource_uuid": "resource_id",
- "collection_unit": "DAY",
- "collection_period": 1}
-
- perf_req.return_value = type('obj', (object,), {'text': '{"metric_data":"[]"}'})
-
- get_metric.return_value = "metric_id"
- self.metrics.read_metric_data(endpoint, auth_token, values, verify_ssl=False)
-
- perf_req.assert_called_once()
-
- @mock.patch.object(Common, "perform_request")
- def test_invalid_read_data_req(self, perf_req):
- """Test the read metric data function for an invalid call."""
- values = {}
-
- with self.assertRaises(KeyError):
- self.metrics.read_metric_data(endpoint, auth_token, values, verify_ssl=False)
-
- def test_complete_response_list(self):
- """Test the response list function for formatting metric lists."""
- # Mock a list for testing purposes, with valid OSM metric
- resp_list = self.metrics.response_list(metric_list)
-
- # Check for the expected values in the resulting list
- for l in result_list:
- self.assertIn(l, resp_list[0].values())
-
- def test_name_response_list(self):
- """Test the response list with metric name configured."""
- # Mock the metric name to test a metric name list
- # Test with a name that is not in the list
- invalid_name = "my_metric"
- resp_list = self.metrics.response_list(
- metric_list, metric_name=invalid_name)
-
- self.assertEqual(resp_list, [])
-
- # Test with a name on the list
- valid_name = "disk_write_ops"
- resp_list = self.metrics.response_list(
- metric_list, metric_name=valid_name)
-
- # Check for the expected values in the resulting list
- for l in result_list:
- self.assertIn(l, resp_list[0].values())
-
- def test_resource_response_list(self):
- """Test the response list with resource_id configured."""
- # Mock a resource_id to test a resource list
- # Test with resource not on the list
- invalid_id = "mock_resource"
- resp_list = self.metrics.response_list(metric_list, resource=invalid_id)
-
- self.assertEqual(resp_list, [])
-
- # Test with a resource on the list
- valid_id = "r_id"
- resp_list = self.metrics.response_list(metric_list, resource=valid_id)
-
- # Check for the expected values in the resulting list
- for l in result_list:
- self.assertIn(l, resp_list[0].values())
-
- def test_combined_response_list(self):
- """Test the response list function with resource_id and metric_name."""
- # Test for a combined resource and name list
- # resource and name are on the list
- valid_name = "disk_write_ops"
- valid_id = "r_id"
- resp_list = self.metrics.response_list(
- metric_list, metric_name=valid_name, resource=valid_id)
-
- # Check for the expected values in the resulting list
- for l in result_list:
- self.assertIn(l, resp_list[0].values())
-
- # resource not on list
- invalid_id = "mock_resource"
- resp_list = self.metrics.response_list(
- metric_list, metric_name=valid_name, resource=invalid_id)
-
- self.assertEqual(resp_list, [])
-
- # metric name not on list
- invalid_name = "mock_metric"
- resp_list = self.metrics.response_list(
- metric_list, metric_name=invalid_name, resource=valid_id)
-
- self.assertEqual(resp_list, [])
+++ /dev/null
-# Copyright 2017 iIntel Research and Development Ireland Limited
-# *************************************************************
-
-# This file is part of OSM Monitoring module
-# All Rights Reserved to Intel Corporation
-
-# 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: helena.mcgough@intel.com or adrian.hoban@intel.com
-##
-"""Tests for all metric request message keys."""
-
-import json
-import logging
-import unittest
-
-import mock
-
-from osm_mon.core.auth import AuthManager
-from osm_mon.plugins.OpenStack.Gnocchi import metric_handler as metric_req
-from osm_mon.plugins.OpenStack.Gnocchi.metric_handler import OpenstackMetricHandler
-from osm_mon.plugins.OpenStack.common import Common
-
-log = logging.getLogger(__name__)
-
-
-class Response(object):
- """Mock a response object for requests."""
-
- def __init__(self):
- """Initialise test and status code values."""
- self.text = json.dumps([{"id": "test_id"}])
- self.status_code = "STATUS_CODE"
-
-
-class Message(object):
- """A class to mock a message object value for metric requests."""
-
- def __init__(self):
- """Initialize a mocked message instance."""
- self.topic = "metric_request"
- self.key = None
- self.value = json.dumps({"mock_message": "message_details"})
-
-
-class TestMetricReq(unittest.TestCase):
- """Integration test for metric request keys."""
-
- def setUp(self):
- """Setup the tests for metric request keys."""
- super(TestMetricReq, self).setUp()
- self.metrics = metric_req.OpenstackMetricHandler()
-
- @mock.patch.object(Common, "get_auth_token", mock.Mock())
- @mock.patch.object(Common, "get_endpoint", mock.Mock())
- @mock.patch.object(metric_req.OpenstackMetricHandler, "delete_metric")
- @mock.patch.object(metric_req.OpenstackMetricHandler, "get_metric_id")
- @mock.patch.object(AuthManager, "get_credentials")
- def test_delete_metric_key(self, get_creds, get_metric_id, del_metric):
- """Test the functionality for a delete metric request."""
- value = {"metric_name": "disk_write_ops", "resource_uuid": "my_r_id", "correlation_id": 1}
-
- get_creds.return_value = type('obj', (object,), {
- 'config': '{"insecure":true}'
- })
- del_metric.return_value = True
-
- # Call the metric functionality and check delete request
- get_metric_id.return_value = "my_metric_id"
- self.metrics.handle_request('delete_metric_request', value, 'test_id')
- del_metric.assert_called_with(mock.ANY, mock.ANY, "my_metric_id", False)
-
- @mock.patch.object(Common, "get_auth_token", mock.Mock())
- @mock.patch.object(Common, 'get_endpoint', mock.Mock())
- @mock.patch.object(metric_req.OpenstackMetricHandler, "list_metrics")
- @mock.patch.object(AuthManager, "get_credentials")
- def test_list_metric_key(self, get_creds, list_metrics):
- """Test the functionality for a list metric request."""
- value = {"metrics_list_request": {"correlation_id": 1}}
-
- get_creds.return_value = type('obj', (object,), {
- 'config': '{"insecure":true}'
- })
-
- list_metrics.return_value = []
-
- # Call the metric functionality and check list functionality
- self.metrics.handle_request('list_metric_request', value, 'test_id')
- list_metrics.assert_called_with(mock.ANY, mock.ANY, {"correlation_id": 1}, False)
-
- @mock.patch.object(Common, "get_auth_token", mock.Mock())
- @mock.patch.object(Common, 'get_endpoint', mock.Mock())
- @mock.patch.object(AuthManager, "get_credentials")
- @mock.patch.object(Common, "perform_request")
- def test_update_metric_key(self, perf_req, get_creds):
- """Test the functionality for an update metric request."""
- value = {"metric_update_request":
- {"correlation_id": 1,
- "metric_name": "my_metric",
- "resource_uuid": "my_r_id"}}
-
- get_creds.return_value = type('obj', (object,), {
- 'config': '{"insecure":true}'
- })
-
- mock_response = Response()
- mock_response.text = json.dumps({'metrics': {'my_metric': 'id'}})
- perf_req.return_value = mock_response
-
- # Call metric functionality and confirm no function is called
- # Gnocchi does not support updating a metric configuration
- self.metrics.handle_request('update_metric_request', value, 'test_id')
-
- @mock.patch.object(Common, "get_auth_token", mock.Mock())
- @mock.patch.object(Common, 'get_endpoint', mock.Mock())
- @mock.patch.object(OpenstackMetricHandler, "configure_metric")
- @mock.patch.object(AuthManager, "get_credentials")
- def test_config_metric_key(self, get_credentials, config_metric):
- """Test the functionality for a create metric request."""
- value = {"metric_create_request": {"correlation_id": 123}}
- get_credentials.return_value = type('obj', (object,), {'config': '{"insecure":true}'})
- # Call metric functionality and check config metric
- config_metric.return_value = "metric_id", "resource_id"
- self.metrics.handle_request('create_metric_request', value, 'test_id')
- config_metric.assert_called_with(mock.ANY, mock.ANY, {"correlation_id": 123}, False)
-
- @mock.patch.object(Common, "get_auth_token", mock.Mock())
- @mock.patch.object(Common, 'get_endpoint', mock.Mock())
- @mock.patch.object(OpenstackMetricHandler, "read_metric_data")
- @mock.patch.object(AuthManager, "get_credentials")
- @mock.patch.object(Common, "perform_request")
- def test_read_data_key(self, perf_req, get_creds, read_data):
- """Test the functionality for a read metric data request."""
- value = {"correlation_id": 123, "metric_name": "cpu_utilization", "resource_uuid": "uuid"}
-
- get_creds.return_value = type('obj', (object,), {
- 'config': '{"insecure":true}'
- })
-
- mock_response = Response()
- mock_response.text = json.dumps({'metrics': {'cpu_util': 'id'}})
- perf_req.return_value = mock_response
-
- # Call metric functionality and check read data metrics
- read_data.return_value = "time_stamps", "data_values"
- self.metrics.handle_request('read_metric_data_request', value, 'test_id')
- read_data.assert_called_with(
- mock.ANY, mock.ANY, value, False)
+++ /dev/null
-# Copyright 2017 Intel Research and Development Ireland Limited
-# *************************************************************
-
-# This file is part of OSM Monitoring module
-# All Rights Reserved to Intel Corporation
-
-# 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: helena.mcgough@intel.com or adrian.hoban@intel.com
-##
-"""Tests for all common OpenStack methods."""
-
-import json
-import unittest
-
-import mock
-from kafka import KafkaProducer
-
-from osm_mon.core.database import DatabaseManager, Alarm
-from osm_mon.plugins.OpenStack.Aodh.notifier import NotifierHandler
-
-post_data = {"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 Response(object):
- """Mock a response class for generating responses."""
-
- def __init__(self, text):
- """Initialise a mock response with a text attribute."""
- self.text = text
-
-
-class RFile():
- def read(self, content_length):
- return json.dumps(post_data, sort_keys=True)
-
-
-class MockNotifierHandler(NotifierHandler):
- """Mock the NotifierHandler class for testing purposes."""
-
- def __init__(self):
- """Initialise mock NotifierHandler."""
- self.headers = {'Content-Length': '20'}
- self.rfile = RFile()
-
- def setup(self):
- """Mock setup function."""
- pass
-
- def handle(self):
- """Mock handle function."""
- pass
-
- def finish(self):
- """Mock finish function."""
- pass
-
-
-@mock.patch.object(KafkaProducer, "__init__", lambda *args, **kwargs: None)
-@mock.patch.object(KafkaProducer, "flush", mock.Mock())
-class TestNotifier(unittest.TestCase):
- """Test the NotifierHandler class for requests from aodh."""
-
- def setUp(self):
- """Setup tests."""
- super(TestNotifier, self).setUp()
- self.handler = MockNotifierHandler()
-
- @mock.patch.object(NotifierHandler, "_set_headers")
- def test_do_GET(self, set_head):
- """Tests do_GET. Validates _set_headers has been called."""
- self.handler.do_GET()
-
- set_head.assert_called_once()
-
- @mock.patch.object(NotifierHandler, "notify_alarm")
- @mock.patch.object(NotifierHandler, "_set_headers")
- def test_do_POST(self, set_head, notify):
- """Tests do_POST. Validates notify_alarm has been called."""
- self.handler.do_POST()
-
- set_head.assert_called_once()
- notify.assert_called_with(post_data)
-
- @mock.patch.object(NotifierHandler, "_publish_response")
- @mock.patch.object(DatabaseManager, "get_alarm")
- def test_notify_alarm_valid_alarm(
- self, get_alarm, notify):
- """
- Tests notify_alarm when request from OpenStack references an existing alarm in the DB.
- Validates KafkaProducer.notify_alarm has been called.
- """
- # Generate return values for valid notify_alarm operation
- mock_alarm = Alarm()
- get_alarm.return_value = mock_alarm
-
- self.handler.notify_alarm(post_data)
- notify.assert_called_with('notify_alarm', mock.ANY)
-
- @mock.patch.object(NotifierHandler, "_publish_response")
- @mock.patch.object(DatabaseManager, "get_alarm")
- def test_notify_alarm_invalid_alarm(
- self, get_alarm, notify):
- """
- Tests notify_alarm when request from OpenStack references a non existing alarm in the DB.
- Validates Exception is thrown and KafkaProducer.notify_alarm has not been called.
- """
- # Generate return values for valid notify_alarm operation
- get_alarm.return_value = None
-
- with self.assertRaises(Exception):
- self.handler.notify_alarm(post_data)
- notify.assert_not_called()
+++ /dev/null
-# Copyright 2017 iIntel Research and Development Ireland Limited
-# *************************************************************
-
-# This file is part of OSM Monitoring module
-# All Rights Reserved to Intel Corporation
-
-# 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: helena.mcgough@intel.com or adrian.hoban@intel.com
-##
-"""Test that the correct responses are generated for each message."""
-
-import logging
-import unittest
-
-import mock
-
-from osm_mon.plugins.OpenStack import response as resp
-
-log = logging.getLogger(__name__)
-
-
-class TestOpenStackResponse(unittest.TestCase):
- """Tests for responses generated by the OpenStack plugins."""
-
- def setUp(self):
- """Setup for testing OpenStack plugin responses."""
- super(TestOpenStackResponse, self).setUp()
- self.plugin_resp = resp.OpenStackResponseBuilder()
-
- def test_invalid_key(self):
- """Test if an invalid key is entered for a response."""
- message = self.plugin_resp.generate_response("mock_invalid_key")
- self.assertEqual(message, None)
-
- @mock.patch.object(
- resp.OpenStackResponseBuilder, "alarm_list_response")
- def test_list_alarm_resp(self, alarm_list_resp):
- """Test out a function call for a list alarm response."""
- message = self.plugin_resp.generate_response("list_alarm_response")
- self.assertEqual(alarm_list_resp.return_value, message)
-
- @mock.patch.object(
- resp.OpenStackResponseBuilder, "list_metric_response")
- def test_list_metric_resp(self, metric_list_resp):
- """Test list metric response function call."""
- message = self.plugin_resp.generate_response("list_metric_response")
- self.assertEqual(message, metric_list_resp.return_value)
-
- @mock.patch.object(
- resp.OpenStackResponseBuilder, "delete_alarm_response")
- def test_delete_alarm_resp(self, del_alarm_resp):
- """Test delete alarm response function call."""
- message = self.plugin_resp.generate_response("delete_alarm_response")
- self.assertEqual(message, del_alarm_resp.return_value)
-
- @mock.patch.object(
- resp.OpenStackResponseBuilder, "delete_metric_response")
- def test_delete_metric_resp(self, del_metric_resp):
- """Test the response functionality of delete metric response."""
- message = self.plugin_resp.generate_response("delete_metric_response")
- self.assertEqual(message, del_metric_resp.return_value)
-
- @mock.patch.object(
- resp.OpenStackResponseBuilder, "create_alarm_response")
- def test_create_alarm_resp(self, config_alarm_resp):
- """Test create alarm response function call."""
- message = self.plugin_resp.generate_response("create_alarm_response")
- self.assertEqual(message, config_alarm_resp.return_value)
-
- @mock.patch.object(
- resp.OpenStackResponseBuilder, "metric_create_response")
- def test_create_metric_resp(self, config_metric_resp):
- """Test create metric response function call."""
- message = self.plugin_resp.generate_response("create_metric_response")
- self.assertEqual(message, config_metric_resp.return_value)
-
- @mock.patch.object(
- resp.OpenStackResponseBuilder, "update_alarm_response")
- def test_update_alarm_resp(self, up_alarm_resp):
- """Test update alarm response function call."""
- message = self.plugin_resp.generate_response("update_alarm_response")
- self.assertEqual(message, up_alarm_resp.return_value)
-
- @mock.patch.object(
- resp.OpenStackResponseBuilder, "update_metric_response")
- def test_update_metric_resp(self, up_metric_resp):
- """Test update metric response function call."""
- message = self.plugin_resp.generate_response("update_metric_response")
- self.assertEqual(message, up_metric_resp.return_value)
-
- @mock.patch.object(
- resp.OpenStackResponseBuilder, "notify_alarm")
- def test_notify_alarm(self, notify_alarm):
- """Test notify alarm response function call."""
- message = self.plugin_resp.generate_response("notify_alarm")
- self.assertEqual(message, notify_alarm.return_value)
-
- @mock.patch.object(
- resp.OpenStackResponseBuilder, "read_metric_data_response")
- def test_read_metric_data_resp(self, read_data_resp):
- """Test read metric data response function call."""
- message = self.plugin_resp.generate_response(
- "read_metric_data_response")
- self.assertEqual(message, read_data_resp.return_value)
+++ /dev/null
-# Copyright 2017 Intel Research and Development Ireland Limited
-# *************************************************************
-
-# This file is part of OSM Monitoring module
-# All Rights Reserved to Intel Corporation
-
-# 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: helena.mcgough@intel.com or adrian.hoban@intel.com
-##
-"""Tests for settings for OpenStack plugins configurations."""
-
-import logging
-import os
-import unittest
-
-from osm_mon.core.settings import Config
-
-log = logging.getLogger(__name__)
-
-
-class TestSettings(unittest.TestCase):
- """Test the settings class for OpenStack plugin configuration."""
-
- def setUp(self):
- """Test Setup."""
- super(TestSettings, self).setUp()
- self.cfg = Config.instance()
-
- def test_set_os_username(self):
- """Test reading the environment for OpenStack plugin configuration."""
- os.environ["OS_NOTIFIER_URI"] = "test"
- self.cfg.read_environ()
-
- self.assertEqual(self.cfg.OS_NOTIFIER_URI, "test")
+++ /dev/null
-# -*- coding: utf-8 -*-
-
-##
-# Copyright 2017-2018 VMware Inc.
-# This file is part of ETSI OSM
-# All Rights Reserved.
-#
-# 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: osslegalrouting@vmware.com
-##
-
-"""VMware MON plugin tests."""
-
-import logging
-import sys
-
-from osm_mon.core.settings import Config
-
-cfg = Config.instance()
-logging.basicConfig(stream=sys.stdout,
- format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
- datefmt='%m/%d/%Y %I:%M:%S %p',
- level=logging.getLevelName(cfg.OSMMON_LOG_LEVEL))
-log = logging.getLogger(__name__)
-
+++ /dev/null
-# -*- coding: utf-8 -*-
-
-##
-# Copyright 2017-2018 VMware Inc.
-# This file is part of ETSI OSM
-# All Rights Reserved.
-#
-# 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: osslegalrouting@vmware.com
-##
-
-""" Mock tests for VMware vROPs Mon plugin """
-
-import os
-import sys
-import unittest
-
-import mock
-import requests
-
-sys.path.append(os.path.join(os.path.dirname(os.path.abspath(__file__)), "..", "..", ".."))
-
-from osm_mon.plugins.vRealiseOps import mon_plugin_vrops as monPlugin
-
-from pyvcloud.vcd.client import Client
-
-
-class TestMonPlugin(unittest.TestCase):
- """Test class for vROPs Mon Plugin class methods"""
-
- def setUp(self):
- """Setup the tests for Mon Plugin class methods"""
- super(TestMonPlugin, self).setUp()
-
- self.m_vim_access_config = {'vrops_site': 'abc',
- 'vrops_user': 'user',
- 'vrops_password': 'passwd',
- 'vim_url': 'vcd_url',
- 'admin_username': 'admin',
- 'admin_password': 'admin_passwd',
- 'vim_uuid': '1',
- 'tenant_id': 'org_vdc_1'}
- self.mon_plugin = monPlugin.MonPlugin(self.m_vim_access_config)
- # create client object
- self.vca = Client('test', verify_ssl_certs=False)
- # create session
- self.session = requests.Session()
-
- def test_get_default_Params_valid_metric_alarm_name(self):
- """Test get default params method"""
-
- # Mock valid metric_alarm_name and response
- metric_alarm_name = "Average_Memory_Usage_Above_Threshold"
- expected_return = {'impact': 'risk', 'cancel_cycles': 2, 'adapter_kind': 'VMWARE',
- 'repeat': False, 'cancel_period': 300, 'alarm_type': 16,
- 'vrops_alarm': 'Avg_Mem_Usage_Above_Thr', 'enabled': True, 'period': 300,
- 'resource_kind': 'VirtualMachine', 'alarm_subType': 19,
- 'action': 'acknowledge', 'evaluation': 2, 'unit': '%'}
-
- # call get default param function under test
- actual_return = self.mon_plugin.get_default_Params(metric_alarm_name)
-
- # verify return value with expected value
- self.assertEqual(expected_return, actual_return)
-
- def test_get_default_Params_invalid_metric_alarm_name(self):
- """Test get default params method invalid metric alarm"""
-
- # Mock valid metric_alarm_name and response
- metric_alarm_name = "Invalid_Alarm"
- expected_return = {}
-
- # call get default param function under test
- actual_return = self.mon_plugin.get_default_Params(metric_alarm_name)
-
- # verify return value with expected value
- self.assertEqual(expected_return, actual_return)
-
- @mock.patch.object(monPlugin.requests, 'post')
- def test_create_symptom_valid_req_response(self, m_post):
- """Test create symptom method-valid request"""
-
- # Mock valid symptom params and mock responses
- symptom_param = {'threshold_value': 0, 'cancel_cycles': 1, 'adapter_kind_key': 'VMWARE',
- 'resource_kind_key': 'VirtualMachine', 'severity': 'CRITICAL',
- 'symptom_name': \
- 'CPU_Utilization_Above_Thr-e14b203c-6bf2-4e2f-a91c-8c19d240eda4',
- 'operation': 'GT', 'wait_cycles': 1, 'metric_key': 'cpu|usage_average'}
-
- m_post.return_value.status_code = 201
- m_post.return_value.content = \
- '{"id":"SymptomDefinition-351c23b4-bc3c-4c7b-b4af-1ad90a673c5d",\
- "name":"CPU_Utilization_Above_Thr-e14b203c-6bf2-4e2f-a91c-8c19d240eda4",\
- "adapterKindKey":"VMWARE","resourceKindKey":"VirtualMachine",\
- "waitCycles":1,"cancelCycles":1,\
- "state":{"severity":"CRITICAL","condition":{"type":"CONDITION_HT",\
- "key":"cpu|usage_average","operator":"GT","value":"0.0",\
- "valueType":"NUMERIC",\
- "instanced":false,"thresholdType":"STATIC"}}}'
-
- expected_return = "SymptomDefinition-351c23b4-bc3c-4c7b-b4af-1ad90a673c5d"
-
- # call create symptom method under test
- actual_return = self.mon_plugin.create_symptom(symptom_param)
-
- # verify that mocked method is called
- m_post.assert_called()
-
- # verify return value with expected value
- self.assertEqual(expected_return, actual_return)
-
- @mock.patch.object(monPlugin.requests, 'post')
- def test_create_symptom_invalid_req_response(self, m_post):
- """Test create symptom method-invalid response"""
-
- # Mock valid symptom params and invalid mock responses
- symptom_param = {'threshold_value': 0, 'cancel_cycles': 1, 'adapter_kind_key': 'VMWARE',
- 'resource_kind_key': 'VirtualMachine', 'severity': 'CRITICAL',
- 'symptom_name': \
- 'CPU_Utilization_Above_Thr-e14b203c-6bf2-4e2f-a91c-8c19d240eda4',
- 'operation': 'GT', 'wait_cycles': 1, 'metric_key': 'cpu|usage_average'}
-
- m_post.return_value.status_code = 404
- m_post.return_value.content = '404 Not Found'
-
- expected_return = None
-
- # call create symptom method under test
- actual_return = self.mon_plugin.create_symptom(symptom_param)
-
- # verify that mocked method is called
- m_post.assert_called()
-
- # verify return value with expected value
- self.assertEqual(expected_return, actual_return)
-
- @mock.patch.object(monPlugin.requests, 'post')
- def test_create_symptom_incorrect_data(self, m_post):
- """Test create symptom method-incorrect data"""
-
- # Mock valid symptom params and invalid mock responses
- symptom_param = {'threshold_value': 0, 'cancel_cycles': 1, 'adapter_kind_key': 'VMWARE',
- 'resource_kind_key': 'VirtualMachine', 'severity': 'CRITICAL',
- 'symptom_name': \
- 'CPU_Utilization_Above_Thr-e14b203c-6bf2-4e2f-a91c-8c19d240eda4',
- 'operation': 'GT', 'metric_key': 'cpu|usage_average'}
-
- expected_return = None
-
- # call create symptom method under test
- actual_return = self.mon_plugin.create_symptom(symptom_param)
-
- # verify that mocked method is not called
- m_post.assert_not_called()
-
- # verify return value with expected value
- self.assertEqual(expected_return, actual_return)
-
- @mock.patch.object(monPlugin.requests, 'post')
- def test_create_alarm_definition_valid_req_response(self, m_post):
- """Test create alarm definition method-valid response"""
-
- # Mock valid alarm params and mock responses
- alarm_param = {'description': 'CPU_Utilization_Above_Threshold', 'cancelCycles': 1,
- 'subType': 19, 'waitCycles': 1,
- 'severity': 'CRITICAL', 'impact': 'risk', 'adapterKindKey': 'VMWARE',
- 'name': 'CPU_Utilization_Above_Thr-e14b203c-6bf2-4e2f-a91c-8c19d240eda4',
- 'resourceKindKey': 'VirtualMachine', 'type': 16,
- 'symptomDefinitionId': \
- 'SymptomDefinition-25278b06-bff8-4409-a141-9b4e064235df'}
-
- m_post.return_value.status_code = 201
- m_post.return_value.content = \
- '{"id":"AlertDefinition-d4f21e4b-770a-45d6-b298-022eaf489115",\
- "name":"CPU_Utilization_Above_Thr-e14b203c-6bf2-4e2f-a91c-8c19d240eda4",\
- "description":"CPU_Utilization_Above_Threshold","adapterKindKey":"VMWARE",\
- "resourceKindKey":"VirtualMachine","waitCycles":1,"cancelCycles":1,\
- "type":16,"subType":19,\
- "states":[{"severity":"CRITICAL","base-symptom-set":{"type":"SYMPTOM_SET",\
- "relation":"SELF","aggregation":"ALL","symptomSetOperator":"AND",\
- "symptomDefinitionIds":\
- ["SymptomDefinition-25278b06-bff8-4409-a141-9b4e064235df"]},\
- "impact":{"impactType":"BADGE","detail":"risk"}}]}'
-
- expected_return = "AlertDefinition-d4f21e4b-770a-45d6-b298-022eaf489115"
-
- # call create alarm definition method under test
- actual_return = self.mon_plugin.create_alarm_definition(alarm_param)
-
- # verify that mocked method is called
- m_post.assert_called()
-
- # verify return value with expected value
- self.assertEqual(expected_return, actual_return)
-
- @mock.patch.object(monPlugin.requests, 'post')
- def test_create_alarm_definition_invalid_req_response(self, m_post):
- """Test create alarm definition method-invalid response"""
-
- # Mock valid alarm params and mock responses
- alarm_param = {'description': 'CPU_Utilization_Above_Threshold', 'cancelCycles': 1,
- 'subType': 19, 'waitCycles': 1,
- 'severity': 'CRITICAL', 'impact': 'risk', 'adapterKindKey': 'VMWARE',
- 'name': 'CPU_Utilization_Above_Thr-e14b203c-6bf2-4e2f-a91c-8c19d240eda4',
- 'resourceKindKey': 'VirtualMachine', 'type': 16,
- 'symptomDefinitionId': \
- 'SymptomDefinition-25278b06-bff8-4409-a141-9b4e064235df'}
-
- m_post.return_value.status_code = 404
- m_post.return_value.content = '404 Not Found'
-
- expected_return = None
-
- # call create alarm definition method under test
- actual_return = self.mon_plugin.create_alarm_definition(alarm_param)
-
- # verify that mocked method is called
- m_post.assert_called()
-
- # verify return value with expected value
- self.assertEqual(expected_return, actual_return)
-
- @mock.patch.object(monPlugin.requests, 'post')
- def test_create_alarm_definition_incorrect_data(self, m_post):
- """Test create alarm definition method-incorrect data"""
-
- # Mock incorrect alarm param
- alarm_param = {'description': 'CPU_Utilization_Above_Threshold', 'cancelCycles': 1,
- 'subType': 19, 'waitCycles': 1, 'type': 16,
- 'severity': 'CRITICAL', 'impact': 'risk', 'adapterKindKey': 'VMWARE',
- 'symptomDefinitionId': \
- 'SymptomDefinition-25278b06-bff8-4409-a141-9b4e064235df'}
- expected_return = None
-
- # call create symptom method under test
- actual_return = self.mon_plugin.create_alarm_definition(alarm_param)
-
- # verify that mocked method is not called
- m_post.assert_not_called()
-
- # verify return value with expected value
- self.assertEqual(expected_return, actual_return)
-
- @mock.patch.object(monPlugin.DatabaseManager, 'save_alarm')
- @mock.patch.object(monPlugin.MonPlugin, 'create_alarm_notification_rule')
- @mock.patch.object(monPlugin.MonPlugin, 'get_vm_resource_id')
- @mock.patch.object(monPlugin.MonPlugin, 'get_vm_moref_id')
- @mock.patch.object(monPlugin.MonPlugin, 'create_alarm_definition')
- @mock.patch.object(monPlugin.MonPlugin, 'create_symptom')
- @mock.patch.object(monPlugin.MonPlugin, 'get_alarm_defination_by_name')
- @mock.patch.object(monPlugin.MonPlugin, 'get_default_Params')
- def test_configure_alarm_valid_req(self, m_get_default_Params,
- m_get_alarm_defination_by_name,
- m_create_symptom,
- m_create_alarm_definition,
- m_get_vm_moref_id,
- m_get_vm_resource_id,
- m_create_alarm_notification_rule,
- m_save_alarm):
- """Test configure alarm valid request creating alarm"""
-
- # Mock input configuration dictionary
- config_dict = {'threshold_value': 0, 'severity': 'CRITICAL',
- 'alarm_name': 'CPU_Utilization_Above_Threshold',
- 'resource_uuid': 'e14b203c-6bf2-4e2f-a91c-8c19d240eda4',
- 'correlation_id': 'e14b203c-6bf2-4e2f-a91c-8c19d2abcdef',
- 'statistic': 'AVERAGE', 'metric_name': 'cpu_utilization',
- 'vdu_name': 'vdu1', 'vnf_member_index': 'index1', 'ns_id': 'nsd1',
- 'operation': 'GT', 'unit': '%',
- 'description': 'CPU_Utilization_Above_Threshold'}
-
- # symptom parameters to be passed for symptom creation
- symptom_params = {'threshold_value': 0,
- 'cancel_cycles': 1,
- 'adapter_kind_key': 'VMWARE',
- 'resource_kind_key': 'VirtualMachine',
- 'severity': 'CRITICAL',
- 'symptom_name': \
- 'CPU_Utilization_Above_Thr-e14b203c-6bf2-4e2f-a91c-8c19d240eda4',
- 'operation': 'GT',
- 'wait_cycles': 1,
- 'metric_key': 'cpu|usage_average'}
-
- # alarm parameters to be passed for alarm creation
- alarm_params = {'description': 'CPU_Utilization_Above_Threshold',
- 'cancelCycles': 1, 'subType': 19,
- 'waitCycles': 1, 'severity': 'CRITICAL',
- 'impact': 'risk', 'adapterKindKey': 'VMWARE',
- 'name': 'CPU_Utilization_Above_Thr-e14b203c-6bf2-4e2f-a91c-8c19d240eda4',
- 'resourceKindKey': 'VirtualMachine',
- 'symptomDefinitionId': \
- 'SymptomDefinition-2e8f9ddc-9f7b-4cd6-b85d-7d7fe3a8a804',
- 'type': 16}
-
- vm_moref_id = 'vm-6626'
- vrops_alarm_name = 'CPU_Utilization_Above_Thr-e14b203c-6bf2-4e2f-a91c-8c19d240eda4'
- alarm_def = 'AlertDefinition-0f3cdcb3-4e1b-4a0b-86d0-66d4b3f65220'
- resource_id = 'ac87622f-b761-40a0-b151-00872a2a456e'
- alarm_def_uuid = '0f3cdcb3-4e1b-4a0b-86d0-66d4b3f65220'
-
- # Mock default Parameters for alarm & metric configuration
- m_get_default_Params.side_effect = [{'impact': 'risk', 'cancel_cycles': 1,
- 'adapter_kind': 'VMWARE', 'repeat': False,
- 'cancel_period': 300, 'alarm_type': 16,
- 'vrops_alarm': 'CPU_Utilization_Above_Thr',
- 'enabled': True, 'period': 300,
- 'resource_kind': 'VirtualMachine',
- 'alarm_subType': 19, 'action': 'acknowledge',
- 'evaluation': 1, 'unit': 'msec'},
- {'metric_key': 'cpu|usage_average', 'unit': '%'}
- ]
-
- # set mocked function return values
- m_get_alarm_defination_by_name.return_value = []
- m_create_symptom.return_value = 'SymptomDefinition-2e8f9ddc-9f7b-4cd6-b85d-7d7fe3a8a804'
- m_create_alarm_definition.return_value = \
- 'AlertDefinition-0f3cdcb3-4e1b-4a0b-86d0-66d4b3f65220'
- m_get_vm_moref_id.return_value = vm_moref_id
- m_get_vm_resource_id.return_value = 'ac87622f-b761-40a0-b151-00872a2a456e'
- m_create_alarm_notification_rule.return_value = 'f37900e7-dd01-4383-b84c-08f519530d71'
-
- # Call configure_alarm method under test
- return_value = self.mon_plugin.configure_alarm(config_dict)
-
- # Verify that mocked methods are called with correct parameters
- self.assertEqual(m_get_default_Params.call_count, 2)
- m_get_alarm_defination_by_name.assert_called_with(vrops_alarm_name)
- m_create_symptom.assert_called_with(symptom_params)
- m_create_alarm_definition.assert_called_with(alarm_params)
- m_get_vm_moref_id.assert_called_with(config_dict['resource_uuid'])
- m_get_vm_resource_id.assert_called_with(vm_moref_id)
- m_create_alarm_notification_rule.assert_called_with(vrops_alarm_name,
- alarm_def,
- resource_id)
- m_save_alarm.assert_called_with(vrops_alarm_name, '1',
- config_dict['threshold_value'],
- config_dict['operation'],
- config_dict['metric_name'],
- config_dict['vdu_name'],
- config_dict['vnf_member_index'],
- config_dict['ns_id'])
-
- # Verify return value with expected value of alarm_def_uuid
- self.assertEqual(return_value, alarm_def_uuid)
-
- @mock.patch.object(monPlugin.DatabaseManager, 'save_alarm')
- @mock.patch.object(monPlugin.MonPlugin, 'create_alarm_notification_rule')
- @mock.patch.object(monPlugin.MonPlugin, 'get_vm_resource_id')
- @mock.patch.object(monPlugin.MonPlugin, 'get_vm_moref_id')
- @mock.patch.object(monPlugin.MonPlugin, 'create_alarm_definition')
- @mock.patch.object(monPlugin.MonPlugin, 'create_symptom')
- @mock.patch.object(monPlugin.MonPlugin, 'get_alarm_defination_by_name')
- @mock.patch.object(monPlugin.MonPlugin, 'get_default_Params')
- def test_configure_alarm_invalid_alarm_name_req(self, m_get_default_Params,
- m_get_alarm_defination_by_name,
- m_create_symptom,
- m_create_alarm_definition,
- m_get_vm_moref_id,
- m_get_vm_resource_id,
- m_create_alarm_notification_rule,
- m_save_alarm):
- """Test configure alarm invalid test: for invalid alarm name"""
-
- # Mock input configuration dictionary
- config_dict = {'threshold_value': 0, 'severity': 'CRITICAL',
- 'alarm_name': 'CPU_Utilization_Above_Threshold',
- 'resource_uuid': 'e14b203c-6bf2-4e2f-a91c-8c19d240eda4',
- 'correlation_id': 'e14b203c-6bf2-4e2f-a91c-8c19d2abcdef',
- 'statistic': 'AVERAGE', 'metric_name': 'CPU_UTILIZATION',
- 'operation': 'GT', 'unit': '%',
- 'description': 'CPU_Utilization_Above_Threshold'}
-
- alarm_def_uuid = None
-
- # Mock default Parameters return value to None
- m_get_default_Params.return_value = {}
-
- # Call configure_alarm method under test
- return_value = self.mon_plugin.configure_alarm(config_dict)
-
- # Verify that mocked methods are called with correct parameters
- m_get_default_Params.assert_called_with(config_dict['alarm_name'])
- m_get_alarm_defination_by_name.assert_not_called()
- m_create_symptom.assert_not_called()
- m_create_alarm_definition.assert_not_called()
- m_get_vm_moref_id.assert_not_called()
- m_get_vm_resource_id.assert_not_called()
- m_create_alarm_notification_rule.assert_not_called()
- m_save_alarm.assert_not_called()
-
- # Verify return value with expected value i.e. None
- self.assertEqual(return_value, alarm_def_uuid)
-
- @mock.patch.object(monPlugin.DatabaseManager, 'save_alarm')
- @mock.patch.object(monPlugin.MonPlugin, 'create_alarm_notification_rule')
- @mock.patch.object(monPlugin.MonPlugin, 'get_vm_resource_id')
- @mock.patch.object(monPlugin.MonPlugin, 'get_vm_moref_id')
- @mock.patch.object(monPlugin.MonPlugin, 'create_alarm_definition')
- @mock.patch.object(monPlugin.MonPlugin, 'create_symptom')
- @mock.patch.object(monPlugin.MonPlugin, 'get_alarm_defination_by_name')
- @mock.patch.object(monPlugin.MonPlugin, 'get_default_Params')
- def test_configure_alarm_invalid_metric_name_req(self, m_get_default_Params,
- m_get_alarm_defination_by_name,
- m_create_symptom,
- m_create_alarm_definition,
- m_get_vm_moref_id,
- m_get_vm_resource_id,
- m_create_alarm_notification_rule,
- m_save_alarm):
- """Test configure alarm invalid test: for invalid metric name"""
-
- # Mock input configuration dictionary
- config_dict = {'threshold_value': 0, 'severity': 'CRITICAL',
- 'alarm_name': 'CPU_Utilization_Above_Threshold',
- 'resource_uuid': 'e14b203c-6bf2-4e2f-a91c-8c19d240eda4',
- 'correlation_id': 'e14b203c-6bf2-4e2f-a91c-8c19d2abcdef',
- 'statistic': 'AVERAGE', 'metric_name': 'CPU_UTILIZATION',
- 'operation': 'GT', 'unit': '%',
- 'description': 'CPU_Utilization_Above_Threshold'}
-
- alarm_def_uuid = None
-
- # Mock default Parameters return values for metrics to None
- m_get_default_Params.side_effect = [{'impact': 'risk', 'cancel_cycles': 1,
- 'adapter_kind': 'VMWARE', 'repeat': False,
- 'cancel_period': 300, 'alarm_type': 16,
- 'vrops_alarm': 'CPU_Utilization_Above_Thr',
- 'enabled': True, 'period': 300,
- 'resource_kind': 'VirtualMachine',
- 'alarm_subType': 19, 'action': 'acknowledge',
- 'evaluation': 1, 'unit': 'msec'},
- {}
- ]
-
- # Call configure_alarm method under test
- return_value = self.mon_plugin.configure_alarm(config_dict)
-
- # Verify that mocked methods are called with correct parameters
- self.assertEqual(m_get_default_Params.call_count, 2)
- m_get_alarm_defination_by_name.assert_not_called()
- m_create_symptom.assert_not_called()
- m_create_alarm_definition.assert_not_called()
- m_get_vm_moref_id.assert_not_called()
- m_get_vm_resource_id.assert_not_called()
- m_create_alarm_notification_rule.assert_not_called()
- m_save_alarm.assert_not_called()
-
- # Verify return value with expected value i.e. None
- self.assertEqual(return_value, alarm_def_uuid)
-
- @mock.patch.object(monPlugin.DatabaseManager, 'save_alarm')
- @mock.patch.object(monPlugin.MonPlugin, 'create_alarm_notification_rule')
- @mock.patch.object(monPlugin.MonPlugin, 'get_vm_resource_id')
- @mock.patch.object(monPlugin.MonPlugin, 'get_vm_moref_id')
- @mock.patch.object(monPlugin.MonPlugin, 'create_alarm_definition')
- @mock.patch.object(monPlugin.MonPlugin, 'create_symptom')
- @mock.patch.object(monPlugin.MonPlugin, 'get_alarm_defination_by_name')
- @mock.patch.object(monPlugin.MonPlugin, 'get_default_Params')
- def test_configure_alarm_invalid_already_exists(self, m_get_default_Params,
- m_get_alarm_defination_by_name,
- m_create_symptom,
- m_create_alarm_definition,
- m_get_vm_moref_id,
- m_get_vm_resource_id,
- m_create_alarm_notification_rule,
- m_save_alarm):
- """Test configure alarm invalid test: for alarm that already exists"""
-
- # Mock input configuration dictionary
- config_dict = {'threshold_value': 0, 'severity': 'CRITICAL',
- 'alarm_name': 'CPU_Utilization_Above_Threshold',
- 'resource_uuid': 'e14b203c-6bf2-4e2f-a91c-8c19d240eda4',
- 'correlation_id': 'e14b203c-6bf2-4e2f-a91c-8c19d2abcdef',
- 'statistic': 'AVERAGE', 'metric_name': 'CPU_UTILIZATION',
- 'operation': 'GT', 'unit': '%',
- 'description': 'CPU_Utilization_Above_Threshold'}
-
- vrops_alarm_name = 'CPU_Utilization_Above_Thr-e14b203c-6bf2-4e2f-a91c-8c19d240eda4'
- alarm_def_uuid = None
-
- # Mock default Parameters for alarm & metric configuration
- m_get_default_Params.side_effect = [{'impact': 'risk', 'cancel_cycles': 1,
- 'adapter_kind': 'VMWARE', 'repeat': False,
- 'cancel_period': 300, 'alarm_type': 16,
- 'vrops_alarm': 'CPU_Utilization_Above_Thr',
- 'enabled': True, 'period': 300,
- 'resource_kind': 'VirtualMachine',
- 'alarm_subType': 19, 'action': 'acknowledge',
- 'evaluation': 1, 'unit': 'msec'},
- {'metric_key': 'cpu|usage_average', 'unit': '%'}
- ]
- # set mocked function return value
- m_get_alarm_defination_by_name.return_value = ['mocked_alarm_CPU_Utilization_Above_Thr']
-
- # Call configure_alarm method under test
- return_value = self.mon_plugin.configure_alarm(config_dict)
-
- # Verify that mocked methods are called with correct parameters
- self.assertEqual(m_get_default_Params.call_count, 2)
- m_get_alarm_defination_by_name.assert_called_with(vrops_alarm_name)
- m_create_symptom.assert_not_called()
- m_create_alarm_definition.assert_not_called()
- m_get_vm_moref_id.assert_not_called()
- m_get_vm_resource_id.assert_not_called()
- m_create_alarm_notification_rule.assert_not_called()
- m_save_alarm.assert_not_called()
- # Verify return value with expected value of alarm_def_uuid
- self.assertEqual(return_value, alarm_def_uuid)
-
- @mock.patch.object(monPlugin.DatabaseManager, 'save_alarm')
- @mock.patch.object(monPlugin.MonPlugin, 'create_alarm_notification_rule')
- @mock.patch.object(monPlugin.MonPlugin, 'get_vm_resource_id')
- @mock.patch.object(monPlugin.MonPlugin, 'get_vm_moref_id')
- @mock.patch.object(monPlugin.MonPlugin, 'create_alarm_definition')
- @mock.patch.object(monPlugin.MonPlugin, 'create_symptom')
- @mock.patch.object(monPlugin.MonPlugin, 'get_alarm_defination_by_name')
- @mock.patch.object(monPlugin.MonPlugin, 'get_default_Params')
- def test_configure_alarm_failed_symptom_creation(self, m_get_default_Params,
- m_get_alarm_defination_by_name,
- m_create_symptom,
- m_create_alarm_definition,
- m_get_vm_moref_id,
- m_get_vm_resource_id,
- m_create_alarm_notification_rule,
- m_save_alarm):
- """Test configure alarm: failed to create symptom"""
-
- # Mock input configuration dictionary
- config_dict = {'threshold_value': 0, 'severity': 'CRITICAL',
- 'alarm_name': 'CPU_Utilization_Above_Threshold',
- 'resource_uuid': 'e14b203c-6bf2-4e2f-a91c-8c19d240eda4',
- 'correlation_id': 'e14b203c-6bf2-4e2f-a91c-8c19d2abcdef',
- 'statistic': 'AVERAGE', 'metric_name': 'CPU_UTILIZATION',
- 'operation': 'GT', 'unit': '%',
- 'description': 'CPU_Utilization_Above_Threshold'}
-
- # symptom parameters to be passed for symptom creation
- symptom_params = {'threshold_value': 0,
- 'cancel_cycles': 1,
- 'adapter_kind_key': 'VMWARE',
- 'resource_kind_key': 'VirtualMachine',
- 'severity': 'CRITICAL',
- 'symptom_name': 'CPU_Utilization_Above_Thr-e14b203c-6bf2-4e2f-a91c-8c19d240eda4',
- 'operation': 'GT',
- 'wait_cycles': 1,
- 'metric_key': 'cpu|usage_average'}
- vrops_alarm_name = 'CPU_Utilization_Above_Thr-e14b203c-6bf2-4e2f-a91c-8c19d240eda4'
- alarm_def_uuid = None
-
- # Mock default Parameters for alarm & metric configuration
- m_get_default_Params.side_effect = [{'impact': 'risk', 'cancel_cycles': 1,
- 'adapter_kind': 'VMWARE', 'repeat': False,
- 'cancel_period': 300, 'alarm_type': 16,
- 'vrops_alarm': 'CPU_Utilization_Above_Thr',
- 'enabled': True, 'period': 300,
- 'resource_kind': 'VirtualMachine',
- 'alarm_subType': 19, 'action': 'acknowledge',
- 'evaluation': 1, 'unit': 'msec'},
- {'metric_key': 'cpu|usage_average', 'unit': '%'}
- ]
- # set mocked function return values
- m_get_alarm_defination_by_name.return_value = []
- m_create_symptom.return_value = None
-
- # Call configure_alarm method under test
- return_value = self.mon_plugin.configure_alarm(config_dict)
-
- # Verify that mocked methods are called with correct parameters
- self.assertEqual(m_get_default_Params.call_count, 2)
- m_get_alarm_defination_by_name.assert_called_with(vrops_alarm_name)
- m_create_symptom.assert_called_with(symptom_params)
- m_create_alarm_definition.assert_not_called()
- m_get_vm_moref_id.assert_not_called()
- m_get_vm_resource_id.assert_not_called()
- m_create_alarm_notification_rule.assert_not_called()
- m_save_alarm.assert_not_called()
-
- # Verify return value with expected value of alarm_def_uuid
- self.assertEqual(return_value, alarm_def_uuid)
-
- @mock.patch.object(monPlugin.DatabaseManager, 'save_alarm')
- @mock.patch.object(monPlugin.MonPlugin, 'create_alarm_notification_rule')
- @mock.patch.object(monPlugin.MonPlugin, 'get_vm_resource_id')
- @mock.patch.object(monPlugin.MonPlugin, 'get_vm_moref_id')
- @mock.patch.object(monPlugin.MonPlugin, 'create_alarm_definition')
- @mock.patch.object(monPlugin.MonPlugin, 'create_symptom')
- @mock.patch.object(monPlugin.MonPlugin, 'get_alarm_defination_by_name')
- @mock.patch.object(monPlugin.MonPlugin, 'get_default_Params')
- def test_configure_alarm_failed_alert_creation(self, m_get_default_Params,
- m_get_alarm_defination_by_name,
- m_create_symptom,
- m_create_alarm_definition,
- m_get_vm_moref_id,
- m_get_vm_resource_id,
- m_create_alarm_notification_rule,
- m_save_alarm):
- """Test configure alarm: failed to create alert in vROPs"""
-
- # Mock input configuration dictionary
- config_dict = {'threshold_value': 0, 'severity': 'CRITICAL',
- 'alarm_name': 'CPU_Utilization_Above_Threshold',
- 'resource_uuid': 'e14b203c-6bf2-4e2f-a91c-8c19d240eda4',
- 'correlation_id': 'e14b203c-6bf2-4e2f-a91c-8c19d2abcdef',
- 'statistic': 'AVERAGE', 'metric_name': 'CPU_UTILIZATION',
- 'operation': 'GT', 'unit': '%',
- 'description': 'CPU_Utilization_Above_Threshold'}
-
- # symptom parameters to be passed for symptom creation
- symptom_params = {'threshold_value': 0,
- 'cancel_cycles': 1,
- 'adapter_kind_key': 'VMWARE',
- 'resource_kind_key': 'VirtualMachine',
- 'severity': 'CRITICAL',
- 'symptom_name': 'CPU_Utilization_Above_Thr-e14b203c-6bf2-4e2f-a91c-8c19d240eda4',
- 'operation': 'GT',
- 'wait_cycles': 1,
- 'metric_key': 'cpu|usage_average'}
-
- # alarm parameters to be passed for alarm creation
- alarm_params = {'description': 'CPU_Utilization_Above_Threshold',
- 'cancelCycles': 1, 'subType': 19,
- 'waitCycles': 1, 'severity': 'CRITICAL',
- 'impact': 'risk', 'adapterKindKey': 'VMWARE',
- 'name': 'CPU_Utilization_Above_Thr-e14b203c-6bf2-4e2f-a91c-8c19d240eda4',
- 'resourceKindKey': 'VirtualMachine',
- 'symptomDefinitionId': 'SymptomDefinition-2e8f9ddc-9f7b-4cd6-b85d-7d7fe3a8a804',
- 'type': 16}
-
- vrops_alarm_name = 'CPU_Utilization_Above_Thr-e14b203c-6bf2-4e2f-a91c-8c19d240eda4'
- alarm_def_uuid = None
-
- # Mock default Parameters for alarm & metric configuration
- m_get_default_Params.side_effect = [{'impact': 'risk', 'cancel_cycles': 1,
- 'adapter_kind': 'VMWARE', 'repeat': False,
- 'cancel_period': 300, 'alarm_type': 16,
- 'vrops_alarm': 'CPU_Utilization_Above_Thr',
- 'enabled': True, 'period': 300,
- 'resource_kind': 'VirtualMachine',
- 'alarm_subType': 19, 'action': 'acknowledge',
- 'evaluation': 1, 'unit': 'msec'},
- {'metric_key': 'cpu|usage_average', 'unit': '%'}
- ]
- # set mocked function return values
- m_get_alarm_defination_by_name.return_value = []
- m_create_symptom.return_value = 'SymptomDefinition-2e8f9ddc-9f7b-4cd6-b85d-7d7fe3a8a804'
- m_create_alarm_definition.return_value = None
-
- # Call configure_alarm method under test
- return_value = self.mon_plugin.configure_alarm(config_dict)
-
- # Verify that mocked methods are called with correct parameters
- self.assertEqual(m_get_default_Params.call_count, 2)
- m_get_alarm_defination_by_name.assert_called_with(vrops_alarm_name)
- m_create_symptom.assert_called_with(symptom_params)
- m_create_alarm_definition.assert_called_with(alarm_params)
- m_get_vm_moref_id.assert_not_called()
- m_get_vm_resource_id.assert_not_called()
- m_create_alarm_notification_rule.assert_not_called()
- m_save_alarm.assert_not_called()
-
- # Verify return value with expected value of alarm_def_uuid
- self.assertEqual(return_value, alarm_def_uuid)
-
- @mock.patch.object(monPlugin.DatabaseManager, 'save_alarm')
- @mock.patch.object(monPlugin.MonPlugin, 'create_alarm_notification_rule')
- @mock.patch.object(monPlugin.MonPlugin, 'get_vm_resource_id')
- @mock.patch.object(monPlugin.MonPlugin, 'get_vm_moref_id')
- @mock.patch.object(monPlugin.MonPlugin, 'create_alarm_definition')
- @mock.patch.object(monPlugin.MonPlugin, 'create_symptom')
- @mock.patch.object(monPlugin.MonPlugin, 'get_alarm_defination_by_name')
- @mock.patch.object(monPlugin.MonPlugin, 'get_default_Params')
- def test_configure_alarm_failed_to_get_vm_moref_id(self, m_get_default_Params,
- m_get_alarm_defination_by_name,
- m_create_symptom,
- m_create_alarm_definition,
- m_get_vm_moref_id,
- m_get_vm_resource_id,
- m_create_alarm_notification_rule,
- m_save_alarm):
- """Test configure alarm: failed to get vm_moref_id"""
-
- # Mock input configuration dictionary
- config_dict = {'threshold_value': 0, 'severity': 'CRITICAL',
- 'alarm_name': 'CPU_Utilization_Above_Threshold',
- 'resource_uuid': 'e14b203c-6bf2-4e2f-a91c-8c19d240eda4',
- 'correlation_id': 'e14b203c-6bf2-4e2f-a91c-8c19d2abcdef',
- 'statistic': 'AVERAGE', 'metric_name': 'CPU_UTILIZATION',
- 'operation': 'GT', 'unit': '%',
- 'description': 'CPU_Utilization_Above_Threshold'}
-
- # symptom parameters to be passed for symptom creation
- symptom_params = {'threshold_value': 0,
- 'cancel_cycles': 1,
- 'adapter_kind_key': 'VMWARE',
- 'resource_kind_key': 'VirtualMachine',
- 'severity': 'CRITICAL',
- 'symptom_name': \
- 'CPU_Utilization_Above_Thr-e14b203c-6bf2-4e2f-a91c-8c19d240eda4',
- 'operation': 'GT',
- 'wait_cycles': 1,
- 'metric_key': 'cpu|usage_average'}
-
- # alarm parameters to be passed for alarm creation
- alarm_params = {'description': 'CPU_Utilization_Above_Threshold',
- 'cancelCycles': 1, 'subType': 19,
- 'waitCycles': 1, 'severity': 'CRITICAL',
- 'impact': 'risk', 'adapterKindKey': 'VMWARE',
- 'name': 'CPU_Utilization_Above_Thr-e14b203c-6bf2-4e2f-a91c-8c19d240eda4',
- 'resourceKindKey': 'VirtualMachine',
- 'symptomDefinitionId': \
- 'SymptomDefinition-2e8f9ddc-9f7b-4cd6-b85d-7d7fe3a8a804',
- 'type': 16}
-
- vrops_alarm_name = 'CPU_Utilization_Above_Thr-e14b203c-6bf2-4e2f-a91c-8c19d240eda4'
- alarm_def_uuid = None
-
- # Mock default Parameters for alarm & metric configuration
- m_get_default_Params.side_effect = [{'impact': 'risk', 'cancel_cycles': 1,
- 'adapter_kind': 'VMWARE', 'repeat': False,
- 'cancel_period': 300, 'alarm_type': 16,
- 'vrops_alarm': 'CPU_Utilization_Above_Thr',
- 'enabled': True, 'period': 300,
- 'resource_kind': 'VirtualMachine',
- 'alarm_subType': 19, 'action': 'acknowledge',
- 'evaluation': 1, 'unit': 'msec'},
- {'metric_key': 'cpu|usage_average', 'unit': '%'}
- ]
- # set mocked function return values
- m_get_alarm_defination_by_name.return_value = []
- m_create_symptom.return_value = 'SymptomDefinition-2e8f9ddc-9f7b-4cd6-b85d-7d7fe3a8a804'
- m_create_alarm_definition.return_value = \
- 'AlertDefinition-0f3cdcb3-4e1b-4a0b-86d0-66d4b3f65220'
- m_get_vm_moref_id.return_value = None
-
- # Call configure_alarm method under test
- return_value = self.mon_plugin.configure_alarm(config_dict)
-
- # Verify that mocked methods are called with correct parameters
- self.assertEqual(m_get_default_Params.call_count, 2)
- m_get_alarm_defination_by_name.assert_called_with(vrops_alarm_name)
- m_create_symptom.assert_called_with(symptom_params)
- m_create_alarm_definition.assert_called_with(alarm_params)
- m_get_vm_moref_id.assert_called_with(config_dict['resource_uuid'])
- m_get_vm_resource_id.assert_not_called()
- m_create_alarm_notification_rule.assert_not_called()
- m_save_alarm.assert_not_called()
-
- # Verify return value with expected value of alarm_def_uuid
- self.assertEqual(return_value, alarm_def_uuid)
-
- @mock.patch.object(monPlugin.DatabaseManager, 'save_alarm')
- @mock.patch.object(monPlugin.MonPlugin, 'create_alarm_notification_rule')
- @mock.patch.object(monPlugin.MonPlugin, 'get_vm_resource_id')
- @mock.patch.object(monPlugin.MonPlugin, 'get_vm_moref_id')
- @mock.patch.object(monPlugin.MonPlugin, 'create_alarm_definition')
- @mock.patch.object(monPlugin.MonPlugin, 'create_symptom')
- @mock.patch.object(monPlugin.MonPlugin, 'get_alarm_defination_by_name')
- @mock.patch.object(monPlugin.MonPlugin, 'get_default_Params')
- def test_configure_alarm_failed_to_get_vm_resource_id(self, m_get_default_Params,
- m_get_alarm_defination_by_name,
- m_create_symptom,
- m_create_alarm_definition,
- m_get_vm_moref_id,
- m_get_vm_resource_id,
- m_create_alarm_notification_rule,
- m_save_alarm):
- """Test configure alarm: failed to get vm resource_id"""
-
- # Mock input configuration dictionary
- config_dict = {'threshold_value': 0, 'severity': 'CRITICAL',
- 'alarm_name': 'CPU_Utilization_Above_Threshold',
- 'resource_uuid': 'e14b203c-6bf2-4e2f-a91c-8c19d240eda4',
- 'correlation_id': 'e14b203c-6bf2-4e2f-a91c-8c19d2abcdef',
- 'statistic': 'AVERAGE', 'metric_name': 'CPU_UTILIZATION',
- 'operation': 'GT', 'unit': '%',
- 'description': 'CPU_Utilization_Above_Threshold'}
-
- # symptom parameters to be passed for symptom creation
- symptom_params = {'threshold_value': 0,
- 'cancel_cycles': 1,
- 'adapter_kind_key': 'VMWARE',
- 'resource_kind_key': 'VirtualMachine',
- 'severity': 'CRITICAL',
- 'symptom_name': \
- 'CPU_Utilization_Above_Thr-e14b203c-6bf2-4e2f-a91c-8c19d240eda4',
- 'operation': 'GT',
- 'wait_cycles': 1,
- 'metric_key': 'cpu|usage_average'}
-
- # alarm parameters to be passed for alarm creation
- alarm_params = {'description': 'CPU_Utilization_Above_Threshold',
- 'cancelCycles': 1, 'subType': 19,
- 'waitCycles': 1, 'severity': 'CRITICAL',
- 'impact': 'risk', 'adapterKindKey': 'VMWARE',
- 'name': 'CPU_Utilization_Above_Thr-e14b203c-6bf2-4e2f-a91c-8c19d240eda4',
- 'resourceKindKey': 'VirtualMachine',
- 'symptomDefinitionId': \
- 'SymptomDefinition-2e8f9ddc-9f7b-4cd6-b85d-7d7fe3a8a804',
- 'type': 16}
-
- vrops_alarm_name = 'CPU_Utilization_Above_Thr-e14b203c-6bf2-4e2f-a91c-8c19d240eda4'
- vm_moref_id = 'vm-6626'
- alarm_def_uuid = None
-
- # Mock default Parameters for alarm & metric configuration
- m_get_default_Params.side_effect = [{'impact': 'risk', 'cancel_cycles': 1,
- 'adapter_kind': 'VMWARE', 'repeat': False,
- 'cancel_period': 300, 'alarm_type': 16,
- 'vrops_alarm': 'CPU_Utilization_Above_Thr',
- 'enabled': True, 'period': 300,
- 'resource_kind': 'VirtualMachine',
- 'alarm_subType': 19, 'action': 'acknowledge',
- 'evaluation': 1, 'unit': 'msec'},
- {'metric_key': 'cpu|usage_average', 'unit': '%'}
- ]
- # set mocked function return values
- m_get_alarm_defination_by_name.return_value = []
- m_create_symptom.return_value = 'SymptomDefinition-2e8f9ddc-9f7b-4cd6-b85d-7d7fe3a8a804'
- m_create_alarm_definition.return_value = \
- 'AlertDefinition-0f3cdcb3-4e1b-4a0b-86d0-66d4b3f65220'
- m_get_vm_moref_id.return_value = vm_moref_id
- m_get_vm_resource_id.return_value = None
- m_save_alarm.assert_not_called()
-
- # Call configure_alarm method under test
- return_value = self.mon_plugin.configure_alarm(config_dict)
-
- # Verify that mocked methods are called with correct parameters
- self.assertEqual(m_get_default_Params.call_count, 2)
- m_get_alarm_defination_by_name.assert_called_with(vrops_alarm_name)
- m_create_symptom.assert_called_with(symptom_params)
- m_create_alarm_definition.assert_called_with(alarm_params)
- m_get_vm_moref_id.assert_called_with(config_dict['resource_uuid'])
- m_get_vm_resource_id.assert_called_with(vm_moref_id)
- m_create_alarm_notification_rule.assert_not_called()
-
- # Verify return value with expected value of alarm_def_uuid
- self.assertEqual(return_value, alarm_def_uuid)
-
- @mock.patch.object(monPlugin.DatabaseManager, 'save_alarm')
- @mock.patch.object(monPlugin.MonPlugin, 'create_alarm_notification_rule')
- @mock.patch.object(monPlugin.MonPlugin, 'get_vm_resource_id')
- @mock.patch.object(monPlugin.MonPlugin, 'get_vm_moref_id')
- @mock.patch.object(monPlugin.MonPlugin, 'create_alarm_definition')
- @mock.patch.object(monPlugin.MonPlugin, 'create_symptom')
- @mock.patch.object(monPlugin.MonPlugin, 'get_alarm_defination_by_name')
- @mock.patch.object(monPlugin.MonPlugin, 'get_default_Params')
- def test_configure_alarm_failed_to_create_alarm_notification_rule(self, m_get_default_Params,
- m_get_alarm_defination_by_name,
- m_create_symptom,
- m_create_alarm_definition,
- m_get_vm_moref_id,
- m_get_vm_resource_id,
- m_create_alarm_notification_rule,
- m_save_alarm):
- """Test configure alarm: failed to create alarm notification rule"""
-
- # Mock input configuration dictionary
- config_dict = {'threshold_value': 0, 'severity': 'CRITICAL',
- 'alarm_name': 'CPU_Utilization_Above_Threshold',
- 'resource_uuid': 'e14b203c-6bf2-4e2f-a91c-8c19d240eda4',
- 'correlation_id': 'e14b203c-6bf2-4e2f-a91c-8c19d2abcdef',
- 'statistic': 'AVERAGE', 'metric_name': 'CPU_UTILIZATION',
- 'operation': 'GT', 'unit': '%',
- 'description': 'CPU_Utilization_Above_Threshold'}
-
- # symptom parameters to be passed for symptom creation
- symptom_params = {'threshold_value': 0,
- 'cancel_cycles': 1,
- 'adapter_kind_key': 'VMWARE',
- 'resource_kind_key': 'VirtualMachine',
- 'severity': 'CRITICAL',
- 'symptom_name': \
- 'CPU_Utilization_Above_Thr-e14b203c-6bf2-4e2f-a91c-8c19d240eda4',
- 'operation': 'GT',
- 'wait_cycles': 1,
- 'metric_key': 'cpu|usage_average'}
-
- # alarm parameters to be passed for alarm creation
- alarm_params = {'description': 'CPU_Utilization_Above_Threshold',
- 'cancelCycles': 1, 'subType': 19,
- 'waitCycles': 1, 'severity': 'CRITICAL',
- 'impact': 'risk', 'adapterKindKey': 'VMWARE',
- 'name': 'CPU_Utilization_Above_Thr-e14b203c-6bf2-4e2f-a91c-8c19d240eda4',
- 'resourceKindKey': 'VirtualMachine',
- 'symptomDefinitionId': \
- 'SymptomDefinition-2e8f9ddc-9f7b-4cd6-b85d-7d7fe3a8a804',
- 'type': 16}
-
- vrops_alarm_name = 'CPU_Utilization_Above_Thr-e14b203c-6bf2-4e2f-a91c-8c19d240eda4'
- vm_moref_id = 'vm-6626'
- alarm_def = 'AlertDefinition-0f3cdcb3-4e1b-4a0b-86d0-66d4b3f65220'
- resource_id = 'ac87622f-b761-40a0-b151-00872a2a456e'
- alarm_def_uuid = None
-
- # Mock default Parameters for alarm & metric configuration
- m_get_default_Params.side_effect = [{'impact': 'risk', 'cancel_cycles': 1,
- 'adapter_kind': 'VMWARE', 'repeat': False,
- 'cancel_period': 300, 'alarm_type': 16,
- 'vrops_alarm': 'CPU_Utilization_Above_Thr',
- 'enabled': True, 'period': 300,
- 'resource_kind': 'VirtualMachine',
- 'alarm_subType': 19, 'action': 'acknowledge',
- 'evaluation': 1, 'unit': 'msec'},
- {'metric_key': 'cpu|usage_average', 'unit': '%'}
- ]
- # set mocked function return values
- m_get_alarm_defination_by_name.return_value = []
- m_create_symptom.return_value = 'SymptomDefinition-2e8f9ddc-9f7b-4cd6-b85d-7d7fe3a8a804'
- m_create_alarm_definition.return_value = \
- 'AlertDefinition-0f3cdcb3-4e1b-4a0b-86d0-66d4b3f65220'
- m_get_vm_moref_id.return_value = vm_moref_id
- m_get_vm_resource_id.return_value = 'ac87622f-b761-40a0-b151-00872a2a456e'
- m_create_alarm_notification_rule.return_value = None
-
- # Call configure_alarm method under test
- return_value = self.mon_plugin.configure_alarm(config_dict)
-
- # Verify that mocked methods are called with correct parameters
- self.assertEqual(m_get_default_Params.call_count, 2)
- m_get_alarm_defination_by_name.assert_called_with(vrops_alarm_name)
- m_create_symptom.assert_called_with(symptom_params)
- m_create_alarm_definition.assert_called_with(alarm_params)
- m_get_vm_moref_id.assert_called_with(config_dict['resource_uuid'])
- m_get_vm_resource_id.assert_called_with(vm_moref_id)
- m_create_alarm_notification_rule.assert_called_with(vrops_alarm_name, alarm_def, resource_id)
- m_save_alarm.assert_not_called()
-
- # Verify return value with expected value of alarm_def_uuid
- self.assertEqual(return_value, alarm_def_uuid)
-
- @mock.patch.object(monPlugin.requests, 'get')
- def test_get_alarm_defination_details_valid_rest_req_response(self, m_get):
- """Test get_alarm_defination_details: For a valid REST request response"""
-
- alarm_uuid = '9a6d8a14-9f25-4d81-bf91-4d773497444d'
-
- # Set mocked function's return values
- m_get.return_value.status_code = 200
- m_get.return_value.content = '{"id":"AlertDefinition-9a6d8a14-9f25-4d81-bf91-4d773497444d",\
- "name":"CPU_Utilization_Above_Thr-e14b203c-6bf2-4e2f-a91c-8c19d240eda4",\
- "description":"CPU_Utilization_Above_Threshold",\
- "adapterKindKey":"VMWARE","resourceKindKey":"VirtualMachine",\
- "waitCycles":1,"cancelCycles":1,"type":16,"subType":19,\
- "states":[{"severity":"CRITICAL","base-symptom-set":\
- {"type":"SYMPTOM_SET","relation":"SELF",\
- "aggregation":"ALL","symptomSetOperator":"AND","symptomDefinitionIds":\
- ["SymptomDefinition-bcc2cb36-a67b-4deb-bcd3-9b5884973278"]},\
- "impact":{"impactType":"BADGE","detail":"risk"}}]}'
-
- expected_alarm_details = {'adapter_kind': 'VMWARE', 'symptom_definition_id': \
- 'SymptomDefinition-bcc2cb36-a67b-4deb-bcd3-9b5884973278',
- 'alarm_name': \
- 'CPU_Utilization_Above_Thr-e14b203c-6bf2-4e2f-a91c-8c19d240eda4',
- 'alarm_id': 'AlertDefinition-9a6d8a14-9f25-4d81-bf91-4d773497444d',
- 'resource_kind': 'VirtualMachine', 'type': 16, 'sub_type': 19}
-
- expected_alarm_details_json = {'states':
- [{'impact':
- {'impactType': 'BADGE', 'detail': 'risk'}, 'severity': 'CRITICAL',
- 'base-symptom-set': {'symptomDefinitionIds': \
- [
- 'SymptomDefinition-bcc2cb36-a67b-4deb-bcd3-9b5884973278'],
- 'relation': 'SELF', 'type': 'SYMPTOM_SET',
- 'aggregation': 'ALL', 'symptomSetOperator': 'AND'}}],
- 'adapterKindKey': 'VMWARE',
- 'description': 'CPU_Utilization_Above_Threshold',
- 'type': 16, 'cancelCycles': 1,
- 'resourceKindKey': 'VirtualMachine',
- 'subType': 19, 'waitCycles': 1,
- 'id': 'AlertDefinition-9a6d8a14-9f25-4d81-bf91-4d773497444d',
- 'name': \
- 'CPU_Utilization_Above_Thr-e14b203c-6bf2-4e2f-a91c-8c19d240eda4'}
-
- # Call get_alarm_defination_details method under test
- alarm_details_json, alarm_details = self.mon_plugin.get_alarm_defination_details(alarm_uuid)
-
- # Verify that mocked method is called
- m_get.assert_called()
-
- # Verify return value with expected value
- self.assertEqual(expected_alarm_details, alarm_details)
- self.assertEqual(expected_alarm_details_json, alarm_details_json)
-
- @mock.patch.object(monPlugin.requests, 'get')
- def test_get_alarm_defination_details_invalid_rest_req_response(self, m_get):
- """Test get_alarm_defination_details: For an invalid REST request response"""
-
- alarm_uuid = '9a6d8a14-9f25-4d81-bf91-4d773497444d'
-
- # Set mocked function's return values
- m_get.return_value.status_code = 404
- m_get.return_value.content = '{"message": "No such AlertDefinition - \
- AlertDefinition-9a6d8a14-9f25-4d81-bf91-4d773497444.",\
- "httpStatusCode": 404,"apiErrorCode": 404}'
-
- expected_alarm_details = None
- expected_alarm_details_json = None
-
- # Call get_alarm_defination_details method under test
- alarm_details_json, alarm_details = self.mon_plugin.get_alarm_defination_details(alarm_uuid)
-
- # verify that mocked method is called
- m_get.assert_called()
-
- # Verify return value with expected value
- self.assertEqual(expected_alarm_details, alarm_details)
- self.assertEqual(expected_alarm_details_json, alarm_details_json)
-
- @mock.patch.object(monPlugin.requests, 'get')
- def test_get_alarm_defination_by_name_valid_rest_req_response(self, m_get):
- """Test get_alarm_defination_by_name: For a valid REST request response"""
-
- alarm_name = 'CPU_Utilization_Above_Thr-e14b203c-6bf2-4e2f-a91c-8c19d240eda4'
-
- # Set mocked function's return values
- m_get.return_value.status_code = 200
- m_get.return_value.content = '{"pageInfo": {"totalCount": 1,"page": 0,"pageSize": 1000},\
- "links": [\
- {"href": "/suite-api/api/alertdefinitions?page=0&pageSize=1000",\
- "rel": "SELF","name": "current"},\
- {"href": "/suite-api/api/alertdefinitions?page=0&pageSize=1000",\
- "rel": "RELATED","name": "first"},\
- {"href": "/suite-api/api/alertdefinitions?page=0&pageSize=1000",\
- "rel": "RELATED","name": "last"}],\
- "alertDefinitions": [{\
- "id": "AlertDefinition-9a6d8a14-9f25-4d81-bf91-4d773497444d",\
- "name": "CPU_Utilization_Above_Thr-e14b203c-6bf2-4e2f-a91c-8c19d240eda4",\
- "description": "CPU_Utilization_Above_Threshold",\
- "adapterKindKey": "VMWARE","resourceKindKey": "VirtualMachine",\
- "waitCycles": 1,"cancelCycles": 1,"type": 16,"subType": 19,\
- "states": [{"impact": {"impactType": "BADGE","detail": "risk"},\
- "severity": "CRITICAL",\
- "base-symptom-set": {"type": "SYMPTOM_SET",\
- "relation": "SELF","aggregation": "ALL",\
- "symptomSetOperator": "AND",\
- "symptomDefinitionIds": [\
- "SymptomDefinition-bcc2cb36-a67b-4deb-bcd3-9b5884973278"]}}]\
- }]}'
-
- # Expected return match list
- Exp_alert_match_list = [{'states':
- [{'impact': {'impactType': 'BADGE', 'detail': 'risk'},
- 'severity': 'CRITICAL',
- 'base-symptom-set': {
- 'symptomDefinitionIds': \
- ['SymptomDefinition-bcc2cb36-a67b-4deb-bcd3-9b5884973278'],
- 'relation': 'SELF',
- 'type': 'SYMPTOM_SET',
- 'aggregation': 'ALL',
- 'symptomSetOperator': 'AND'}
- }],
- 'adapterKindKey': 'VMWARE',
- 'description': 'CPU_Utilization_Above_Threshold',
- 'type': 16,
- 'cancelCycles': 1,
- 'resourceKindKey': 'VirtualMachine',
- 'subType': 19, 'waitCycles': 1,
- 'id': 'AlertDefinition-9a6d8a14-9f25-4d81-bf91-4d773497444d',
- 'name': \
- 'CPU_Utilization_Above_Thr-e14b203c-6bf2-4e2f-a91c-8c19d240eda4'
- }]
-
- # Call get_alarm_defination_by_name method under test
- alert_match_list = self.mon_plugin.get_alarm_defination_by_name(alarm_name)
-
- # Verify that mocked method is called
- m_get.assert_called()
-
- # Verify return value with expected value
- self.assertEqual(Exp_alert_match_list, alert_match_list)
-
- @mock.patch.object(monPlugin.requests, 'get')
- def test_get_alarm_defination_by_name_no_valid_alarm_found(self, m_get):
- """Test get_alarm_defination_by_name: With no valid alarm found in returned list"""
-
- alarm_name = 'CPU_Utilization_Above_Thr-e14b203c-6bf2-4e2f-a91c-8c19d240eda5'
-
- # Set mocked function's return values
- m_get.return_value.status_code = 200
- m_get.return_value.content = '{"pageInfo": {"totalCount": 1,"page": 0,"pageSize": 1000},\
- "links": [\
- {"href": "/suite-api/api/alertdefinitions?page=0&pageSize=1000",\
- "rel": "SELF","name": "current"},\
- {"href": "/suite-api/api/alertdefinitions?page=0&pageSize=1000",\
- "rel": "RELATED","name": "first"},\
- {"href": "/suite-api/api/alertdefinitions?page=0&pageSize=1000",\
- "rel": "RELATED","name": "last"}],\
- "alertDefinitions": [{\
- "id": "AlertDefinition-9a6d8a14-9f25-4d81-bf91-4d773497444d",\
- "name": "CPU_Utilization_Above_Thr-e14b203c-6bf2-4e2f-a91c-8c19d240eda4",\
- "description": "CPU_Utilization_Above_Threshold",\
- "adapterKindKey": "VMWARE","resourceKindKey": "VirtualMachine",\
- "waitCycles": 1,"cancelCycles": 1,"type": 16,"subType": 19,\
- "states": [{"impact": {"impactType": "BADGE","detail": "risk"},\
- "severity": "CRITICAL",\
- "base-symptom-set": {"type": "SYMPTOM_SET",\
- "relation": "SELF","aggregation": "ALL",\
- "symptomSetOperator": "AND",\
- "symptomDefinitionIds": [\
- "SymptomDefinition-bcc2cb36-a67b-4deb-bcd3-9b5884973278"]}}]\
- }]}'
-
- # Expected return match list
- Exp_alert_match_list = []
-
- # Call get_alarm_defination_by_name method under test
- alert_match_list = self.mon_plugin.get_alarm_defination_by_name(alarm_name)
-
- # Verify that mocked method is called
- m_get.assert_called()
-
- # Verify return value with expected value
- self.assertEqual(Exp_alert_match_list, alert_match_list)
-
- @mock.patch.object(monPlugin.requests, 'put')
- @mock.patch.object(monPlugin.MonPlugin, 'get_symptom_defination_details')
- def test_update_symptom_defination_valid_symptom_req_response(self,
- m_get_symptom_defination_details,
- m_put):
- """Test update_symptom_defination: With valid REST response, update symptom"""
-
- # Expected symptom to be updated
- symptom_defination_id = 'SymptomDefinition-bcc2cb36-a67b-4deb-bcd3-9b5884973278'
- new_alarm_config = {'severity': "CRITICAL",
- 'operation': 'GT',
- 'threshold_value': 5,
- 'alarm_uuid': '9a6d8a14-9f25-4d81-bf91-4d773497444d'
- }
-
- # Set mocked function's return values
- m_get_symptom_defination_details.return_value = {
- "id": "SymptomDefinition-bcc2cb36-a67b-4deb-bcd3-9b5884973278",
- "name": "CPU_Utilization_Above_Thr-e14b203c-6bf2-4e2f-a91c-8c19d240eda4",
- "adapterKindKey": "VMWARE",
- "resourceKindKey": "VirtualMachine",
- "waitCycles": 1,
- "cancelCycles": 1,
- "state": {"severity": "CRITICAL",
- "condition": {
- "type": "CONDITION_HT",
- "key": "cpu|usage_average", "operator": "GT", "value": "0.0",
- "valueType": "NUMERIC", "instanced": False,
- "thresholdType": "STATIC"}
- }
- }
-
- m_put.return_value.status_code = 200
- m_put.return_value.content = '{\
- "id":"SymptomDefinition-bcc2cb36-a67b-4deb-bcd3-9b5884973278",\
- "name":"CPU_Utilization_Above_Thr-e14b203c-6bf2-4e2f-a91c-8c19d240eda4",\
- "adapterKindKey":"VMWARE","resourceKindKey":"VirtualMachine","waitCycles":1,\
- "cancelCycles":1,\
- "state":{\
- "severity":"CRITICAL",\
- "condition":{\
- "type":"CONDITION_HT","key":"cpu|usage_average","operator":"GT","value":"5.0",\
- "valueType":"NUMERIC","instanced":False,"thresholdType":"STATIC"}}}'
-
- # Call update_symptom_defination method under test
- symptom_uuid = self.mon_plugin.update_symptom_defination(symptom_defination_id,
- new_alarm_config)
-
- # Verify that mocked method is called with required parameters
- m_get_symptom_defination_details.assert_called_with(symptom_defination_id)
- # m_put.assert_called_with(symptom_defination_id,new_alarm_config)
-
- # Verify return value with expected value
- self.assertEqual(symptom_defination_id, symptom_uuid)
-
- @mock.patch.object(monPlugin.requests, 'put')
- @mock.patch.object(monPlugin.MonPlugin, 'get_symptom_defination_details')
- def test_update_symptom_defination_invalid_symptom_req_response(self,
- m_get_symptom_defination_details,
- m_put):
- """Test update_symptom_defination: If invalid REST response received, return None"""
-
- # Expected symptom to be updated
- symptom_defination_id = 'SymptomDefinition-bcc2cb36-a67b-4deb-bcd3-9b5884973278'
- new_alarm_config = {'severity': "CRITICAL",
- 'operation': 'GT',
- 'threshold_value': 5,
- 'alarm_uuid': '9a6d8a14-9f25-4d81-bf91-4d773497444d'
- }
-
- # Set mocked function's return values
- m_get_symptom_defination_details.return_value = {
- "id": "SymptomDefinition-bcc2cb36-a67b-4deb-bcd3-9b5884973278",
- "name": "CPU_Utilization_Above_Thr-e14b203c-6bf2-4e2f-a91c-8c19d240eda4",
- "adapterKindKey": "VMWARE",
- "resourceKindKey": "VirtualMachine",
- "waitCycles": 1,
- "cancelCycles": 1,
- "state": {"severity": "CRITICAL",
- "condition": {
- "type": "CONDITION_HT",
- "key": "cpu|usage_average", "operator": "GT", "value": "0.0",
- "valueType": "NUMERIC", "instanced": False,
- "thresholdType": "STATIC"}
- }
- }
-
- m_put.return_value.status_code = 500
- m_put.return_value.content = '{\
- "message": "Internal Server error, cause unknown.",\
- "moreInformation": [\
- {"name": "errorMessage",\
- "value": "Symptom Definition CPU_Utilization_Above_Thr-e14b203c-\
- 6bf2-4e2f-a91c-8c19d240eda4 does not exist and hence cannot be updated."},\
- {"name": "localizedMessage",\
- "value": "Symptom Definition CPU_Utilization_Above_Thr-e14b203c-\
- 6bf2-4e2f-a91c-8c19d240eda4 does not exist and hence cannot be updated.;"}],\
- "httpStatusCode": 500,"apiErrorCode": 500}'
-
- # Call update_symptom_defination method under test
- symptom_uuid = self.mon_plugin.update_symptom_defination(symptom_defination_id,
- new_alarm_config)
-
- # Verify that mocked method is called with required parameters
- m_get_symptom_defination_details.assert_called_with(symptom_defination_id)
- m_put.assert_called()
-
- # Verify return value with expected value
- self.assertEqual(symptom_uuid, None)
-
- @mock.patch.object(monPlugin.requests, 'put')
- @mock.patch.object(monPlugin.MonPlugin, 'get_symptom_defination_details')
- def test_update_symptom_defination_failed_to_get_symptom_defination(self,
- m_get_symptom_defination_details,
- m_put):
- """Test update_symptom_defination: if fails to get symptom_defination returns None"""
-
- # Expected symptom to be updated
- symptom_defination_id = 'SymptomDefinition-bcc2cb36-a67b-4deb-bcd3-9b5884973278'
- new_alarm_config = {'severity': "CRITICAL",
- 'operation': 'GT',
- 'threshold_value': 5,
- 'alarm_uuid': '9a6d8a14-9f25-4d81-bf91-4d773497444d'
- }
-
- # Set mocked function's return values
- m_get_symptom_defination_details.return_value = None
-
- # Call update_symptom_defination method under test
- symptom_uuid = self.mon_plugin.update_symptom_defination(symptom_defination_id,
- new_alarm_config)
-
- # Verify that mocked method is called with required parameters
- m_get_symptom_defination_details.assert_called_with(symptom_defination_id)
- m_put.assert_not_called()
-
- # Verify return value with expected value
- self.assertEqual(symptom_uuid, None)
-
- @mock.patch.object(monPlugin.requests, 'get')
- def test_get_symptom_defination_details_valid_req_response(self, m_get):
- """Test update_symptom_defination: With valid REST response symptom is created"""
-
- # Expected symptom to be updated
- symptom_uuid = 'SymptomDefinition-bcc2cb36-a67b-4deb-bcd3-9b5884973278'
-
- # Set mocked function's return values
- m_get.return_value.status_code = 200
- m_get.return_value.content = '{\
- "id": "SymptomDefinition-bcc2cb36-a67b-4deb-bcd3-9b5884973278",\
- "name": "CPU_Utilization_Above_Thr-e14b203c-6bf2-4e2f-a91c-8c19d240eda4",\
- "adapterKindKey": "VMWARE","resourceKindKey": "VirtualMachine","waitCycles": 1,\
- "cancelCycles": 1,"state": {"severity": "CRITICAL","condition": {"type": "CONDITION_HT",\
- "key": "cpu|usage_average","operator": "GT","value": "6.0","valueType": "NUMERIC",\
- "instanced": false,"thresholdType": "STATIC"}}}'
- expected_symptom_details = { \
- "id": "SymptomDefinition-bcc2cb36-a67b-4deb-bcd3-9b5884973278",
- "name": "CPU_Utilization_Above_Thr-e14b203c-6bf2-4e2f-a91c-8c19d240eda4",
- "adapterKindKey": "VMWARE", "resourceKindKey": "VirtualMachine", "waitCycles": 1,
- "cancelCycles": 1, "state": {"severity": "CRITICAL", "condition": {"type": "CONDITION_HT",
- "key": "cpu|usage_average",
- "operator": "GT", "value": "6.0",
- "valueType": "NUMERIC",
- "instanced": False,
- "thresholdType": "STATIC"}}}
-
- # Call update_symptom_defination method under test
- symptom_details = self.mon_plugin.get_symptom_defination_details(symptom_uuid)
-
- # Verify that mocked method is called with required parameters
- m_get.assert_called()
-
- # Verify return value with expected value
- self.assertEqual(expected_symptom_details, symptom_details)
-
- @mock.patch.object(monPlugin.requests, 'get')
- def test_get_symptom_defination_details_invalid_req_response(self, m_get):
- """Test update_symptom_defination: if invalid REST response received return None"""
-
- # Expected symptom to be updated
- symptom_uuid = 'SymptomDefinition-bcc2cb36-a67b-4deb-bcd3-9b5884973278'
-
- # Set mocked function's return values
- m_get.return_value.status_code = 404
- m_get.return_value.content = '{"message": "No such SymptomDefinition\
- - SymptomDefinition-bcc2cb36-a67b-4deb-bcd3-9b5884973278.",\
- "httpStatusCode": 404,"apiErrorCode": 404}'
-
- expected_symptom_details = None
-
- # Call update_symptom_defination method under test
- symptom_details = self.mon_plugin.get_symptom_defination_details(symptom_uuid)
-
- # Verify that mocked method is called with required parameters
- m_get.assert_called()
-
- # Verify return value with expected value
- self.assertEqual(expected_symptom_details, symptom_details)
-
- @mock.patch.object(monPlugin.requests, 'get')
- def test_get_symptom_defination_details_symptom_uuid_not_provided(self, m_get):
- """Test update_symptom_defination: if required symptom uuid is not provided"""
-
- # Expected symptom to be updated
- symptom_uuid = None
- expected_symptom_details = None
-
- # Call update_symptom_defination method under test
- symptom_details = self.mon_plugin.get_symptom_defination_details(symptom_uuid)
-
- # Verify that mocked method is called with required parameters
- m_get.assert_not_called()
-
- # Verify return value with expected value
- self.assertEqual(expected_symptom_details, symptom_details)
-
- @mock.patch.object(monPlugin.requests, 'put')
- def test_reconfigure_alarm_valid_req_response(self, m_put):
- """Test reconfigure_alarm: for valid REST response"""
-
- # Set input parameters to reconfigure_alarm
- alarm_details_json = {
- 'id': 'AlertDefinition-9a6d8a14-9f25-4d81-bf91-4d773497444d',
- 'name': 'CPU_Utilization_Above_Thr-e14b203c-6bf2-4e2f-a91c-8c19d240eda4',
- 'description': 'CPU_Utilization_Above_Threshold', 'adapterKindKey': 'VMWARE',
- 'states': [{'impact': {'impactType': 'BADGE', 'detail': 'risk'}, 'severity': 'CRITICAL',
- 'base-symptom-set': {
- 'symptomDefinitionIds': ['SymptomDefinition-bcc2cb36-a67b-4deb-bcd3-9b5884973278'],
- 'relation': 'SELF', 'type': 'SYMPTOM_SET', 'aggregation': 'ALL',
- 'symptomSetOperator': 'AND'}}],
- 'type': 16, 'cancelCycles': 1, 'resourceKindKey': 'VirtualMachine', 'subType': 19,
- 'waitCycles': 1}
-
- new_alarm_config = {'severity': 'WARNING',
- 'description': 'CPU_Utilization_Above_Threshold_Warning'}
-
- # Set mocked function's return values
- m_put.return_value.status_code = 200
- m_put.return_value.content = '{"id":"AlertDefinition-9a6d8a14-9f25-4d81-bf91-4d773497444d",\
- "name":"CPU_Utilization_Above_Thr-e14b203c-6bf2-4e2f-a91c-8c19d240eda4",\
- "description":"CPU_Utilization_Above_Threshold_Warning","adapterKindKey":"VMWARE",\
- "resourceKindKey":"VirtualMachine","waitCycles":1,"cancelCycles":1,"type":16,\
- "subType":19,"states":[{"severity":"WARNING","base-symptom-set":{"type":"SYMPTOM_SET",\
- "relation":"SELF","aggregation":"ALL","symptomSetOperator":"AND",\
- "symptomDefinitionIds":["SymptomDefinition-bcc2cb36-a67b-4deb-bcd3-9b5884973278"]},\
- "impact":{"impactType":"BADGE","detail":"risk"}}]}'
-
- # Expected alarm_def_uuid to be returned
- expected_alarm_def_uuid = '9a6d8a14-9f25-4d81-bf91-4d773497444d'
-
- # Call reconfigure_alarm method under test
- alarm_def_uuid = self.mon_plugin.reconfigure_alarm(alarm_details_json, new_alarm_config)
-
- # Verify that mocked method is called with required parameters
- m_put.assert_called()
-
- # Verify return value with expected value
- self.assertEqual(expected_alarm_def_uuid, alarm_def_uuid)
-
- @mock.patch.object(monPlugin.requests, 'put')
- def test_reconfigure_alarm_invalid_req_response(self, m_put):
- """Test reconfigure_alarm: for invalid REST response, return None"""
-
- # Set input parameters to reconfigure_alarm
- alarm_details_json = {
- 'id': 'AlertDefinition-9a6d8a14-9f25-4d81-bf91-4d773497444d',
- 'name': 'CPU_Utilization_Above_Thr-e14b203c-6bf2-4e2f-a91c-8c19d240eda4',
- 'description': 'CPU_Utilization_Above_Threshold', 'adapterKindKey': 'VMWARE',
- 'states': [{'impact': {'impactType': 'BADGE', 'detail': 'risk'}, 'severity': 'CRITICAL',
- 'base-symptom-set': {
- 'symptomDefinitionIds': ['SymptomDefinition-bcc2cb36-a67b-4deb-bcd3-9b5884973278'],
- 'relation': 'SELF', 'type': 'SYMPTOM_SET', 'aggregation': 'ALL',
- 'symptomSetOperator': 'AND'}}],
- 'type': 16, 'cancelCycles': 1, 'resourceKindKey': 'VirtualMachine', 'subType': 19,
- 'waitCycles': 1}
-
- new_alarm_config = {'severity': 'WARNING',
- 'description': 'CPU_Utilization_Above_Threshold_Warning'}
-
- # Set mocked function's return values
- m_put.return_value.status_code = 500
- m_put.return_value.content = '{"message": "Internal Server error, cause unknown.",\
- "moreInformation": [{"name": "errorMessage",\
- "value": "Cannot update Alert Definition CPU_Utilization_Above_Thr-\
- e14b203c-6bf2-4e2f-a91c-8c19d240eda4 since it does not exist"},\
- {"name": "localizedMessage",\
- "value": "Cannot update Alert Definition CPU_Utilization_Above_Thr-\
- e14b203c-6bf2-4e2f-a91c-8c19d240eda4 since it does not exist;"}],\
- "httpStatusCode": 500,"apiErrorCode": 500}'
-
- # Expected alarm_def_uuid to be returned
- expected_alarm_def_uuid = None
-
- # Call reconfigure_alarm method under test
- alarm_def_uuid = self.mon_plugin.reconfigure_alarm(alarm_details_json, new_alarm_config)
-
- # Verify that mocked method is called with required parameters
- m_put.assert_called()
-
- # Verify return value with expected value
- self.assertEqual(expected_alarm_def_uuid, alarm_def_uuid)
-
- @mock.patch.object(monPlugin.MonPlugin, 'delete_symptom_definition')
- @mock.patch.object(monPlugin.MonPlugin, 'delete_alarm_defination')
- @mock.patch.object(monPlugin.MonPlugin, 'delete_notification_rule')
- @mock.patch.object(monPlugin.MonPlugin, 'get_alarm_defination_details')
- def test_delete_alarm_configuration_successful_alarm_deletion(self,
- m_get_alarm_defination_details,
- m_delete_notification_rule,
- m_delete_alarm_defination,
- m_delete_symptom_definition):
- """Test delete_alarm_configuration: for successful alarm deletion, return alarm uuid"""
-
- # Set input parameters to delete_alarm_configuration
- delete_alarm_req_dict = {'alarm_uuid': '9a6d8a14-9f25-4d81-bf91-4d773497444d'}
-
- # Set mocked function's return values
- alarm_details_json = {
- 'id': 'AlertDefinition-9a6d8a14-9f25-4d81-4d773497444d',
- 'name': 'CPU_Utilization_Above_Thr-e14b203c-6bf2-4e2f-8c19d240eda4',
- 'symptomDefinitionIds': ['SymptomDefinition-bcc2cb36-a67b-4deb-9b5884973278']}
- alarm_details = {
- 'alarm_name': 'CPU_Utilization_Above_Thr-e14b203c-6bf2-4e2f-8c19d240eda4',
- 'alarm_id': 'AlertDefinition-9a6d8a14-9f25-4d81-4d773497444d',
- 'symptom_definition_id': 'SymptomDefinition-bcc2cb36-a67b-4deb-9b5884973278'}
-
- m_get_alarm_defination_details.return_value = (alarm_details_json, alarm_details)
- m_delete_notification_rule.return_value = '989e7293-d78d-4405-92e30ec4f247'
- m_delete_alarm_defination.return_value = alarm_details['alarm_id']
- m_delete_symptom_definition.return_value = alarm_details['symptom_definition_id']
-
- # Call reconfigure_alarm method under test
- alarm_uuid = self.mon_plugin.delete_alarm_configuration(delete_alarm_req_dict)
-
- # Verify that mocked method is called with required parameters
- m_get_alarm_defination_details.assert_called_with(delete_alarm_req_dict['alarm_uuid'])
- m_delete_notification_rule.assert_called_with(alarm_details['alarm_name'])
- m_delete_alarm_defination.assert_called_with(alarm_details['alarm_id'])
- m_delete_symptom_definition.assert_called_with(alarm_details['symptom_definition_id'])
-
- # Verify return value with expected value
- self.assertEqual(alarm_uuid, delete_alarm_req_dict['alarm_uuid'])
-
- @mock.patch.object(monPlugin.MonPlugin, 'delete_symptom_definition')
- @mock.patch.object(monPlugin.MonPlugin, 'delete_alarm_defination')
- @mock.patch.object(monPlugin.MonPlugin, 'delete_notification_rule')
- @mock.patch.object(monPlugin.MonPlugin, 'get_alarm_defination_details')
- def test_delete_alarm_configuration_failed_to_get_alarm_defination(self,
- m_get_alarm_defination_details,
- m_delete_notification_rule,
- m_delete_alarm_defination,
- m_delete_symptom_definition):
- """Test delete_alarm_configuration: if failed to get alarm definition, return None"""
-
- # Set input parameters to delete_alarm_configuration
- delete_alarm_req_dict = {'alarm_uuid': '9a6d8a14-9f25-4d81-bf91-4d773497444d'}
-
- # Set mocked function's return values
- alarm_details_json = None
- alarm_details = None
-
- m_get_alarm_defination_details.return_value = (alarm_details_json, alarm_details)
-
- # Call reconfigure_alarm method under test
- alarm_uuid = self.mon_plugin.delete_alarm_configuration(delete_alarm_req_dict)
-
- # Verify that mocked method is called with required parameters
- m_get_alarm_defination_details.assert_called_with(delete_alarm_req_dict['alarm_uuid'])
- m_delete_notification_rule.assert_not_called()
- m_delete_alarm_defination.assert_not_called()
- m_delete_symptom_definition.assert_not_called()
-
- # Verify return value with expected value
- self.assertEqual(alarm_uuid, None)
-
- @mock.patch.object(monPlugin.MonPlugin, 'delete_symptom_definition')
- @mock.patch.object(monPlugin.MonPlugin, 'delete_alarm_defination')
- @mock.patch.object(monPlugin.MonPlugin, 'delete_notification_rule')
- @mock.patch.object(monPlugin.MonPlugin, 'get_alarm_defination_details')
- def test_delete_alarm_configuration_failed_to_delete_notification_rule(self,
- m_get_alarm_defination_details,
- m_delete_notification_rule,
- m_delete_alarm_defination,
- m_delete_symptom_definition):
- """Test delete_alarm_configuration: if failed to delete notification rule, return None"""
-
- # Set input parameters to delete_alarm_configuration
- delete_alarm_req_dict = {'alarm_uuid': '9a6d8a14-9f25-4d81-bf91-4d773497444d'}
-
- # Set mocked function's return values
- alarm_details_json = {
- 'id': 'AlertDefinition-9a6d8a14-9f25-4d81-4d773497444d',
- 'name': 'CPU_Utilization_Above_Thr-e14b203c-6bf2-4e2f-8c19d240eda4',
- 'symptomDefinitionIds': ['SymptomDefinition-bcc2cb36-a67b-4deb-9b5884973278']}
- alarm_details = {
- 'alarm_name': 'CPU_Utilization_Above_Thr-e14b203c-6bf2-4e2f-8c19d240eda4',
- 'alarm_id': 'AlertDefinition-9a6d8a14-9f25-4d81-4d773497444d',
- 'symptom_definition_id': 'SymptomDefinition-bcc2cb36-a67b-4deb-9b5884973278'}
-
- m_get_alarm_defination_details.return_value = (alarm_details_json, alarm_details)
- m_delete_notification_rule.return_value = None
-
- # Call reconfigure_alarm method under test
- alarm_uuid = self.mon_plugin.delete_alarm_configuration(delete_alarm_req_dict)
-
- # Verify that mocked method is called with required parameters
- m_get_alarm_defination_details.assert_called_with(delete_alarm_req_dict['alarm_uuid'])
- m_delete_notification_rule.assert_called_with(alarm_details['alarm_name'])
- m_delete_alarm_defination.assert_not_called()
- m_delete_symptom_definition.assert_not_called()
-
- # Verify return value with expected value
- self.assertEqual(alarm_uuid, None)
-
- @mock.patch.object(monPlugin.MonPlugin, 'delete_symptom_definition')
- @mock.patch.object(monPlugin.MonPlugin, 'delete_alarm_defination')
- @mock.patch.object(monPlugin.MonPlugin, 'delete_notification_rule')
- @mock.patch.object(monPlugin.MonPlugin, 'get_alarm_defination_details')
- def test_delete_alarm_configuration_failed_to_delete_alarm_defination(self,
- m_get_alarm_defination_details,
- m_delete_notification_rule,
- m_delete_alarm_defination,
- m_delete_symptom_definition):
- """Test delete_alarm_configuration: if failed to delete alarm definition, return None"""
-
- # Set input parameters to delete_alarm_configuration
- delete_alarm_req_dict = {'alarm_uuid': '9a6d8a14-9f25-4d81-bf91-4d773497444d'}
-
- # Set mocked function's return values
- alarm_details_json = {
- 'id': 'AlertDefinition-9a6d8a14-9f25-4d81-4d773497444d',
- 'name': 'CPU_Utilization_Above_Thr-e14b203c-6bf2-4e2f-8c19d240eda4',
- 'symptomDefinitionIds': ['SymptomDefinition-bcc2cb36-a67b-4deb-9b5884973278']}
- alarm_details = {
- 'alarm_name': 'CPU_Utilization_Above_Thr-e14b203c-6bf2-4e2f-8c19d240eda4',
- 'alarm_id': 'AlertDefinition-9a6d8a14-9f25-4d81-4d773497444d',
- 'symptom_definition_id': 'SymptomDefinition-bcc2cb36-a67b-4deb-9b5884973278'}
-
- m_get_alarm_defination_details.return_value = (alarm_details_json, alarm_details)
- m_delete_notification_rule.return_value = '989e7293-d78d-4405-92e30ec4f247'
- m_delete_alarm_defination.return_value = None
-
- # Call reconfigure_alarm method under test
- alarm_uuid = self.mon_plugin.delete_alarm_configuration(delete_alarm_req_dict)
-
- # Verify that mocked method is called with required parameters
- m_get_alarm_defination_details.assert_called_with(delete_alarm_req_dict['alarm_uuid'])
- m_delete_notification_rule.assert_called_with(alarm_details['alarm_name'])
- m_delete_alarm_defination.assert_called_with(alarm_details['alarm_id'])
- m_delete_symptom_definition.assert_not_called()
-
- # Verify return value with expected value
- self.assertEqual(alarm_uuid, None)
-
- @mock.patch.object(monPlugin.MonPlugin, 'delete_symptom_definition')
- @mock.patch.object(monPlugin.MonPlugin, 'delete_alarm_defination')
- @mock.patch.object(monPlugin.MonPlugin, 'delete_notification_rule')
- @mock.patch.object(monPlugin.MonPlugin, 'get_alarm_defination_details')
- def test_delete_alarm_configuration_failed_to_delete_symptom_definition(self,
- m_get_alarm_defination_details,
- m_delete_notification_rule,
- m_delete_alarm_defination,
- m_delete_symptom_definition):
- """Test delete_alarm_configuration: if failed to delete symptom definition, return None"""
-
- # Set input parameters to delete_alarm_configuration
- delete_alarm_req_dict = {'alarm_uuid': '9a6d8a14-9f25-4d81-bf91-4d773497444d'}
-
- # Set mocked function's return values
- alarm_details_json = {
- 'id': 'AlertDefinition-9a6d8a14-9f25-4d81-4d773497444d',
- 'name': 'CPU_Utilization_Above_Thr-e14b203c-6bf2-4e2f-8c19d240eda4',
- 'symptomDefinitionIds': ['SymptomDefinition-bcc2cb36-a67b-4deb-9b5884973278']}
- alarm_details = {
- 'alarm_name': 'CPU_Utilization_Above_Thr-e14b203c-6bf2-4e2f-8c19d240eda4',
- 'alarm_id': 'AlertDefinition-9a6d8a14-9f25-4d81-4d773497444d',
- 'symptom_definition_id': 'SymptomDefinition-bcc2cb36-a67b-4deb-9b5884973278'}
-
- m_get_alarm_defination_details.return_value = (alarm_details_json, alarm_details)
- m_delete_notification_rule.return_value = '989e7293-d78d-4405-92e30ec4f247'
- m_delete_alarm_defination.return_value = alarm_details['alarm_id']
- m_delete_symptom_definition.return_value = None
-
- # Call reconfigure_alarm method under test
- alarm_uuid = self.mon_plugin.delete_alarm_configuration(delete_alarm_req_dict)
-
- # Verify that mocked method is called with required parameters
- m_get_alarm_defination_details.assert_called_with(delete_alarm_req_dict['alarm_uuid'])
- m_delete_notification_rule.assert_called_with(alarm_details['alarm_name'])
- m_delete_alarm_defination.assert_called_with(alarm_details['alarm_id'])
- m_delete_symptom_definition.assert_called_with(alarm_details['symptom_definition_id'])
-
- # Verify return value with expected value
- self.assertEqual(alarm_uuid, None)
-
- @mock.patch.object(monPlugin.requests, 'delete')
- @mock.patch.object(monPlugin.MonPlugin, 'get_notification_rule_id_by_alarm_name')
- def test_delete_notification_rule_successful_deletion_req_response(self,
- m_get_notification_rule_id_by_alarm_name,
- m_delete):
- """Test delete_notification_rule: Valid notification rule is deleted & returns rule_id"""
-
- # Set input parameters to delete_notification_rule
- alarm_name = 'CPU_Utilization_Above_Thr-e14b203c-6bf2-4e2f-8c19d240eda4'
-
- # Set mocked function's return values
- m_get_notification_rule_id_by_alarm_name.return_value = '8db86441-71d8-4830-9e1a-a90be3776d12'
- m_delete.return_value.status_code = 204
-
- # Call delete_notification_rule method under test
- rule_id = self.mon_plugin.delete_notification_rule(alarm_name)
-
- # Verify that mocked method is called with required parameters
- m_get_notification_rule_id_by_alarm_name.assert_called_with(alarm_name)
- m_delete.assert_called()
-
- # Verify return value with expected value
- self.assertEqual(rule_id, '8db86441-71d8-4830-9e1a-a90be3776d12')
-
- @mock.patch.object(monPlugin.requests, 'delete')
- @mock.patch.object(monPlugin.MonPlugin, 'get_notification_rule_id_by_alarm_name')
- def test_delete_notification_rule_failed_to_get_notification_rule_id(self,
- m_get_notification_rule_id_by_alarm_name,
- m_delete):
- """Test delete_notification_rule: if notification rule is not found, returns None"""
-
- # Set input parameters to delete_notification_rule
- alarm_name = 'CPU_Utilization_Above_Thr-e14b203c-6bf2-4e2f-8c19d240eda4'
-
- # Set mocked function's return values
- m_get_notification_rule_id_by_alarm_name.return_value = None
-
- # Call delete_notification_rule method under test
- rule_id = self.mon_plugin.delete_notification_rule(alarm_name)
-
- # Verify that mocked method is called with required parameters
- m_get_notification_rule_id_by_alarm_name.assert_called_with(alarm_name)
- m_delete.assert_not_called()
-
- # verify return value with expected value
- self.assertEqual(rule_id, None)
-
- @mock.patch.object(monPlugin.requests, 'delete')
- @mock.patch.object(monPlugin.MonPlugin, 'get_notification_rule_id_by_alarm_name')
- def test_delete_notification_rule_invalid_deletion_req_response(self,
- m_get_notification_rule_id_by_alarm_name,
- m_delete):
- """Test delete_notification_rule: If an invalid response is received, returns None"""
-
- # Set input parameters to delete_notification_rule
- alarm_name = 'CPU_Utilization_Above_Thr-e14b203c-6bf2-4e2f-8c19d240eda4'
-
- # Set mocked function's return values
- m_get_notification_rule_id_by_alarm_name.return_value = '8db86441-71d8-4830-9e1a-a90be3776d12'
- m_delete.return_value.status_code = 404
-
- # Call delete_notification_rule method under test
- rule_id = self.mon_plugin.delete_notification_rule(alarm_name)
-
- # Verify that mocked method is called with required parameters
- m_get_notification_rule_id_by_alarm_name.assert_called_with(alarm_name)
- m_delete.assert_called()
-
- # Verify return value with expected value
- self.assertEqual(rule_id, None)
-
- @mock.patch.object(monPlugin.requests, 'get')
- def test_get_notification_rule_id_by_alarm_name_valid_req_response(self, m_get):
- """Test get_notification_rule_id_by_alarm_name: A valid request response received,
- returns notification_id
- """
-
- # Set input parameters to get_notification_rule_id_by_alarm_name
- alarm_name = 'CPU_Utilization_Above_Thr-e14b203c-6bf2-4e2f-a91c-8c19d240eda4'
-
- # Set mocked function's return values
- m_get.return_value.status_code = 200
- m_get.return_value.content = '{\
- "pageInfo": {"totalCount": 0,"page": 0,"pageSize": 1000},\
- "links": [\
- {"href": "/suite-api/api/notifications/rules?page=0&pageSize=1000",\
- "rel": "SELF","name": "current"},\
- {"href": "/suite-api/api/notifications/rules?page=0&pageSize=1000",\
- "rel": "RELATED","name": "first"},\
- {"href": "/suite-api/api/notifications/rules?page=0&pageSize=1000",\
- "rel": "RELATED","name": "last"}],\
- "notification-rule": [{\
- "id": "2b86fa23-0c15-445c-a2b1-7bd725c46f59",\
- "name": "notify_CPU_Utilization_Above_Thr-e14b203c-6bf2-4e2f-a91c-8c19d240eda4",\
- "pluginId": "03053f51-f829-438d-993d-cc33a435d76a",\
- "links": [{"href": "/suite-api/api/notifications/rules/2b86fa23-0c15-445c-a2b1-7bd725c46f59",\
- "rel": "SELF","name": "linkToSelf"}]}]}'
-
- # Call get_notification_rule_id_by_alarm_name method under test
- notification_id = self.mon_plugin.get_notification_rule_id_by_alarm_name(alarm_name)
-
- # Verify that mocked method is called with required parameters
- m_get.assert_called()
-
- # Verify return value with expected value
- self.assertEqual(notification_id, '2b86fa23-0c15-445c-a2b1-7bd725c46f59')
-
- @mock.patch.object(monPlugin.requests, 'get')
- def test_get_notification_rule_id_by_alarm_name_invalid_req_response(self, m_get):
- """Test get_notification_rule_id_by_alarm_name: If an invalid response received,\
- returns None
- """
-
- # Set input parameters to delete_alarm_configuration
- alarm_name = 'CPU_Utilization_Above_Thr-e14b203c-6bf2-4e2f-a91c-8c19d240eda4'
-
- # Set mocked function's return values
- m_get.return_value.status_code = 404
-
- # Call get_notification_rule_id_by_alarm_name method under test
- notification_id = self.mon_plugin.get_notification_rule_id_by_alarm_name(alarm_name)
-
- # Verify that mocked method is called with required parameters
- m_get.assert_called()
-
- # Verify return value with expected value
- self.assertEqual(notification_id, None)
-
- @mock.patch.object(monPlugin.requests, 'get')
- def test_get_notification_rule_id_by_alarm_name_rule_not_found(self, m_get):
- """Test get_notification_rule_id_by_alarm_name: If a notification rule is not found,
- returns None
- """
-
- # Set input parameters to delete_alarm_configuration
- alarm_name = 'CPU_Utilization_Above_Thr-e14b203c-6bf2-4e2f-a91c-8c19d240eda'
-
- # Set mocked function's return values
- m_get.return_value.status_code = 200
- m_get.return_value.content = '{\
- "pageInfo": {"totalCount": 0,"page": 0,"pageSize": 1000},\
- "links": [\
- {"href": "/suite-api/api/notifications/rules?page=0&pageSize=1000",\
- "rel": "SELF","name": "current"},\
- {"href": "/suite-api/api/notifications/rules?page=0&pageSize=1000",\
- "rel": "RELATED","name": "first"},\
- {"href": "/suite-api/api/notifications/rules?page=0&pageSize=1000",\
- "rel": "RELATED","name": "last"}],\
- "notification-rule": [{\
- "id": "2b86fa23-0c15-445c-a2b1-7bd725c46f59",\
- "name": "notify_CPU_Utilization_Above_Thr-e14b203c-6bf2-4e2f-a91c-8c19d240eda4",\
- "pluginId": "03053f51-f829-438d-993d-cc33a435d76a",\
- "links": [{"href": "/suite-api/api/notifications/rules/2b86fa23-0c15-445c-a2b1-7bd725c46f59",\
- "rel": "SELF","name": "linkToSelf"}]}]}'
-
- # Call get_notification_rule_id_by_alarm_name method under test
- notification_id = self.mon_plugin.get_notification_rule_id_by_alarm_name(alarm_name)
-
- # Verify that mocked method is called with required parameters
- m_get.assert_called()
-
- # Verify return value with expected value
- self.assertEqual(notification_id, None)
-
- @mock.patch.object(monPlugin.requests, 'delete')
- def test_delete_alarm_defination_valid_req_response(self, m_delete):
- """Test delete_alarm_defination: A valid request response received,
- returns symptom_id
- """
-
- # Set input parameters to delete_alarm_definition
- alarm_definition_id = 'AlertDefinition-9a6d8a14-9f25-4d81-4d773497444d'
-
- # Set mocked function's return values
- m_delete.return_value.status_code = 204
-
- # Call delete_alarm_defination method under test
- actual_alarm_id = self.mon_plugin.delete_alarm_defination(alarm_definition_id)
-
- # Verify that mocked method is called with required parameters
- m_delete.assert_called()
-
- # Verify return value with expected value
- self.assertEqual(actual_alarm_id, alarm_definition_id)
-
- @mock.patch.object(monPlugin.requests, 'delete')
- def test_delete_alarm_defination_invalid_req_response(self, m_delete):
- """Test delete_alarm_defination: If an invalid request response received,
- returns None
- """
-
- # Set input parameters to delete_alarm_definition
- alarm_definition_id = 'AlertDefinition-9a6d8a14-9f25-4d81-4d773497444d'
-
- # Set mocked function's return values
- m_delete.return_value.status_code = 404
-
- # Call delete_alarm_defination method under test
- actual_alarm_id = self.mon_plugin.delete_alarm_defination(alarm_definition_id)
-
- # Verify that mocked method is called with required parameters
- m_delete.assert_called()
-
- # Verify return value with expected value
- self.assertEqual(actual_alarm_id, None)
-
- @mock.patch.object(monPlugin.requests, 'delete')
- def test_delete_symptom_definition_valid_req_response(self, m_delete):
- """Test delete_symptom_definition: A valid request response received,
- returns symptom_id
- """
-
- # Set input parameters to delete_symptom_definition
- symptom_definition_id = 'SymptomDefinition-bcc2cb36-a67b-4deb-9b5884973278'
-
- # Set mocked function's return values
- m_delete.return_value.status_code = 204
-
- # Call delete_symptom_definition method under test
- actual_symptom_id = self.mon_plugin.delete_symptom_definition(symptom_definition_id)
-
- # Verify that mocked method is called with required parameters
- m_delete.assert_called()
-
- # Verify return value with expected value
- self.assertEqual(actual_symptom_id, symptom_definition_id)
-
- @mock.patch.object(monPlugin.requests, 'delete')
- def test_delete_symptom_definition_invalid_req_response(self, m_delete):
- """Test delete_symptom_definition: If an invalid request response received,
- returns None
- """
-
- # Set input parameters to delete_symptom_definition
- symptom_definition_id = 'SymptomDefinition-bcc2cb36-a67b-4deb-9b5884973278'
-
- # Set mocked function's return values
- m_delete.return_value.status_code = 404
-
- # Call delete_symptom_definition method under test
- actual_symptom_id = self.mon_plugin.delete_symptom_definition(symptom_definition_id)
-
- # Verify that mocked method is called with required parameters
- m_delete.assert_called()
-
- # Verify return value with expected value
- self.assertEqual(actual_symptom_id, None)
-
- @mock.patch.object(monPlugin.requests, 'post')
- @mock.patch.object(monPlugin.MonPlugin, 'check_if_plugin_configured')
- def test_configure_rest_plugin_valid_plugin_id(self, m_check_if_plugin_configured, m_post):
- """Test configure rest plugin method-valid plugin id"""
-
- # mock return values
- expected_return = m_check_if_plugin_configured.return_value = "mock_pluginid"
-
- # call configure rest plugin method under test
- actual_return = self.mon_plugin.configure_rest_plugin()
-
- # verify that mocked method is called
- m_check_if_plugin_configured.assert_called()
- m_post.assert_not_called()
-
- # verify return value with expected value
- self.assertEqual(expected_return, actual_return)
-
- @mock.patch.object(monPlugin.MonPlugin, 'enable_rest_plugin')
- @mock.patch.object(monPlugin.requests, 'post')
- @mock.patch.object(monPlugin.MonPlugin, 'check_if_plugin_configured')
- def est_configure_rest_plugin_invalid_plugin_id(self, m_check_if_plugin_configured, m_post, m_enable_rest_plugin):
- """Test configure rest plugin method-invalid plugin id"""
-
- # mock return values
- m_check_if_plugin_configured.return_value = None # not configured
- m_post.return_value.status_code = 201 # success
- m_post.return_value.content = '{"pluginTypeId":"RestPlugin","pluginId":"1ef15663-9739-49fe-8c41-022bcc9f690c",\
- "name":"MON_module_REST_Plugin","version":1518693747871,"enabled":false,\
- "configValues":[{"name":"Url","value":"https://MON.lxd:8080/notify/"},\
- {"name":"Content-type","value":"application/json"},{"name":"Certificate",\
- "value":"AA:E7:3E:A5:34:E0:25:FB:28:84:3B:74:B2:18:74:C0:C3:E8:26:50"},\
- {"name":"ConnectionCount","value":"20"}]}'
-
- m_enable_rest_plugin.return_value = True # success
- expected_return = '1ef15663-9739-49fe-8c41-022bcc9f690c'
-
- # call configure rest plugin method under test
- actual_return = self.mon_plugin.configure_rest_plugin()
-
- # verify that mocked method is called
- m_check_if_plugin_configured.assert_called()
- m_post.assert_called()
- m_enable_rest_plugin.assert_called_with('1ef15663-9739-49fe-8c41-022bcc9f690c', 'MON_module_REST_Plugin')
-
- # verify return value with expected value
- self.assertEqual(expected_return, actual_return)
-
- @mock.patch.object(monPlugin.MonPlugin, 'enable_rest_plugin')
- @mock.patch.object(monPlugin.requests, 'post')
- @mock.patch.object(monPlugin.MonPlugin, 'check_if_plugin_configured')
- def est_configure_rest_plugin_failed_to_enable_plugin(self, m_check_if_plugin_configured, m_post,
- m_enable_rest_plugin):
- """Test configure rest plugin method-failed to enable plugin case"""
-
- # mock return values
- m_check_if_plugin_configured.return_value = None # not configured
- m_post.return_value.status_code = 201 # success
- m_post.return_value.content = '{"pluginTypeId":"RestPlugin","pluginId":"1ef15663-9739-49fe-8c41-022bcc9f690c",\
- "name":"MON_module_REST_Plugin","version":1518693747871,"enabled":false,\
- "configValues":[{"name":"Url","value":"https://MON.lxd:8080/notify/"},\
- {"name":"Content-type","value":"application/json"},{"name":"Certificate",\
- "value":"AA:E7:3E:A5:34:E0:25:FB:28:84:3B:74:B2:18:74:C0:C3:E8:26:50"},\
- {"name":"ConnectionCount","value":"20"}]}'
-
- m_enable_rest_plugin.return_value = False # return failure
- expected_return = None
-
- # call configure rest plugin method under test
- actual_return = self.mon_plugin.configure_rest_plugin()
-
- # verify that mocked method is called
- m_check_if_plugin_configured.assert_called()
- m_post.assert_called()
- m_enable_rest_plugin.assert_called_with('1ef15663-9739-49fe-8c41-022bcc9f690c', 'MON_module_REST_Plugin')
-
- # verify return value with expected value
- self.assertEqual(expected_return, actual_return)
-
- @mock.patch.object(monPlugin.requests, 'get')
- def test_check_if_plugin_configured_valid_req_response(self, m_get):
- """Test check if plugin configured method-valid request response"""
-
- plugin_name = 'MON_module_REST_Plugin'
- # mock return values
- m_get.return_value.status_code = 200
- expected_return = '1ef15663-9739-49fe-8c41-022bcc9f690c'
- m_get.return_value.content = '{"notificationPluginInstances":\
- [{"pluginTypeId":"RestPlugin",\
- "pluginId":"1ef15663-9739-49fe-8c41-022bcc9f690c",\
- "name":"MON_module_REST_Plugin","version":1518694966987,\
- "enabled":true,"configValues":[{"name":"Url",\
- "value":"https://MON.lxd:8080/notify/"},\
- {"name":"Content-type","value":"application/json"},\
- {"name":"Certificate",\
- "value":"AA:E7:3E:A5:34:E0:25:FB:28:84:3B:74:B2:18:74:C0"},\
- {"name":"ConnectionCount","value":"20"}]}]}'
-
- # call check if plugin configured method under test
- actual_return = self.mon_plugin.check_if_plugin_configured(plugin_name)
-
- # verify that mocked method is called
- m_get.assert_called()
-
- # verify return value with expected value
- self.assertEqual(expected_return, actual_return)
-
- @mock.patch.object(monPlugin.requests, 'get')
- def test_check_if_plugin_configured_invalid_req_response(self, m_get):
- """Test check if plugin configured method-invalid request response"""
-
- plugin_name = 'MON_module_REST_Plugin'
- # mock return values
- m_get.return_value.status_code = 201
- expected_return = None
- m_get.return_value.content = '{"notificationPluginInstances":\
- [{"pluginTypeId":"RestPlugin",\
- "pluginId":"1ef15663-9739-49fe-8c41-022bcc9f690c",\
- "name":"MON_module_REST_Plugin","version":1518694966987,\
- "enabled":true,"configValues":[{"name":"Url",\
- "value":"https://MON.lxd:8080/notify/"},\
- {"name":"Content-type","value":"application/json"},\
- {"name":"Certificate",\
- "value":"AA:E7:3E:A5:34:E0:25:FB:28:84:3B:74:B2:18:74:C0"},\
- {"name":"ConnectionCount","value":"20"}]}]}'
-
- # call check if plugin configured method under test
- actual_return = self.mon_plugin.check_if_plugin_configured(plugin_name)
-
- # verify that mocked method is called
- m_get.assert_called()
-
- # verify return value with expected value
- self.assertEqual(expected_return, actual_return)
-
- @mock.patch.object(monPlugin.requests, 'put')
- def test_enable_rest_plugin_valid_req_response(self, m_put):
- """Test enable rest plugin method-valid request response"""
-
- plugin_name = 'MON_module_REST_Plugin'
- plugin_id = '1ef15663-9739-49fe-8c41-022bcc9f690c'
- # mock return values
- m_put.return_value.status_code = 204
- expected_return = True
- m_put.return_value.content = ''
-
- # call enable rest plugin configured method under test
- actual_return = self.mon_plugin.enable_rest_plugin(plugin_id, plugin_name)
-
- # verify that mocked method is called
- m_put.assert_called()
-
- # verify return value with expected value
- self.assertEqual(expected_return, actual_return)
-
- @mock.patch.object(monPlugin.requests, 'put')
- def test_enable_rest_plugin_invalid_req_response(self, m_put):
- """Test enable rest plugin method-invalid request response"""
-
- plugin_name = 'MON_module_REST_Plugin'
- plugin_id = '08018c0f-8879-4ca1-9b92-00e22d2ff81b' # invalid plugin id
- # mock return values
- m_put.return_value.status_code = 404 # api Error code
- expected_return = False
- m_put.return_value.content = '<?xml version="1.0" encoding="UTF-8" standalone="yes"?><ops:\
- error xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" \
- xmlns:xs="http://www.w3.org/2001/XMLSchema" xmlns:ops=\
- "http://webservice.vmware.com/vRealizeOpsMgr/1.0/" \
- httpStatusCode="404" apiErrorCode="404"><ops:message>\
- No such Notification Plugin - 08018c0f-8879-4ca1-9b92-\
- 00e22d2ff81b.</ops:message></ops:error>'
-
- # call enable rest plugin configured method under test
- actual_return = self.mon_plugin.enable_rest_plugin(plugin_id, plugin_name)
-
- # verify that mocked method is called
- m_put.assert_called()
-
- # verify return value with expected value
- self.assertEqual(expected_return, actual_return)
-
- @mock.patch.object(monPlugin.requests, 'post')
- @mock.patch.object(monPlugin.MonPlugin, 'check_if_plugin_configured')
- def test_create_alarm_notification_rule_valid_req(self, m_check_if_plugin_configured, m_post):
- """Test create alarm notification rule method valid request response"""
-
- alarm_name = 'CPU_Utilization_Above_Thr-e14b203c-6bf2-4e2f-a91c-8c19d240eda4'
- alarm_id = 'AlertDefinition-f1163767-6eac-438f-8e60-a7a867257e14'
- res_id = 'ac87622f-b761-40a0-b151-00872a2a456e'
- expected_return = "8db86441-71d8-4830-9e1a-a90be3776d12"
-
- # mock return values
- m_check_if_plugin_configured.return_value = '03053f51-f829-438d-993d-cc33a435d76a'
- m_post.return_value.status_code = 201
- m_post.return_value.content = '{"id":"8db86441-71d8-4830-9e1a-a90be3776d12",\
- "name":"notify_CPU_Utilization_Above_Thr-e14b203c",\
- "pluginId":"03053f51-f829-438d-993d-cc33a435d76a",\
- "alertControlStates":[],"alertStatuses":[],\
- "resourceFilter":{"matchResourceIdOnly":true,\
- "childrenResourceKindFilters":[],\
- "resourceId":"ac87622f-b761-40a0-b151-00872a2a456e"},\
- "alertTypeFilters":[],"alertDefinitionIdFilters":{"values":[\
- "AlertDefinition-f1163767-6eac-438f-8e60-a7a867257e14"]}}'
-
- # call enable rest plugin configured method under test
- actual_return = self.mon_plugin.create_alarm_notification_rule(alarm_name, alarm_id, res_id)
-
- # verify that mocked method is called
- m_check_if_plugin_configured.assert_called_with('MON_module_REST_Plugin')
- m_post.assert_called()
-
- # verify return value with expected value
- self.assertEqual(expected_return, actual_return)
-
- @mock.patch.object(monPlugin.requests, 'post')
- @mock.patch.object(monPlugin.MonPlugin, 'check_if_plugin_configured')
- def test_create_alarm_notification_rule_invalid_req(self, m_check_if_plugin_configured, m_post):
- """Test create alarm notification rule method invalid request response"""
-
- alarm_name = 'CPU_Utilization_Above_Thr-e14b203c-6bf2-4e2f-a91c-8c19d240eda4'
- alarm_id = 'AlertDefinition-f1163767-6eac-438f-8e60-a7a867257e14'
- res_id = 'ac87622f-b761-40a0-b151-00872a2a456e'
- expected_return = None # invalid req should retrun none
-
- # mock return values
- m_check_if_plugin_configured.return_value = '03053f51-f829-438d-993d-cc33a435d76a'
- m_post.return_value.status_code = 500
- m_post.return_value.content = '{"message":"Internal Server error, cause unknown.",\
- "moreInformation":[{"name":"errorMessage","value":\
- "there is already a rule with the same rule name"},\
- {"name":"localizedMessage","value":"there is already \
- a rule with the same rule name;"}],"httpStatusCode":500,\
- "apiErrorCode":500}'
-
- # call enable rest plugin configured method under test
- actual_return = self.mon_plugin.create_alarm_notification_rule(alarm_name, alarm_id, res_id)
-
- # verify that mocked method is called
- m_check_if_plugin_configured.assert_called_with('MON_module_REST_Plugin')
- m_post.assert_called()
-
- # verify return value with expected value
- self.assertEqual(expected_return, actual_return)
-
- @mock.patch.object(monPlugin.requests, 'post')
- @mock.patch.object(monPlugin.MonPlugin, 'check_if_plugin_configured')
- def test_create_alarm_notification_rule_failed_to_get_plugin_id(self,
- m_check_if_plugin_configured, m_post):
- """Test create alarm notification rule method invalid plugin id"""
-
- alarm_name = 'CPU_Utilization_Above_Thr-e14b203c-6bf2-4e2f-a91c-8c19d240eda4'
- alarm_id = 'AlertDefinition-f1163767-6eac-438f-8e60-a7a867257e14'
- res_id = 'ac87622f-b761-40a0-b151-00872a2a456e'
- expected_return = None # invalid req should retrun none
-
- # mock return values
- m_check_if_plugin_configured.return_value = None
-
- # call enable rest plugin configured method under test
- actual_return = self.mon_plugin.create_alarm_notification_rule(alarm_name, alarm_id, res_id)
-
- # verify that mocked method is called
- m_check_if_plugin_configured.assert_called_with('MON_module_REST_Plugin')
- m_post.assert_not_called()
-
- # verify return value with expected value
- self.assertEqual(expected_return, actual_return)
-
- @mock.patch.object(monPlugin.requests, 'get')
- @mock.patch.object(monPlugin.MonPlugin, 'get_vm_resource_id')
- @mock.patch.object(monPlugin.MonPlugin, 'get_vm_moref_id')
- @mock.patch.object(monPlugin.MonPlugin, 'get_default_Params')
- def test_get_metrics_data_valid_rest_req_response(self, m_get_default_Params,
- m_get_vm_moref_id,
- m_get_vm_resource_id,
- m_get):
- """Test get metrics data of resource method valid request response"""
-
- metrics = {'collection_period': 1, 'metric_name': 'CPU_UTILIZATION', 'metric_uuid': None,
- 'schema_version': 1.0, 'resource_uuid': 'e14b203c-6bf2-4e2f-a91c-8c19d240eda4',
- 'correlation_id': 'e14b203c-6bf2-4e2f-a91c-8c19d2abcdef',
- 'schema_type': 'read_metric_data_request', 'vim_type': 'VMware',
- 'collection_unit': 'HR', 'vim_uuid': '1'}
-
- # mock return value
- m_get_default_Params.return_value = {'metric_key': 'cpu|usage_average', 'unit': '%'}
- vm_moref_id = m_get_vm_moref_id.return_value = 'vm-6626'
- m_get_vm_resource_id.return_value = 'ac87622f-b761-40a0-b151-00872a2a456e'
- m_get.return_value.status_code = 200
- m_get.return_value.content = '{"values":[{"resourceId":"ac87622f-b761-40a0-b151-\
- 00872a2a456e","stat-list":{"stat":[{"timestamps":\
- [1519716874297,1519717174294,1519717474295,1519717774298,\
- 1519718074300,1519718374299,1519718674314,1519718974325,\
- 1519719274304,1519719574298,1519719874298,1519720174301],\
- "statKey":{"key":"cpu|usage_average"},"intervalUnit":\
- {"quantifier":1},"data":[0.1120000034570694,\
- 0.11866666376590729,0.11599999666213989,0.11400000005960464,\
- 0.12066666781902313,0.11533333361148834,0.11800000071525574,\
- 0.11533333361148834,0.12200000137090683,0.11400000005960464,\
- 0.1459999978542328,0.12133333086967468]}]}}]}'
-
- # call get matrics data method under test
- actual_return = self.mon_plugin.get_metrics_data(metrics)
-
- # verify that mocked method is called
- m_get_default_Params.assert_called_with(metrics['metric_name'])
- m_get_vm_moref_id.assert_called_with(metrics['resource_uuid'])
- m_get_vm_resource_id.assert_called_with(vm_moref_id)
- m_get.assert_called()
-
- # verify return value with expected value
- # self.assertEqual(expected_return, actual_return)
-
- @mock.patch.object(monPlugin.requests, 'get')
- @mock.patch.object(monPlugin.MonPlugin, 'get_vm_resource_id')
- @mock.patch.object(monPlugin.MonPlugin, 'get_vm_moref_id')
- @mock.patch.object(monPlugin.MonPlugin, 'get_default_Params')
- def test_get_metrics_data_invalid_rest_req_response(self, m_get_default_Params,
- m_get_vm_moref_id,
- m_get_vm_resource_id,
- m_get):
- """Test get metrics data of resource method invalid request response"""
-
- metrics = {'collection_period': 1, 'metric_name': 'CPU_UTILIZATION', 'metric_uuid': None,
- 'schema_version': 1.0, 'resource_uuid': 'e14b203c-6bf2-4e2f-a91c-8c19d240eda4',
- 'correlation_id': 'e14b203c-6bf2-4e2f-a91c-8c19d2abcdef',
- 'schema_type': 'read_metric_data_request', 'vim_type': 'VMware',
- 'collection_unit': 'HR', 'vim_uuid': '1'}
-
- # mock return value
- m_get_default_Params.return_value = {'metric_key': 'cpu|usage_average', 'unit': '%'}
- vm_moref_id = m_get_vm_moref_id.return_value = 'vm-6626'
- m_get_vm_resource_id.return_value = 'ac87622f-b761-40a0-b151-00872a2a456e'
- m_get.return_value.status_code = 400
- expected_return = {'metric_name': 'CPU_UTILIZATION', 'metric_uuid': '0',
- 'schema_version': '1.0',
- 'resource_uuid': 'e14b203c-6bf2-4e2f-a91c-8c19d240eda4',
- 'correlation_id': 'e14b203c-6bf2-4e2f-a91c-8c19d2abcdef',
- 'metrics_data': {'time_series': [], 'metrics_series': []},
- 'schema_type': 'read_metric_data_response',
- 'unit': '%', 'vim_uuid': '1'}
-
- # call get metrics data method under test
- actual_return = self.mon_plugin.get_metrics_data(metrics)
-
- # verify that mocked method is called
- m_get_default_Params.assert_called_with(metrics['metric_name'])
- m_get_vm_moref_id.assert_called_with(metrics['resource_uuid'])
- m_get_vm_resource_id.assert_called_with(vm_moref_id)
- m_get.assert_called()
-
- m_get.return_value.content = '{"message":"Invalid request... #1 violations found.",\
- "validationFailures":[{"failureMessage":"Invalid Parameter",\
- "violationPath":"end"}],"httpStatusCode":400,\
- "apiErrorCode":400}'
-
- # verify return value with expected value
- self.assertEqual(expected_return, actual_return)
-
- @mock.patch.object(monPlugin.requests, 'get')
- @mock.patch.object(monPlugin.MonPlugin, 'get_vm_resource_id')
- @mock.patch.object(monPlugin.MonPlugin, 'get_vm_moref_id')
- @mock.patch.object(monPlugin.MonPlugin, 'get_default_Params')
- def test_get_metrics_data_metric_not_supported(self, m_get_default_Params,
- m_get_vm_moref_id,
- m_get_vm_resource_id,
- m_get):
- """Test get metrics data of resource method invalid metric name"""
-
- metrics = {'collection_period': 1, 'metric_name': 'invalid_metric', 'metric_uuid': None,
- 'schema_version': 1.0,
- 'resource_uuid': 'e14b203c-6bf2-4e2f-a91c-8c19d240eda4',
- 'correlation_id': 'e14b203c-6bf2-4e2f-a91c-8c19d2abcdef',
- 'schema_type': 'read_metric_data_request', 'vim_type': 'VMware',
- 'collection_unit': 'HR', 'vim_uuid': '1'}
-
- # mock return value
- m_get_default_Params.return_value = {} # returns empty dict
-
- expected_return = {'metric_name': 'invalid_metric', 'metric_uuid': '0', 'vim_uuid': '1',
- 'schema_version': '1.0', 'resource_uuid': 'e14b203c-6bf2-4e2f-a91c-8c19d240eda4',
- 'correlation_id': 'e14b203c-6bf2-4e2f-a91c-8c19d2abcdef',
- 'metrics_data': {'time_series': [], 'metrics_series': []},
- 'schema_type': 'read_metric_data_response', 'unit': None}
-
- # call get matrics data method under test
- actual_return = self.mon_plugin.get_metrics_data(metrics)
-
- # verify that mocked method is called/not called
- m_get_default_Params.assert_called_with(metrics['metric_name'])
- m_get_vm_moref_id.assert_not_called()
- m_get_vm_resource_id.assert_not_called()
- m_get.assert_not_called()
-
- # verify return value with expected value
- self.assertEqual(expected_return, actual_return)
-
- @mock.patch.object(monPlugin.requests, 'get')
- @mock.patch.object(monPlugin.MonPlugin, 'get_vm_resource_id')
- @mock.patch.object(monPlugin.MonPlugin, 'get_vm_moref_id')
- @mock.patch.object(monPlugin.MonPlugin, 'get_default_Params')
- def test_get_metrics_data_failed_to_get_vm_moref_id(self, m_get_default_Params,
- m_get_vm_moref_id,
- m_get_vm_resource_id,
- m_get):
- """Test get metrics data method negative scenario- invalid resource id"""
-
- metrics = {'collection_period': 1, 'metric_name': 'cpu_utilization', 'metric_uuid': None,
- 'schema_version': 1.0, 'resource_uuid': 'e14b203c-6bf2-4e2f-a91c-8c19d240eda4',
- 'correlation_id': 'e14b203c-6bf2-4e2f-a91c-8c19d2abcdef',
- 'schema_type': 'read_metric_data_request', 'vim_type': 'VMware',
- 'collection_unit': 'HR', 'vim_uuid': '1'}
-
- # mock return value
- m_get_default_Params.return_value = {'metric_key': 'cpu|usage_average', 'unit': '%'}
- m_get_vm_moref_id.return_value = None
- expected_return = {'metric_name': 'cpu_utilization', 'metric_uuid': '0',
- 'schema_version': '1.0',
- 'resource_uuid': 'e14b203c-6bf2-4e2f-a91c-8c19d240eda4',
- 'correlation_id': 'e14b203c-6bf2-4e2f-a91c-8c19d2abcdef',
- 'metrics_data': {'time_series': [], 'metrics_series': []},
- 'schema_type': 'read_metric_data_response',
- 'unit': '%', 'vim_uuid': '1'}
-
- # call get matrics data method under test
- actual_return = self.mon_plugin.get_metrics_data(metrics)
-
- # verify that mocked method is called/not called
- m_get_default_Params.assert_called_with(metrics['metric_name'])
- m_get_vm_moref_id.assert_called_with(metrics['resource_uuid'])
- m_get_vm_resource_id.assert_not_called()
- m_get.assert_not_called()
-
- # verify return value with expected value
- self.assertEqual(expected_return, actual_return)
-
- @mock.patch.object(monPlugin.requests, 'get')
- @mock.patch.object(monPlugin.MonPlugin, 'get_vm_resource_id')
- @mock.patch.object(monPlugin.MonPlugin, 'get_vm_moref_id')
- @mock.patch.object(monPlugin.MonPlugin, 'get_default_Params')
- def test_get_metrics_data_failed_to_get_vm_resource_id(self, m_get_default_Params,
- m_get_vm_moref_id,
- m_get_vm_resource_id,
- m_get):
- """Test get metrics data method negative scenario- invalid moref id"""
-
- metrics = {'collection_period': 1, 'metric_name': 'CPU_UTILIZATION', 'metric_uuid': None,
- 'schema_version': 1.0, 'resource_uuid': 'e14b203c-6bf2-4e2f-a91c-8c19d240eda4',
- 'correlation_id': 'e14b203c-6bf2-4e2f-a91c-8c19d2abcdef',
- 'schema_type': 'read_metric_data_request', 'vim_type': 'VMware',
- 'collection_unit': 'HR', 'vim_uuid': '1'}
-
- # mock return value
- m_get_default_Params.return_value = {'metric_key': 'cpu|usage_average', 'unit': '%'}
- m_get_vm_moref_id.return_value = 'Invalid-vm-6626'
- m_get_vm_resource_id.return_value = None
- expected_return = {'metric_name': 'CPU_UTILIZATION', 'metric_uuid': '0',
- 'schema_version': '1.0',
- 'resource_uuid': 'e14b203c-6bf2-4e2f-a91c-8c19d240eda4',
- 'correlation_id': 'e14b203c-6bf2-4e2f-a91c-8c19d2abcdef',
- 'metrics_data': {'time_series': [], 'metrics_series': []},
- 'schema_type': 'read_metric_data_response',
- 'unit': '%', 'vim_uuid': '1'}
-
- # call get matrics data method under test
- actual_return = self.mon_plugin.get_metrics_data(metrics)
-
- # verify that mocked method is called/not called
- m_get_default_Params.assert_called_with(metrics['metric_name'])
- m_get_vm_moref_id.assert_called_with(metrics['resource_uuid'])
- m_get_vm_resource_id.assert_called()
- m_get_vm_resource_id.assert_called_with('Invalid-vm-6626')
- m_get.assert_not_called()
-
- # verify return value with expected value
- self.assertEqual(expected_return, actual_return)
-
- @mock.patch.object(monPlugin.MonPlugin, 'reconfigure_alarm')
- @mock.patch.object(monPlugin.MonPlugin, 'update_symptom_defination')
- @mock.patch.object(monPlugin.MonPlugin, 'get_alarm_defination_details')
- def test_update_alarm_configuration_successful_updation(self, m_get_alarm_defination_details,
- m_update_symptom_defination,
- m_reconfigure_alarm):
- """Test update alarm configuration method"""
-
- alarm_config = {'alarm_uuid': 'f1163767-6eac-438f-8e60-a7a867257e14',
- 'correlation_id': 14203,
- 'description': 'CPU_Utilization_Above_Threshold_L', 'operation': 'GT'}
-
- # mock return value
- alarm_details_json = {'states': [{'impact': {'impactType': 'BADGE', 'detail': 'risk'},
- 'severity': 'CRITICAL', 'base-symptom-set': {'symptomDefinitionIds':
- [
- 'SymptomDefinition-47c88675-bea8-436a-bb41-8d2231428f44'],
- 'relation': 'SELF',
- 'type': 'SYMPTOM_SET',
- 'aggregation': 'ALL'}}],
- 'description': 'CPU_Utilization_Above_Threshold', 'type': 16,
- 'id': 'AlertDefinition-f1163767-6eac-438f-8e60-a7a867257e14',
- 'name': 'CPU_Utilization_Above_Thr-e14b203c-6bf2-4e2f-a91c-8c19d2'}
- alarm_details = {'symptom_definition_id': 'SymptomDefinition-47c88675-bea8-436a-bb41-\
- 8d2231428f44', 'alarm_name': 'CPU_Utilization_Above_Thr-e14b203c-6bf2-4e2f-\
- a91c-8c19d2', 'alarm_id': 'AlertDefinition-f1163767-6eac-438f-8e60-\
- a7a867257e14', 'resource_kind': 'VirtualMachine', 'type': 16}
- m_get_alarm_defination_details.return_value = (alarm_details_json, alarm_details)
- m_update_symptom_defination.return_value = 'SymptomDefinition-47c88675-bea8-436a-bb41-\
- 8d2231428f44'
- expected_return = m_reconfigure_alarm.return_value = 'f1163767-6eac-438f-8e60-a7a867257e14'
-
- # call update alarm configuration method under test
- actual_return = self.mon_plugin.update_alarm_configuration(alarm_config)
-
- # verify that mocked method is called
- m_get_alarm_defination_details.assert_called_with(alarm_config['alarm_uuid'])
- m_update_symptom_defination.assert_called_with(alarm_details['symptom_definition_id'],
- alarm_config)
- m_reconfigure_alarm.assert_called_with(alarm_details_json, alarm_config)
-
- # verify return value with expected value
- self.assertEqual(expected_return, actual_return)
-
- @mock.patch.object(monPlugin.MonPlugin, 'reconfigure_alarm')
- @mock.patch.object(monPlugin.MonPlugin, 'update_symptom_defination')
- @mock.patch.object(monPlugin.MonPlugin, 'get_alarm_defination_details')
- def test_update_alarm_configuration_failed_to_reconfigure_alarm(self,
- m_get_alarm_defination_details,
- m_update_symptom_defination,
- m_reconfigure_alarm):
- """Test update alarm configuration method- failed to reconfigure alarm"""
-
- alarm_config = {'alarm_uuid': 'f1163767-6eac-438f-8e60-a7a867257e14',
- 'correlation_id': 14203,
- 'description': 'CPU_Utilization_Above_Threshold_L', 'operation': 'GT'}
-
- # mock return value
- alarm_details_json = {'states': [{'impact': {'impactType': 'BADGE', 'detail': 'risk'},
- 'severity': 'CRITICAL', 'base-symptom-set': {'symptomDefinitionIds':
- [
- 'SymptomDefinition-47c88675-bea8-436a-bb41-8d2231428f44'],
- 'relation': 'SELF',
- 'type': 'SYMPTOM_SET',
- 'aggregation': 'ALL'}}],
- 'description': 'CPU_Utilization_Above_Threshold', 'type': 16,
- 'id': 'AlertDefinition-f1163767-6eac-438f-8e60-a7a867257e14',
- 'name': 'CPU_Utilization_Above_Thr-e14b203c-6bf2-4e2f-a91c-8c19d2'}
- alarm_details = {'symptom_definition_id': 'SymptomDefinition-47c88675-bea8-436a-bb41-\
- 8d2231428f44', 'alarm_name': 'CPU_Utilization_Above_Thr-e14b203c-6bf2-4e2f-\
- a91c-8c19d2', 'alarm_id': 'AlertDefinition-f1163767-6eac-438f-8e60-\
- a7a867257e14', 'resource_kind': 'VirtualMachine', 'type': 16}
- m_get_alarm_defination_details.return_value = (alarm_details_json, alarm_details)
- m_update_symptom_defination.return_value = 'SymptomDefinition-47c88675-bea8-436a-bb41-\
- 8d2231428f44'
- expected_return = m_reconfigure_alarm.return_value = None # failed to reconfigure
-
- # call update alarm configuration method under test
- actual_return = self.mon_plugin.update_alarm_configuration(alarm_config)
-
- # verify that mocked method is called
- m_get_alarm_defination_details.assert_called_with(alarm_config['alarm_uuid'])
- m_update_symptom_defination.assert_called_with(alarm_details['symptom_definition_id'],
- alarm_config)
- m_reconfigure_alarm.assert_called_with(alarm_details_json, alarm_config)
-
- # verify return value with expected value
- self.assertEqual(expected_return, actual_return)
-
- @mock.patch.object(monPlugin.MonPlugin, 'reconfigure_alarm')
- @mock.patch.object(monPlugin.MonPlugin, 'update_symptom_defination')
- @mock.patch.object(monPlugin.MonPlugin, 'get_alarm_defination_details')
- def test_update_alarm_configuration_failed_to_update_symptom(self,
- m_get_alarm_defination_details,
- m_update_symptom_defination,
- m_reconfigure_alarm):
- """Test update alarm configuration method- failed to update alarm"""
-
- alarm_config = {'alarm_uuid': 'f1163767-6eac-438f-8e60-a7a867257e14',
- 'correlation_id': 14203,
- 'description': 'CPU_Utilization_Above_Threshold_L', 'operation': 'GT'}
-
- # mock return value
- alarm_details_json = {'states': [{'impact': {'impactType': 'BADGE', 'detail': 'risk'},
- 'severity': 'CRITICAL', 'base-symptom-set': {'symptomDefinitionIds':
- [
- 'SymptomDefinition-47c88675-bea8-436a-bb41-8d2231428f44'],
- 'relation': 'SELF',
- 'type': 'SYMPTOM_SET',
- 'aggregation': 'ALL'}}],
- 'description': 'CPU_Utilization_Above_Threshold', 'type': 16,
- 'id': 'AlertDefinition-f1163767-6eac-438f-8e60-a7a867257e14',
- 'name': 'CPU_Utilization_Above_Thr-e14b203c-6bf2-4e2f-a91c-8c19d2'}
- alarm_details = {'symptom_definition_id': 'Invalid-47c88675-bea8-436a-bb41-\
- 8d2231428f44', 'alarm_name': 'CPU_Utilization_Above_Thr-e14b203c-6bf2-4e2f-\
- a91c-8c19d2', 'alarm_id': 'AlertDefinition-f1163767-6eac-438f-8e60-\
- a7a867257e14', 'resource_kind': 'VirtualMachine', 'type': 16}
- m_get_alarm_defination_details.return_value = (alarm_details_json, alarm_details)
- expected_return = m_update_symptom_defination.return_value = None
-
- # call update alarm configuration method under test
- actual_return = self.mon_plugin.update_alarm_configuration(alarm_config)
-
- # verify that mocked method is called
- m_get_alarm_defination_details.assert_called_with(alarm_config['alarm_uuid'])
- m_update_symptom_defination.assert_called_with(alarm_details['symptom_definition_id'],
- alarm_config)
- m_reconfigure_alarm.assert_not_called()
-
- # verify return value with expected value
- self.assertEqual(expected_return, actual_return)
-
- @mock.patch.object(monPlugin.MonPlugin, 'get_default_Params')
- def test_verify_metric_support_metric_supported_with_unit(self, m_get_default_Params):
- """Test verify metric support method for supported metric"""
-
- # mock return value
- metric_info = {'metric_unit': '%', 'metric_name': 'cpu_utilization',
- 'resource_uuid': 'e14b203c-6bf2-4e2f-a91c-8c19d240eda4'}
- m_get_default_Params.return_value = {'metric_key': 'cpu|usage_average', 'unit': '%'}
- expected_return = True # supported metric returns True
-
- # call verify metric support method under test
- actual_return = self.mon_plugin.verify_metric_support(metric_info)
-
- # verify that mocked method is called
- m_get_default_Params.assert_called_with(metric_info['metric_name'])
- # m_get_default_Params.assert_called_with(metric_info)
-
- # verify return value with expected value
- self.assertEqual(expected_return, actual_return)
-
- @mock.patch.object(monPlugin.MonPlugin, 'get_default_Params')
- def test_verify_metric_support_metric_not_supported(self, m_get_default_Params):
- """Test verify metric support method for un-supported metric"""
-
- # mock return value
- metric_info = {'metric_unit': '%', 'metric_name': 'invalid_metric',
- 'resource_uuid': 'e14b203c-6bf2-4e2f-a91c-8c19d240eda4'}
- m_get_default_Params.return_value = {}
- expected_return = False # supported metric returns True
-
- # call verify metric support method under test
- actual_return = self.mon_plugin.verify_metric_support(metric_info)
-
- # verify that mocked method is called
- m_get_default_Params.assert_called_with(metric_info['metric_name'])
-
- # verify return value with expected value
- self.assertEqual(expected_return, actual_return)
-
- @mock.patch.object(monPlugin.MonPlugin, 'get_default_Params')
- def test_verify_metric_support_metric_supported_with_mismatched_unit(self,
- m_get_default_Params):
- """Test verify metric support method for supported metric with mismatched unit"""
-
- # mock return value
- metric_info = {'metric_unit': '', 'metric_name': 'invalid_metric',
- 'resource_uuid': 'e14b203c-6bf2-4e2f-a91c-8c19d240eda4'}
- m_get_default_Params.return_value = {'metric_key': 'cpu|usage_average', 'unit': '%'}
- expected_return = True # supported metric returns True
-
- # call verify metric support method under test
- actual_return = self.mon_plugin.verify_metric_support(metric_info)
-
- # verify that mocked method is called
- m_get_default_Params.assert_called_with(metric_info['metric_name'])
-
- # verify return value with expected value
- self.assertEqual(expected_return, actual_return)
-
- @mock.patch.object(monPlugin.MonPlugin, 'get_triggered_alarms_on_resource')
- @mock.patch.object(monPlugin.MonPlugin, 'get_vrops_resourceid_from_ro_uuid')
- def test_get_triggered_alarms_list_returns_triggered_alarms(self,
- m_get_vrops_resourceid,
- m_triggered_alarms):
- """Test get triggered alarm list method valid input"""
-
- # Mock list alarm input
- list_alarm_input = {'severity': 'CRITICAL',
- 'correlation_id': 'e14b203c',
- 'alarm_name': 'CPU_Utilization_Above_Threshold',
- 'resource_uuid': 'e14b203c-6bf2-4e2f-a91c-8c19d240eda4'}
-
- resource_id = m_get_vrops_resourceid.return_value = 'ac87622f-b761-40a0-b151-00872a2a456e'
- expected_return = m_triggered_alarms.return_value = [{'status': 'ACTIVE',
- 'update_date': '2018-01-12T08:34:05',
- 'severity': 'CRITICAL', 'resource_uuid': 'e14b203c',
- 'cancel_date': '0000-00-00T00:00:00',
- 'alarm_instance_uuid': 'd9e3bc84',
- 'alarm_uuid': '5714977d', 'vim_type': 'VMware',
- 'start_date': '2018-01-12T08:34:05'},
- {'status': 'CANCELED',
- 'update_date': '2017-12-20T09:37:57',
- 'severity': 'CRITICAL', 'resource_uuid': 'e14b203c',
- 'cancel_date': '2018-01-12T06:49:19',
- 'alarm_instance_uuid': 'd3bbeef6',
- 'alarm_uuid': '7ba1bf3e', 'vim_type': 'VMware',
- 'start_date': '2017-12-20T09:37:57'}]
-
- # call get triggered alarms list method under test
- actual_return = self.mon_plugin.get_triggered_alarms_list(list_alarm_input)
-
- # verify that mocked method is called
- m_get_vrops_resourceid.assert_called_with(list_alarm_input['resource_uuid'])
- m_triggered_alarms.assert_called_with(list_alarm_input['resource_uuid'], resource_id)
-
- # verify return value with expected value
- self.assertEqual(expected_return, actual_return)
-
- @mock.patch.object(monPlugin.MonPlugin, 'get_triggered_alarms_on_resource')
- @mock.patch.object(monPlugin.MonPlugin, 'get_vrops_resourceid_from_ro_uuid')
- def test_get_triggered_alarms_list_invalid_resource_uuid(self,
- m_get_vrops_resourceid,
- m_triggered_alarms):
- """Test get triggered alarm list method invalid resource uuid"""
-
- # Mock list alarm input
- list_alarm_input = {'severity': 'CRITICAL',
- 'correlation_id': 'e14b203c',
- 'alarm_name': 'CPU_Utilization_Above_Threshold',
- 'resource_uuid': '12345'} # invalid resource uuid
-
- expected_return = m_get_vrops_resourceid.return_value = None # returns empty list
-
- # call get triggered alarms list method under test
- actual_return = self.mon_plugin.get_triggered_alarms_list(list_alarm_input)
-
- # verify that mocked method is called
- m_get_vrops_resourceid.assert_called_with(list_alarm_input['resource_uuid'])
- m_triggered_alarms.assert_not_called()
-
- # verify return value with expected value
- self.assertEqual([], actual_return)
-
- @mock.patch.object(monPlugin.MonPlugin, 'get_triggered_alarms_on_resource')
- @mock.patch.object(monPlugin.MonPlugin, 'get_vrops_resourceid_from_ro_uuid')
- def test_get_triggered_alarms_list_resource_uuid_not_present(self,
- m_get_vrops_resourceid,
- m_triggered_alarms):
- """Test get triggered alarm list method resource not present"""
-
- # Mock list alarm input
- list_alarm_input = {'severity': 'CRITICAL',
- 'correlation_id': 'e14b203c',
- 'alarm_name': 'CPU_Utilization_Above_Threshold'}
-
- # call get triggered alarms list method under test
- actual_return = self.mon_plugin.get_triggered_alarms_list(list_alarm_input)
-
- # verify that mocked method is called
- m_get_vrops_resourceid.assert_not_called()
- m_triggered_alarms.assert_not_called()
-
- # verify return value with expected value
- self.assertEqual([], actual_return)
-
- @mock.patch.object(monPlugin.MonPlugin, 'get_vm_resource_id')
- @mock.patch.object(monPlugin.MonPlugin, 'get_vm_moref_id')
- def test_get_vrops_resourceid_from_ro_uuid(self, m_get_vm_moref_id, m_get_vm_resource_id):
- """Test get vrops resourceid from ro uuid method"""
-
- # Mock the inputs
- ro_resource_uuid = 'e14b203c-6bf2-4e2f-a91c-8c19d240eda4'
- vm_moref_id = m_get_vm_moref_id.return_value = 'vm-6626'
- expected_return = m_get_vm_resource_id.return_value = 'ac87622f-b761-40a0-b151-00872a2a456e'
-
- # call get_vrops_resourceid_from_ro_uuid method under test
- actual_return = self.mon_plugin.get_vrops_resourceid_from_ro_uuid(ro_resource_uuid)
-
- # verify that mocked method is called
- m_get_vm_moref_id.assert_called_with(ro_resource_uuid)
- m_get_vm_resource_id.assert_called_with(vm_moref_id)
-
- # verify return value with expected value
- self.assertEqual(expected_return, actual_return)
-
- @mock.patch.object(monPlugin.MonPlugin, 'get_vm_resource_id')
- @mock.patch.object(monPlugin.MonPlugin, 'get_vm_moref_id')
- def test_get_vrops_resourceid_from_ro_uuid_failed_to_get_vm_resource_id(self,
- m_get_vm_moref_id,
- m_get_vm_resource_id):
- """Test get vrops resourceid from ro uuid method negative scenario"""
-
- # Mock the inputs
- ro_resource_uuid = 'e14b203c-6bf2-4e2f-a91c-8c19d240eda4'
- vm_moref_id = m_get_vm_moref_id.return_value = 'vm-6626'
- expected_return = m_get_vm_resource_id.return_value = None
-
- # call get_vrops_resourceid_from_ro_uuid method under test
- actual_return = self.mon_plugin.get_vrops_resourceid_from_ro_uuid(ro_resource_uuid)
-
- # verify that mocked method is called
- m_get_vm_moref_id.assert_called_with(ro_resource_uuid)
- m_get_vm_resource_id.assert_called_with(vm_moref_id)
-
- # verify return value with expected value
- self.assertEqual(expected_return, actual_return)
-
- @mock.patch.object(monPlugin.MonPlugin, 'get_vm_resource_id')
- @mock.patch.object(monPlugin.MonPlugin, 'get_vm_moref_id')
- def test_get_vrops_resourceid_from_ro_uuid_failed_to_get_vm_moref_id(self,
- m_get_vm_moref_id,
- m_get_vm_resource_id):
- """Test get vrops resourceid from ro uuid method negative scenario"""
-
- # Mock the inputs
- ro_resource_uuid = 'e14b203c-6bf2-4e2f-a91c-8c19d240eda4'
- expected_return = vm_moref_id = m_get_vm_moref_id.return_value = None
-
- # call get_vrops_resourceid_from_ro_uuid method under test
- actual_return = self.mon_plugin.get_vrops_resourceid_from_ro_uuid(ro_resource_uuid)
-
- # verify that mocked method is called
- m_get_vm_moref_id.assert_called_with(ro_resource_uuid)
- m_get_vm_resource_id.assert_not_called()
-
- # verify return value with expected value
- self.assertEqual(expected_return, actual_return)
-
- @mock.patch.object(monPlugin.requests, 'get')
- def test_get_triggered_alarms_on_resource_valid_req_response(self, m_get):
- """Test get triggered alarms on resource method for valid request"""
-
- # Mock the inputs
- ro_resource_uuid = 'e14b203c-6bf2-4e2f-a91c-8c19d240eda4'
- vrops_resource_id = 'ac87622f-b761-40a0-b151-00872a2a456e'
- m_get.return_value.status_code = 200
- expected_return = [{'status': 'ACTIVE', 'update_date': '2018-01-12T08:34:05',
- 'severity': 'CRITICAL', 'start_date': '2018-01-12T08:34:05',
- 'resource_uuid': 'e14b203c-6bf2-4e2f-a91c-8c19d240eda4',
- 'cancel_date': '2018-02-12T08:24:48', 'vim_type': 'VMware',
- 'alarm_instance_uuid': 'd9e3bc84-dcb4-4905-b592-00a55f4cdaf1',
- 'alarm_uuid': '5714977d-56f6-4222-adc7-43fa6c6e7e39'}]
-
- m_get.return_value.content = '{"alerts": [\
- {\
- "alertId": "d9e3bc84-dcb4-4905-b592-00a55f4cdaf1",\
- "resourceId": "ac87622f-b761-40a0-b151-00872a2a456e",\
- "alertLevel": "CRITICAL",\
- "status": "ACTIVE",\
- "startTimeUTC": 1515746045278,\
- "cancelTimeUTC": 1518423888708,\
- "updateTimeUTC": 1515746045278,\
- "alertDefinitionId": "AlertDefinition-5714977d-56f6-4222-adc7-43fa6c6e7e39",\
- "alertDefinitionName": "CPU_Utilization_Above_Thr-e14b203c-6bf2-4e2f-a91c-8c19d240eda4"\
- },\
- {\
- "alertId": "5fb5e940-e161-4253-a729-7255c6d6b1f5",\
- "resourceId": "ac87622f-b761-40a0-b151-00872a2a456e",\
- "alertLevel": "WARNING",\
- "status": "CANCELED",\
- "startTimeUTC": 1506684979154,\
- "cancelTimeUTC": 0,\
- "updateTimeUTC": 1520471975507,\
- "alertDefinitionId": "AlertDefinition-9ec5a921-1a54-411d-85ec-4c1c9b26dd02",\
- "alertDefinitionName": "VM_CPU_Usage_Alarm"\
- }]}'
-
- # call get_vrops_resourceid_from_ro_uuid method under test
- actual_return = self.mon_plugin.get_triggered_alarms_on_resource(ro_resource_uuid,
- vrops_resource_id)
-
- # verify that mocked method is called
- m_get.assert_called()
-
- # verify return value with expected value
- self.assertEqual(expected_return, actual_return)
-
- @mock.patch.object(monPlugin.requests, 'get')
- def test_get_triggered_alarms_on_resource_invalid_req_response(self, m_get):
- """Test get triggered alarms on resource method for invalid request"""
-
- # Mock the inputs
- ro_resource_uuid = 'e14b203c-6bf2-4e2f-a91c-8c19d240eda4'
- vrops_resource_id = 'ac87622f-b761-40a0-b151-00872a2a456e'
- m_get.return_value.status_code = 204
- expected_return = None
-
- # call get_vrops_resourceid_from_ro_uuid method under test
- actual_return = self.mon_plugin.get_triggered_alarms_on_resource(ro_resource_uuid,
- vrops_resource_id)
-
- # verify that mocked method is called
- m_get.assert_called()
-
- # verify return value with expected value
- self.assertEqual(expected_return, actual_return)
-
- @mock.patch.object(monPlugin.requests, 'get')
- def test_get_triggered_alarms_on_resource_no_alarms_present(self, m_get):
- """Test get triggered alarms on resource method for no alarms present"""
-
- # Mock the inputs
- ro_resource_uuid = 'e14b203c-6bf2-4e2f-a91c-8c19d240eda4'
- vrops_resource_id = 'ac87622f-b761-40a0-b151-00872a2a456e'
- m_get.return_value.status_code = 200
- expected_return = []
- m_get.return_value.content = '{"alerts": []}'
-
- # call get_vrops_resourceid_from_ro_uuid method under test
- actual_return = self.mon_plugin.get_triggered_alarms_on_resource(ro_resource_uuid,
- vrops_resource_id)
-
- # verify that mocked method is called
- m_get.assert_called()
-
- # verify return value with expected value
- self.assertEqual(expected_return, actual_return)
-
- def test_convert_date_time_valid_date_time(self):
- """Test convert date time method valid input"""
-
- # Mock the inputs
- date_time = 1515746045278
- expected_return = '2018-01-12T08:34:05'
-
- # call convert_date_time method under test
- actual_return = self.mon_plugin.convert_date_time(date_time)
-
- # verify return value with expected value
- self.assertEqual(expected_return, actual_return)
-
- def test_convert_date_time_invalid_date_time(self):
- """Test convert date time method invalid input"""
-
- # Mock the inputs
- date_time = 0
- expected_return = '0000-00-00T00:00:00'
-
- # call convert_date_time method under test
- actual_return = self.mon_plugin.convert_date_time(date_time)
-
- # verify return value with expected value
- self.assertEqual(expected_return, actual_return)
-
- @mock.patch.object(monPlugin.requests, 'get')
- def test_get_vm_resource_id_rest_valid_req_response(self, m_get):
- """Test get vms resource id valid request"""
-
- # Mock the inputs
- vm_moref_id = 'vm-6626'
- m_get.return_value.status_code = 200
- expected_return = "ac87622f-b761-40a0-b151-00872a2a456e"
- m_get.return_value.content = \
- '{ \
- "resourceList": [\
- {\
- "creationTime": 1497770174130,\
- "resourceKey": {\
- "name": "OCInst2.ubuntu(4337d51f-1e65-4ab0-9c08-4897778d4fda)",\
- "adapterKindKey": "VMWARE",\
- "resourceKindKey": "VirtualMachine",\
- "resourceIdentifiers": [\
- {\
- "identifierType": {\
- "name": "VMEntityObjectID",\
- "dataType": "STRING",\
- "isPartOfUniqueness": true\
- },\
- "value": "vm-6626"\
- }\
- ]\
- },\
- "identifier": "ac87622f-b761-40a0-b151-00872a2a456e"\
- }\
- ]\
- }'
-
- # call get_vm_resource_id method under test
- actual_return = self.mon_plugin.get_vm_resource_id(vm_moref_id)
-
- # verify that mocked method is called
- m_get.assert_called()
-
- # verify return value with expected value
- self.assertEqual(expected_return, actual_return)
-
- @mock.patch.object(monPlugin.requests, 'get')
- def test_get_vm_resource_id_rest_invalid_req_response(self, m_get):
- """Test get vms resource id invalid request"""
-
- # Mock the inputs
- vm_moref_id = 'vm-6626'
- m_get.return_value.status_code = 406
- expected_return = None
- m_get.return_value.content = '406 Not Acceptable'
-
- # call get_vm_resource_id method under test
- actual_return = self.mon_plugin.get_vm_resource_id(vm_moref_id)
-
- # verify that mocked method is called
- m_get.assert_called()
-
- # verify return value with expected value
- self.assertEqual(expected_return, actual_return)
-
- @mock.patch.object(monPlugin.requests, 'get')
- def test_get_vm_resource_id_rest_invalid_response(self, m_get):
- """Test get vms resource id invalid response"""
-
- # Mock the inputs
- vm_moref_id = 'vm-6626'
- m_get.return_value.status_code = 200
- expected_return = None
- m_get.return_value.content = \
- '{ \
- "resourceList": \
- {\
- "creationTime": 1497770174130,\
- "resourceKey": {\
- "name": "OCInst2.ubuntu(4337d51f-1e65-4ab0-9c08-4897778d4fda)",\
- "adapterKindKey": "VMWARE",\
- "resourceKindKey": "VirtualMachine",\
- "resourceIdentifiers": [\
- {\
- "identifierType": {\
- "name": "VMEntityObjectID",\
- "dataType": "STRING",\
- "isPartOfUniqueness": true\
- },\
- "value": "vm-6626"\
- }\
- ]\
- },\
- "identifier": "ac87622f-b761-40a0-b151-00872a2a456e"\
- }\
- }'
-
- # call get_vm_resource_id method under test
- actual_return = self.mon_plugin.get_vm_resource_id(vm_moref_id)
-
- # verify that mocked method is called
- # m_get.assert_called
-
- # verify return value with expected value
- self.assertEqual(expected_return, actual_return)
-
- @mock.patch.object(monPlugin.MonPlugin, 'get_vapp_details_rest')
- def test_get_vm_moref_id_valid_id_found(self, m_get_vapp_details_rest):
- """Test get vm moref id valid scenario"""
-
- # mock the inputs
- vapp_uuid = 'e14b203c-6bf2-4e2f-a91c-8c19d240eda4'
- m_get_vapp_details_rest.return_value = {'vm_vcenter_info': {'vm_moref_id': 'vm-6626'}}
- expected_return = 'vm-6626'
-
- # call get_vm_resource_id method under test
- actual_return = self.mon_plugin.get_vm_moref_id(vapp_uuid)
-
- # verify that mocked method is called
- m_get_vapp_details_rest.assert_called_with(vapp_uuid)
-
- # verify return value with expected value
- self.assertEqual(expected_return, actual_return)
-
- @mock.patch.object(monPlugin.MonPlugin, 'get_vapp_details_rest')
- def test_get_vm_moref_id_valid_id_not_found(self, m_get_vapp_details_rest):
- """Test get vm moref id invalid scenario"""
-
- # mock the inputs
- vapp_uuid = 'e14b203c-6bf2-4e2f-a91c-8c19d240eda' # invalid uuid
- m_get_vapp_details_rest.return_value = {}
- expected_return = None
-
- # call get_vm_resource_id method under test
- actual_return = self.mon_plugin.get_vm_moref_id(vapp_uuid)
-
- # verify that mocked method is called
- m_get_vapp_details_rest.assert_called_with(vapp_uuid)
-
- # verify return value with expected value
- self.assertEqual(expected_return, actual_return)
-
- @mock.patch.object(monPlugin.requests, 'get')
- @mock.patch.object(monPlugin.MonPlugin, 'connect_as_admin')
- def test_get_vapp_details_rest_valid_req_response(self, m_connect_as_admin, m_get):
- """Test get vapp details rest method for valid request response"""
-
- # mock the inputs
- vapp_uuid = 'e14b203c-6bf2-4e2f-a91c-8c19d240eda4'
- m_connect_as_admin.return_value = self.vca
- self.vca._session = self.session
- self.vca._session.headers['x-vcloud-authorization'] = '2ec69b2cc6264ad0a47aaf4e3e280d16'
- m_get.return_value.status_code = 200
- expected_return = {'vm_vcenter_info': {'vm_moref_id': 'vm-6626'}}
- m_get.return_value.content = '<?xml version="1.0" encoding="UTF-8"?>\
- <VApp xmlns="http://www.vmware.com/vcloud/v1.5" xmlns:vmext="http://www.vmware.com/vcloud/extension/v1.5" >\
- <Children>\
- <Vm needsCustomization="false" type="application/vnd.vmware.vcloud.vm+xml">\
- <VCloudExtension required="false">\
- <vmext:VmVimInfo>\
- <vmext:VmVimObjectRef>\
- <vmext:VimServerRef type="application/vnd.vmware.admin.vmwvirtualcenter+xml"/>\
- <vmext:MoRef>vm-6626</vmext:MoRef>\
- <vmext:VimObjectType>VIRTUAL_MACHINE</vmext:VimObjectType>\
- </vmext:VmVimObjectRef>\
- </vmext:VmVimInfo>\
- </VCloudExtension>\
- </Vm>\
- </Children>\
- </VApp>'
-
- # call get_vapp_details_rest method under test
- actual_return = self.mon_plugin.get_vapp_details_rest(vapp_uuid)
-
- # verify that mocked method is called
- m_connect_as_admin.assert_called_with()
- m_get.assert_called()
-
- # verify return value with expected value
- self.assertEqual(expected_return, actual_return)
-
- @mock.patch.object(monPlugin.requests, 'get')
- @mock.patch.object(monPlugin.MonPlugin, 'connect_as_admin')
- def test_get_vapp_details_rest_invalid_req_response(self, m_connect_as_admin, m_get):
- """Test get vapp details rest method for invalid request response"""
-
- # mock the inputs
- vapp_uuid = 'Invalid-e14b203c-6bf2-4e2f-a91c-8c19d240eda4'
- m_connect_as_admin.return_value = self.vca
- self.vca._session = self.session
- self.vca._session.headers['x-vcloud-authorization'] = '2ec69b2cc6264ad0a47aaf4e3e280d16'
- m_get.return_value.status_code = 400
- expected_return = {}
- m_get.return_value.content = 'Bad Request'
-
- # call get_vapp_details_rest method under test
- actual_return = self.mon_plugin.get_vapp_details_rest(vapp_uuid)
-
- # verify that mocked method is called
- m_connect_as_admin.assert_called_with()
-
- # verify return value with expected value
- self.assertEqual(expected_return, actual_return)
-
- @mock.patch.object(monPlugin.requests, 'get')
- @mock.patch.object(monPlugin.MonPlugin, 'connect_as_admin')
- def test_get_vapp_details_rest_failed_to_connect_vcd(self, m_connect_as_admin, m_get):
- """Test get vapp details rest method for failed to connect to vcd"""
-
- # mock the inputs
- vapp_uuid = 'e14b203c-6bf2-4e2f-a91c-8c19d240eda4'
- m_connect_as_admin.return_value = None
- expected_return = {}
-
- # call get_vapp_details_rest method under test
- actual_return = self.mon_plugin.get_vapp_details_rest(vapp_uuid)
-
- # verify that mocked method is called
- m_connect_as_admin.assert_called_with()
- m_get.assert_not_called()
-
- # verify return value with expected value
- self.assertEqual(expected_return, actual_return)
-
- @mock.patch.object(monPlugin.requests, 'get')
- @mock.patch.object(monPlugin.MonPlugin, 'connect_as_admin')
- def test_get_vapp_details_rest_invalid_response(self, m_connect_as_admin, m_get):
- """Test get vapp details rest method for invalid response"""
-
- # mock the inputs
- vapp_uuid = 'e14b203c-6bf2-4e2f-a91c-8c19d240eda4'
- m_connect_as_admin.return_value = self.vca
- self.vca._session = self.session
- self.vca._session.headers['x-vcloud-authorization'] = '2ec69b2cc6264ad0a47aaf4e3e280d16'
- m_get.return_value.status_code = 200
- expected_return = {}
- m_get.return_value.content = '<?xml version="1.0" encoding="UTF-8"?>\
- <VApp xmlns="http://www.vmware.com/vcloud/v1.5" xmlns:vmext="http://www.vmware.com/vcloud/extension/v1.5" >\
- <Children>\
- <Vm needsCustomization="false" type="application/vnd.vmware.vcloud.vm+xml">\
- <VCloudExtension required="false">\
- <vmext:VmVimInfo>\
- <vmext:VmVimObjectRef>\
- <vmext:VimServerRef type="application/vnd.vmware.admin.vmwvirtualcenter+xml"/>\
- <vmext:MoRef>vm-6626</vmext:MoRef>\
- <vmext:VimObjectType>VIRTUAL_MACHINE</vmext:VimObjectType>\
- </vmext:VmVimInfo>\
- </VCloudExtension>\
- </Vm>\
- </Children>\
- </VApp>'
-
- # call get_vapp_details_rest method under test
- actual_return = self.mon_plugin.get_vapp_details_rest(vapp_uuid)
-
- # verify that mocked method is called
- m_connect_as_admin.assert_called_with()
- m_get.assert_called()
-
- # verify return value with expected value
- self.assertEqual(expected_return, actual_return)
-
- @mock.patch.object(monPlugin.Client, 'set_credentials')
- @mock.patch.object(monPlugin, 'Client')
- def test_connect_as_admin(self, m_client, m_set_credentials):
- """Test connect as admin to vCD method"""
-
- # mock the inputs and mocked returns
- expected_return = m_client.return_value = self.vca
- m_set_credentials.retrun_value = True
-
- # call connect_as_admin method under test
- actual_return = self.mon_plugin.connect_as_admin()
-
- # verify that mocked method is called
- m_client.assert_called_with(self.m_vim_access_config['vim_url'],
- verify_ssl_certs=False)
-
- # verify return value with expected value
- self.assertEqual(expected_return, actual_return)
-
-# For testing purpose
-# if __name__ == '__main__':
-# unittest.main()
+++ /dev/null
-# -*- coding: utf-8 -*-
-
-##
-# Copyright 2017-2018 VMware Inc.
-# This file is part of ETSI OSM
-# All Rights Reserved.
-#
-# 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: osslegalrouting@vmware.com
-##
-
-""" Mock tests for VMware vROPs plugin recevier """
-
-import json
-import logging
-import os
-import sys
-import unittest
-from io import UnsupportedOperation
-
-import mock
-
-# sys.path.append("/root/MON/")
-
-log = logging.getLogger(__name__)
-
-sys.path.append(os.path.join(os.path.dirname(os.path.abspath(__file__)), "..", "..", ".."))
-
-from osm_mon.plugins.vRealiseOps import plugin_receiver as monPluginRec
-from osm_mon.core.database import VimCredentials
-
-
-class Message(object):
- """A class to mock a message object value for alarm and matric requests"""
-
- def __init__(self):
- """Initialize a mocked message instance"""
- self.topic = "alarm_or_metric_request"
- self.key = None
- self.value = json.dumps({"mock_value": "mock_details"})
- self.partition = 1
- self.offset = 100
-
-
-class TestPluginReceiver(unittest.TestCase):
- """Test class for Plugin Receiver class methods"""
-
- def setUp(self):
- """Setup the tests for plugin_receiver class methods"""
- super(TestPluginReceiver, self).setUp()
- self.plugin_receiver = monPluginRec.PluginReceiver()
-
- @mock.patch.object(monPluginRec.PluginReceiver, 'publish_create_alarm_status')
- @mock.patch.object(monPluginRec.PluginReceiver, 'create_alarm')
- def test_consume_create_alarm_request_key(self, m_create_alarm, m_publish_create_alarm_status):
- """Test functionality of consume for create_alarm_request key"""
-
- vim_uuid = "f85fc39e-723d-4172-979b-de28b36465bb"
-
- value = {"vim_uuid": vim_uuid, "alarm_create_request": "alarm_details"}
- m_create_alarm.return_value = "test_alarm_id"
-
- # Call the consume method of plugin_receiver
- self.plugin_receiver.handle_alarm_requests('create_alarm_request', value, vim_uuid)
-
- # verify if create_alarm and publish methods called with correct params
- m_create_alarm.assert_called_with(value)
- m_publish_create_alarm_status.assert_called_with("test_alarm_id", value)
-
- @mock.patch.object(monPluginRec.PluginReceiver, 'publish_update_alarm_status')
- @mock.patch.object(monPluginRec.PluginReceiver, 'update_alarm')
- def test_consume_update_alarm_request_key(self, m_update_alarm,
- m_publish_update_alarm_status):
- """Test functionality of consume for update_alarm_request key"""
-
- vim_uuid = "f85fc39e-723d-4172-979b-de28b36465bb"
-
- value = {"vim_uuid": vim_uuid, "alarm_update_request": "alarm_details"}
-
- # set return value to mocked method
- m_update_alarm.return_value = "test_alarm_id"
-
- # Call the consume method of plugin_receiver
- self.plugin_receiver.handle_alarm_requests('update_alarm_request', value, vim_uuid)
-
- # verify update_alarm and publish method called with correct params
- m_update_alarm.assert_called_with(value)
- m_publish_update_alarm_status.assert_called_with("test_alarm_id", value)
-
- @mock.patch.object(monPluginRec.PluginReceiver, 'publish_delete_alarm_status')
- @mock.patch.object(monPluginRec.PluginReceiver, 'delete_alarm')
- def test_consume_delete_alarm_request_key(self, m_delete_alarm,
- m_publish_delete_alarm_status):
- """Test functionality of consume for delete_alarm_request key"""
-
- vim_uuid = "f85fc39e-723d-4172-979b-de28b36465bb"
-
- value = {"vim_uuid": vim_uuid, "alarm_delete_request": "alarm_details"}
- m_delete_alarm.return_value = "test_alarm_id"
-
- # Call the consume method of plugin_receiver and check delete_alarm request
- self.plugin_receiver.handle_alarm_requests('delete_alarm_request', value, vim_uuid)
- m_delete_alarm.assert_called_with(value)
-
- # Check if publish method called with correct parameters
- m_publish_delete_alarm_status.assert_called_with("test_alarm_id", value)
-
- @mock.patch.object(monPluginRec.PluginReceiver, 'publish_list_alarm_response')
- @mock.patch.object(monPluginRec.PluginReceiver, 'list_alarms')
- def test_consume_list_alarm_request_key(self, m_list_alarms,
- m_publish_list_alarm_response):
- """ Test functionality of list alarm request key"""
-
- vim_uuid = "f85fc39e-723d-4172-979b-de28b36465bb"
- value = {"vim_uuid": vim_uuid, "alarm_list_request": "alarm_details"}
-
- test_alarm_list = [{"alarm_uuid": "alarm1_details"}, {"alarm_uuid": "alarm2_details"}]
-
- m_list_alarms.return_value = test_alarm_list
-
- # Call the consume method of plugin_receiver and check delete_alarm request
- self.plugin_receiver.handle_alarm_requests('list_alarm_request', value, vim_uuid)
- m_list_alarms.assert_called_with(value)
-
- # Check if publish method called with correct parameters
- m_publish_list_alarm_response.assert_called_with(test_alarm_list, value)
-
- @mock.patch.object(monPluginRec.PluginReceiver, 'publish_create_alarm_status')
- @mock.patch.object(monPluginRec.PluginReceiver, 'create_alarm')
- def test_consume_invalid_alarm_request_key(self, m_create_alarm,
- m_publish_create_alarm_status):
- """Test functionality of consume for vim_access_credentials invalid request key"""
-
- vim_uuid = "f85fc39e-723d-4172-979b-de28b36465bb"
-
- # Call the consume method of plugin_receiver
- with self.assertRaises(UnsupportedOperation):
- self.plugin_receiver.handle_alarm_requests('invalid_key', {}, vim_uuid)
-
- # verify that create_alarm and publish_create_alarm_status methods not called
- m_create_alarm.assert_not_called()
- m_publish_create_alarm_status.assert_not_called()
-
- @mock.patch.object(monPluginRec.PluginReceiver, 'publish_metrics_data_status')
- @mock.patch.object(monPluginRec.MonPlugin, 'get_metrics_data')
- def test_consume_invalid_metric_request_key(self, m_get_metrics_data,
- m_publish_metric_data_status):
- """Test functionality of invalid metric key request"""
-
- vim_uuid = "f85fc39e-723d-4172-979b-de28b36465bb"
-
- # Call the consume method of plugin_receiver
- with self.assertRaises(UnsupportedOperation):
- self.plugin_receiver.handle_metric_requests('invalid_key', {}, vim_uuid)
-
- # verify that get metrics data and publish methods not called
- m_get_metrics_data.assert_not_called()
- m_publish_metric_data_status.assert_not_called()
-
- @mock.patch.object(monPluginRec.PluginReceiver, 'publish_metrics_data_status')
- @mock.patch.object(monPluginRec.MonPlugin, 'get_metrics_data')
- @mock.patch.object(monPluginRec.PluginReceiver, 'get_vim_access_config')
- def test_consume_read_metric_data_request_key(self, m_get_vim_access_config,
- m_get_metrics_data,
- m_publish_metric_data_status):
- """Test functionality of consume for read_metric_data_request key"""
-
- vim_uuid = "f85fc39e-723d-4172-979b-de28b36465bb"
-
- value = {"vim_uuid": vim_uuid, "metric_name": "metric_details"}
- m_get_metrics_data.return_value = {"metrics_data": "metrics_details"}
-
- m_get_vim_access_config.return_value = {'vrops_site': 'abc',
- 'vrops_user': 'user',
- 'vrops_password': 'passwd',
- 'vim_url': 'vcd_url',
- 'admin_username': 'admin',
- 'admin_password': 'admin_passwd',
- 'vim_uuid': '1',
- 'tenant_id': 'org_vdc_1'}
-
- # Call the consume method of plugin_receiver
- self.plugin_receiver.handle_metric_requests('read_metric_data_request', value, vim_uuid)
- m_get_metrics_data.assert_called_with(value)
-
- # Check if publish method called with correct parameters
- m_publish_metric_data_status.assert_called_with({"metrics_data": "metrics_details"})
-
- @mock.patch.object(monPluginRec.PluginReceiver, 'publish_create_metric_response')
- @mock.patch.object(monPluginRec.PluginReceiver, 'verify_metric')
- def test_consume_create_metric_request_key(self, m_verify_metric,
- m_publish_create_metric_response):
- """Test functionality of consume for create_metric_request key"""
-
- vim_uuid = "f85fc39e-723d-4172-979b-de28b36465bb"
- value = {"vim_uuid": vim_uuid, "metric_create": "metric_details"}
-
- # set the return value
- m_verify_metric.return_value = True
-
- # Call the consume method of plugin_receiver
- self.plugin_receiver.handle_metric_requests('create_metric_request', value, vim_uuid)
- m_verify_metric.assert_called_with(value)
-
- # Check if publish method called with correct parameters
- m_publish_create_metric_response.assert_called_with(value, True)
-
- @mock.patch.object(monPluginRec.PluginReceiver, 'publish_update_metric_response')
- @mock.patch.object(monPluginRec.PluginReceiver, 'verify_metric')
- def test_consume_update_metric_request_key(self, m_verify_metric,
- m_publish_update_metric_response):
- """Test functionality of update metric request key"""
-
- vim_uuid = "f85fc39e-723d-4172-979b-de28b36465bb"
-
- value = {"vim_uuid": vim_uuid, "metric_create": "metric_details"}
-
- # set the return value
- m_verify_metric.return_value = True
-
- # Call the consume method of plugin_receiver
- self.plugin_receiver.handle_metric_requests('update_metric_request', value, vim_uuid)
-
- # verify mocked methods called with correct parameters
- m_verify_metric.assert_called_with(value)
- m_publish_update_metric_response.assert_called_with(value, True)
-
- @mock.patch.object(monPluginRec.PluginReceiver, 'publish_delete_metric_response')
- def test_consume_delete_metric_request_key(self, m_publish_delete_metric_response):
- """Test functionality of consume for delete_metric_request key"""
-
- # Note: vROPS doesn't support deleting metric data
- vim_uuid = "f85fc39e-723d-4172-979b-de28b36465bb"
-
- value = {"vim_uuid": vim_uuid, "metric_name": "metric_details"}
-
- # Call the consume method of plugin_receiver
- self.plugin_receiver.handle_metric_requests('delete_metric_request', value, vim_uuid)
-
- # Check if publish method called with correct parameters
- m_publish_delete_metric_response.assert_called_with(value)
-
- @mock.patch.object(monPluginRec.MonPlugin, 'configure_alarm')
- @mock.patch.object(monPluginRec.MonPlugin, 'configure_rest_plugin')
- @mock.patch.object(monPluginRec.PluginReceiver, 'get_vim_access_config')
- def test_create_alarm_successful(self, m_get_vim_access_config,
- m_configure_rest_plugin,
- m_configure_alarm):
- """ Test functionality of create alarm method-positive case"""
-
- # Mock config_alarm_info
- config_alarm_info = {"schema_version": 1.0,
- "schema_type": "create_alarm_request",
- "vim_type": "VMware",
- "vim_uuid": "1",
- "alarm_create_request": {"correlation_id": 1,
- "alarm_name": "CPU_Utilize_Threshold",
- "metric_name": "CPU_UTILIZATION",
- "tenant_uuid": "tenant_uuid",
- "resource_uuid": "resource_uuid",
- "description": "test_create_alarm",
- "severity": "CRITICAL",
- "operation": "GT",
- "threshold_value": 10,
- "unit": "%",
- "statistic": "AVERAGE"}}
-
- # set return value to plugin uuid
- m_get_vim_access_config.return_value = {'vrops_site': 'abc',
- 'vrops_user': 'user',
- 'vrops_password': 'passwd',
- 'vim_url': 'vcd_url',
- 'admin_username': 'admin',
- 'admin_password': 'admin_passwd',
- 'vim_uuid': '1',
- 'tenant_id': 'org_vdc_1'}
-
- m_configure_rest_plugin.retrun_value = "plugin_uuid"
- m_configure_alarm.return_value = "alarm_uuid"
-
- # call create alarm method under test
- self.plugin_receiver.create_alarm(config_alarm_info)
-
- # verify mocked methods get called with correct params
- m_get_vim_access_config.assert_called_with(config_alarm_info['vim_uuid'])
- m_configure_rest_plugin.assert_called_with()
- m_configure_alarm.assert_called_with(config_alarm_info["alarm_create_request"])
-
- @mock.patch.object(monPluginRec.MonPlugin, 'configure_alarm')
- @mock.patch.object(monPluginRec.MonPlugin, 'configure_rest_plugin')
- @mock.patch.object(monPluginRec.PluginReceiver, 'get_vim_access_config')
- def test_create_alarm_failed(self, m_get_vim_access_config,
- m_configure_rest_plugin,
- m_configure_alarm):
- """ Test functionality of create alarm method negative case"""
-
- # Mock config_alarm_info
- config_alarm_info = {"schema_version": 1.0,
- "schema_type": "create_alarm_request",
- "vim_type": "VMware",
- "vim_uuid": "1",
- "alarm_create_request": {"correlation_id": 1,
- "alarm_name": "CPU_Utilize_Threshold",
- "metric_name": "CPU_UTILIZATION",
- "tenant_uuid": "tenant_uuid",
- "resource_uuid": "resource_uuid",
- "description": "test_create_alarm",
- "severity": "CRITICAL",
- "operation": "GT",
- "threshold_value": 10,
- "unit": "%",
- "statistic": "AVERAGE"}}
-
- # set return value to plugin uuid and alarm_uuid to None
- m_get_vim_access_config.return_value = {'vrops_site': 'abc',
- 'vrops_user': 'user',
- 'vrops_password': 'passwd',
- 'vim_url': 'vcd_url',
- 'admin_username': 'admin',
- 'admin_password': 'admin_passwd',
- 'vim_uuid': '1',
- 'tenant_id': 'org_vdc_1'}
- m_configure_rest_plugin.retrun_value = "plugin_uuid"
- m_configure_alarm.return_value = None
-
- # call create alarm method under test
- alarm_uuid = self.plugin_receiver.create_alarm(config_alarm_info)
-
- # verify mocked method called with correct params
- m_get_vim_access_config.assert_called_with(config_alarm_info['vim_uuid'])
- m_configure_rest_plugin.assert_called_with()
- m_configure_alarm.assert_called_with(config_alarm_info["alarm_create_request"])
-
- # verify create alarm method returns None when failed
- self.assertEqual(alarm_uuid, None)
-
- @mock.patch.object(monPluginRec.MonPlugin, 'update_alarm_configuration')
- @mock.patch.object(monPluginRec.PluginReceiver, 'get_vim_access_config')
- def test_update_alarm_successful(self, m_get_vim_access_config, m_update_alarm_configuration):
- """ Test functionality of update alarm method-positive case"""
-
- # Mock update_alarm_info
- update_alarm_info = {"schema_version": 1.0, "schema_type": "update_alarm_request",
- "vim_type": "VMware", "vim_uuid": "1",
- "alarm_update_request": {'alarm_uuid': 'abc', 'correlation_id': 14203}}
-
- # set return value to mocked method
- m_update_alarm_configuration.return_value = "alarm_uuid"
- m_get_vim_access_config.return_value = {'vrops_site': 'abc',
- 'vrops_user': 'user',
- 'vrops_password': 'passwd',
- 'vim_url': 'vcd_url',
- 'admin_username': 'admin',
- 'admin_password': 'admin_passwd',
- 'vim_uuid': '1',
- 'tenant_id': 'org_vdc_1'}
-
- # check update alarm gets called and returned correct value
- ret_value = self.plugin_receiver.update_alarm(update_alarm_info)
-
- # check mocked method get called with correct param
- m_get_vim_access_config.assert_called_with(update_alarm_info['vim_uuid'])
- m_update_alarm_configuration.assert_called_with(update_alarm_info["alarm_update_request"])
-
- # check return value and passed values are correct
- self.assertEqual(ret_value, "alarm_uuid")
-
- @mock.patch.object(monPluginRec.MonPlugin, 'update_alarm_configuration')
- @mock.patch.object(monPluginRec.PluginReceiver, 'get_vim_access_config')
- def test_update_alarm_failed(self, m_get_vim_access_config, m_update_alarm_configuration):
- """ Test functionality of update alarm method negative case"""
-
- # Mock update_alarm_info
- update_alarm_info = {"schema_version": 1.0, "schema_type": "update_alarm_request",
- "vim_type": "VMware", "vim_uuid": "1",
- "alarm_update_request": {'alarm_uuid': 'abc', 'correlation_id': 14203}}
-
- # set return value to mocked method
- m_update_alarm_configuration.return_value = None
- m_get_vim_access_config.return_value = {'vrops_site': 'abc',
- 'vrops_user': 'user',
- 'vrops_password': 'passwd',
- 'vim_url': 'vcd_url',
- 'admin_username': 'admin',
- 'admin_password': 'admin_passwd',
- 'vim_uuid': '1',
- 'tenant_id': 'org_vdc_1'}
-
- # check update alarm gets called and returned correct value
- ret_value = self.plugin_receiver.update_alarm(update_alarm_info)
-
- # check mocked method get called with correct param
- m_get_vim_access_config.assert_called_with(update_alarm_info['vim_uuid'])
- m_update_alarm_configuration.assert_called_with(update_alarm_info["alarm_update_request"])
-
- # check return value and passed values are correct
- self.assertEqual(ret_value, None)
-
- @mock.patch.object(monPluginRec.MonPlugin, 'delete_alarm_configuration')
- @mock.patch.object(monPluginRec.PluginReceiver, 'get_vim_access_config')
- def test_delete_alarm_successful(self, m_get_vim_access_config, m_delete_alarm_configuration):
- """ Test functionality of delete alarm method-positive case"""
-
- # Mock delete_alarm_info
- delete_alarm_info = {"schema_version": 1.0, "schema_type": "delete_alarm_request",
- "vim_type": "VMware", "vim_uuid": "1",
- "alarm_delete_request": {'alarm_uuid': 'abc', 'correlation_id': 14203}}
-
- # set return value to mocked method
- m_delete_alarm_configuration.return_value = "alarm_uuid"
- m_get_vim_access_config.return_value = {'vrops_site': 'abc',
- 'vrops_user': 'user',
- 'vrops_password': 'passwd',
- 'vim_url': 'vcd_url',
- 'admin_username': 'admin',
- 'admin_password': 'admin_passwd',
- 'vim_uuid': '1',
- 'tenant_id': 'org_vdc_1'}
-
- # check delete alarm gets called and returned correct value
- ret_value = self.plugin_receiver.delete_alarm(delete_alarm_info)
-
- # check mocked method get called with correct param
- m_get_vim_access_config.assert_called_with(delete_alarm_info['vim_uuid'])
- m_delete_alarm_configuration.assert_called_with(delete_alarm_info["alarm_delete_request"])
-
- # check return value and passed values are correct
- self.assertEqual(ret_value, "alarm_uuid")
-
- @mock.patch.object(monPluginRec.MonPlugin, 'delete_alarm_configuration')
- @mock.patch.object(monPluginRec.PluginReceiver, 'get_vim_access_config')
- def test_delete_alarm_failed(self, m_get_vim_access_config, m_delete_alarm_configuration):
- """ Test functionality of delete alarm method-negative case"""
-
- # Mock update_alarm_info
- delete_alarm_info = {"schema_version": 1.0, "schema_type": "delete_alarm_request",
- "vim_type": "VMware", "vim_uuid": "1",
- "alarm_delete_request": {'alarm_uuid': 'abc', 'correlation_id': 14203}}
-
- # set return value to mocked method
- m_delete_alarm_configuration.return_value = None
- m_get_vim_access_config.return_value = {'vrops_site': 'abc',
- 'vrops_user': 'user',
- 'vrops_password': 'passwd',
- 'vim_url': 'vcd_url',
- 'admin_username': 'admin',
- 'admin_password': 'admin_passwd',
- 'vim_uuid': '1',
- 'tenant_id': 'org_vdc_1'}
-
- # check delete alarm gets called and returned correct value
- ret_value = self.plugin_receiver.delete_alarm(delete_alarm_info)
-
- # check mocked method get called with correct param
- m_get_vim_access_config.assert_called_with(delete_alarm_info['vim_uuid'])
- m_delete_alarm_configuration.assert_called_with(delete_alarm_info["alarm_delete_request"])
-
- # check return value to check failed status
- self.assertEqual(ret_value, None)
-
- def test_publish_create_alarm_status(self):
- """ Test functionality of publish create alarm status method"""
-
- # Mock config_alarm_info
- config_alarm_info = {'vim_type': 'VMware', "vim_uuid": "1",
- 'alarm_create_request': {
- 'threshold_value': 0,
- 'severity': 'CRITICAL',
- 'alarm_name': 'CPU_Utilization_Above_Threshold',
- 'resource_uuid': 'e14b203c-6bf2-4e2f-a91c-8c19d240eda4',
- 'correlation_id': 1234,
- 'statistic': 'AVERAGE',
- 'metric_name': 'CPU_UTILIZATION'}
- }
-
- alarm_uuid = "xyz"
-
- # call publish create status method under test
- self.plugin_receiver.publish_create_alarm_status(alarm_uuid, config_alarm_info)
-
- # verify mocked method called with correct params
- # TODO(diazb): Validate payload generation (self.assertEquals(response, expected_message))
-
- def test_publish_update_alarm_status(self):
- """ Test functionality of publish update alarm status method"""
-
- # Mock update_alarm_info
- update_alarm_info = {'vim_type': 'VMware',
- 'vim_uuid': '1',
- 'schema_type': 'update_alarm_request',
- 'alarm_update_request': {'alarm_uuid': '6486e69',
- 'correlation_id': 14203,
- 'operation': 'GT'
- }
- }
-
- alarm_uuid = "xyz"
-
- # call publish update alarm status method under test
- self.plugin_receiver.publish_update_alarm_status(alarm_uuid, update_alarm_info)
-
- # verify mocked method called with correct params
- # TODO(diazb): Validate payload generation (self.assertEquals(response, expected_message))
-
- def test_publish_delete_alarm_status(self):
- """ Test functionality of publish delete alarm status method"""
-
- # Mock delete_alarm_info
- delete_alarm_info = {'vim_type': 'VMware',
- "vim_uuid": "1",
- 'schema_type': 'delete_alarm_request',
- 'alarm_delete_request': {'alarm_uuid': '6486e69',
- 'correlation_id': 14203,
- 'operation': 'GT'
- }
- }
-
- alarm_uuid = "xyz"
-
- # call publish delete alarm status method under test
- self.plugin_receiver.publish_delete_alarm_status(alarm_uuid, delete_alarm_info)
-
- # verify mocked method called with correct params
- # TODO(diazb): Validate payload generation (self.assertEquals(response, expected_message))
-
- def test_publish_metrics_data_status(self):
- """ Test functionality of publish metrics data status method"""
-
- # Mock metrics data
- metrics_data = {
- 'vim_uuid': '1',
- 'metric_name': 'CPU_UTILIZATION', 'metric_uuid': '0',
- 'resource_uuid': 'e14b20', 'correlation_id': 14203,
- 'metrics_data': {'time_series': [15162011, 15162044],
- 'metrics_series': [0.1166666671, 0.1266666650]},
- 'tenant_uuid': 123, 'unit': '%'
- }
-
- # call publish metrics data status method under test
- self.plugin_receiver.publish_metrics_data_status(metrics_data)
-
- # verify mocked method called with correct params
- # TODO(diazb): Validate payload generation (self.assertEquals(response, expected_message))
-
- @mock.patch.object(monPluginRec.MonPlugin, 'verify_metric_support')
- @mock.patch.object(monPluginRec.PluginReceiver, 'get_vim_access_config')
- def test_verify_metric_supported_metric(self, m_get_vim_access_config,
- m_verify_metric_support):
- """ Test functionality of verify metric method"""
-
- # mock metric_info
- metric_info = {'vim_uuid': '1',
- 'metric_create_request': {'metric_unit': '%',
- 'metric_name': 'CPU_UTILIZATION',
- 'resource_uuid': 'e14b203'}}
-
- # set mocked function return value to true
- m_verify_metric_support.return_value = True
- m_get_vim_access_config.return_value = {'vrops_site': 'abc',
- 'vrops_user': 'user',
- 'vrops_password': 'passwd',
- 'vim_url': 'vcd_url',
- 'admin_username': 'admin',
- 'admin_password': 'admin_passwd',
- 'vim_uuid': '1',
- 'tenant_id': 'org_vdc_1'}
-
- # call verify_metric method under test
- ret_value = self.plugin_receiver.verify_metric(metric_info)
-
- # verify mocked method called with correct params
- m_get_vim_access_config.assert_called_with(metric_info['vim_uuid'])
- m_verify_metric_support.assert_called_with(metric_info['metric_create_request'])
-
- # verify the return value
- self.assertEqual(ret_value, True)
-
- @mock.patch.object(monPluginRec.MonPlugin, 'verify_metric_support')
- @mock.patch.object(monPluginRec.PluginReceiver, 'get_vim_access_config')
- def test_verify_metric_unsupported_metric(self, m_get_vim_access_config,
- m_verify_metric_support):
- """ Test functionality of verify metric method-negative case"""
-
- # mock metric_info with unsupported metrics name
- metric_info = {'vim_uuid': '1',
- 'metric_create_request': {'metric_unit': '%',
- 'metric_name': 'Invalid',
- 'resource_uuid': 'e14b203'}}
-
- # set mocked function return value to true
- m_verify_metric_support.return_value = False
- m_get_vim_access_config.return_value = {'vrops_site': 'abc',
- 'vrops_user': 'user',
- 'vrops_password': 'passwd',
- 'vim_url': 'vcd_url',
- 'admin_username': 'admin',
- 'admin_password': 'admin_passwd',
- 'vim_uuid': '1',
- 'tenant_id': 'org_vdc_1'}
-
- # call verify_metric method under test
- ret_value = self.plugin_receiver.verify_metric(metric_info)
-
- # verify mocked method called with correct params
- m_get_vim_access_config.assert_called_with(metric_info['vim_uuid'])
- m_verify_metric_support.assert_called_with(metric_info['metric_create_request'])
-
- # verify the return value
- self.assertEqual(ret_value, False)
-
- def test_publish_create_metric_response(self):
- """ Test functionality of publish create metric response method"""
-
- # Mock metric_info
- metric_info = {
- 'vim_uuid': '1',
- 'vim_type': 'VMware',
- 'correlation_id': 14203,
- 'schema_type': 'create_metric_request',
- 'metric_create_request': {
- 'resource_uuid': '6486e69',
- 'metric_name': 'CPU_UTILIZATION',
- 'metric_unit': '%'
- }
- }
-
- metric_status = True
-
- # call publish create metric method under test
- self.plugin_receiver.publish_create_metric_response(metric_info, metric_status)
-
- # verify mocked method called with correct params
- # TODO(diazb): Validate payload generation (self.assertEquals(response, expected_message))
-
- def test_publish_update_metric_response(self):
- """ Test functionality of publish update metric response method"""
-
- # Mock metric_info
- metric_info = {
- 'vim_uuid': '1',
- 'vim_type': 'VMware',
- 'correlation_id': 14203,
- 'schema_type': 'update_metric_request',
- 'metric_create': {
- 'resource_uuid': '6486e69',
- 'metric_name': 'CPU_UTILIZATION',
- 'metric_unit': '%'
- }
- }
-
- metric_status = True
-
- # call publish update metric method under test
- self.plugin_receiver.publish_update_metric_response(metric_info, metric_status)
-
- # verify mocked method called with correct params
- # TODO(diazb): Validate payload generation (self.assertEquals(response, expected_message))
-
- def test_publish_delete_metric_response(self):
- """ Test functionality of publish delete metric response method"""
-
- # Mock metric_info
- metric_info = {'vim_uuid': '1', 'vim_type': 'VMware', 'correlation_id': 14203,
- 'metric_uuid': 'e14b203c', 'resource_uuid': '6486e69',
- 'metric_name': 'CPU_UTILIZATION',
- 'schema_type': 'delete_metric_request'}
-
- # call publish delete metric method under test-vROPS doesn't support
- # delete metric,just returns response with success
- self.plugin_receiver.publish_delete_metric_response(metric_info)
-
- # verify mocked method called with correct params
- # TODO(diazb): Validate payload generation (self.assertEquals(response, expected_message))
-
- @mock.patch.object(monPluginRec.MonPlugin, 'get_triggered_alarms_list')
- @mock.patch.object(monPluginRec.PluginReceiver, 'get_vim_access_config')
- def test_list_alarms(self, m_get_vim_access_config, m_get_triggered_alarms_list):
- """ Test functionality of list alarms method"""
-
- # Mock list alarm input
- list_alarm_input = {
- 'vim_uuid': '1',
- 'vim_type': 'VMware',
- 'alarm_list_request': {
- 'severity': 'CRITICAL',
- 'correlation_id': 14203,
- 'alarm_name': 'CPU_Utilization_Above_Threshold',
- 'resource_uuid': 'd14b203c'}}
-
- # set return value to mocked method
- m_return = [{'status': 'ACTIVE', 'update_date': '2018-01-12T08:34:05',
- 'severity': 'CRITICAL', 'resource_uuid': 'e14b203c',
- 'cancel_date': '0000-00-00T00:00:00', 'alarm_instance_uuid': 'd9e3bc84',
- 'alarm_uuid': '5714977d', 'vim_type': 'VMware',
- 'start_date': '2018-01-12T08:34:05'},
- {'status': 'CANCELED', 'update_date': '2017-12-20T09:37:57',
- 'severity': 'CRITICAL', 'resource_uuid': 'e14b203c',
- 'cancel_date': '2018-01-12T06:49:19', 'alarm_instance_uuid': 'd3bbeef6',
- 'alarm_uuid': '7ba1bf3e', 'vim_type': 'VMware',
- 'start_date': '2017-12-20T09:37:57'}]
- m_get_triggered_alarms_list.return_value = m_return
-
- m_get_vim_access_config.return_value = {'vrops_site': 'abc',
- 'vrops_user': 'user',
- 'vrops_password': 'passwd',
- 'vim_url': 'vcd_url',
- 'admin_username': 'admin',
- 'admin_password': 'admin_passwd',
- 'vim_uuid': '1',
- 'tenant_id': 'org_vdc_1'}
-
- # call list alarms method under test
- return_value = self.plugin_receiver.list_alarms(list_alarm_input)
-
- # verify mocked method called with correct params
- m_get_vim_access_config.assert_called_with(list_alarm_input['vim_uuid'])
- m_get_triggered_alarms_list.assert_called_with(list_alarm_input['alarm_list_request'])
-
- # verify list alarm method returns correct list
- self.assertEqual(return_value, m_return)
-
- def test_publish_list_alarm_response(self):
- """ Test functionality of publish list alarm response method"""
-
- # Mock list alarm input
- msg_key = 'list_alarm_response'
- topic = 'alarm_response'
- list_alarm_input = {'vim_uuid': '1',
- 'vim_type': 'VMware',
- 'alarm_list_request': {
- 'severity': 'CRITICAL',
- 'correlation_id': 14203,
- 'alarm_name': 'CPU_Utilization_Above_Threshold',
- 'resource_uuid': 'd14b203c'}}
-
- triggered_alarm_list = [{'status': 'ACTIVE', 'update_date': '2018-01-12T08:34:05',
- 'severity': 'CRITICAL', 'resource_uuid': 'e14b203c',
- 'cancel_date': '0000-00-00T00:00:00',
- 'start_date': '2018-01-12T08:34:05',
- 'alarm_instance_uuid': 'd9e3bc84',
- 'alarm_uuid': '5714977d',
- 'vim_type': 'VMware'
- }]
-
- # call publish list alarm response method under test
- response = self.plugin_receiver.publish_list_alarm_response(triggered_alarm_list, list_alarm_input)
-
- # verify mocked method called with correct params
- # TODO(diazb): Validate payload generation (self.assertEquals(response, expected_message))
-
- def test_publish_access_update_response(self):
- """ Test functionality of publish access update response method"""
-
- # Mock required inputs
- access_update_status = True
- access_info_req = {'vim_type': 'VMware',
- 'vim_uuid': '1',
- 'access_config': {'vrops_password': 'vmware',
- 'vcloud-site': 'https://192.169.241.105',
- 'vrops_user': 'Admin', 'correlation_id': 14203,
- 'tenant_id': 'Org2'}
- }
-
- # call publish access update response method under test
- response = self.plugin_receiver.publish_access_update_response(access_update_status, access_info_req)
-
- # verify mocked method called with correct params
- # TODO(diazb): Validate payload generation (self.assertEquals(response, expected_message))
-
- @mock.patch.object(monPluginRec.PluginReceiver, 'write_access_config')
- def test_update_access_credentials_successful(self, m_write_access_config):
- """ Test functionality of update access credentials-positive case"""
-
- # Mock access_info
- access_info = {'vrops_site': 'https://192.169.241.13', 'vrops_user': 'admin',
- 'vrops_password': 'vmware', 'vcloud-site': 'https://192.169.241.15',
- 'admin_username': 'admin', 'admin_password': 'vmware',
- 'vcenter_ip': '192.169.241.13', 'vcenter_port': '443',
- 'vcenter_user': 'admin', 'vcenter_password': 'vmware',
- 'vim_tenant_name': 'Org2', 'orgname': 'Org2', 'tenant_id': 'Org2'}
-
- # Mock return values
- expected_status = m_write_access_config.return_value = True
-
- # call publish update access credentials method under test
- actual_status = self.plugin_receiver.update_access_credentials(access_info)
-
- # check write_access_config called with correct params
- m_write_access_config.assert_called_with(access_info)
-
- # verify update access credentials returns correct status
- self.assertEqual(expected_status, actual_status)
-
- @mock.patch.object(monPluginRec.PluginReceiver, 'write_access_config')
- def test_update_access_credentials_less_config_params(self, m_write_access_config):
- """ Test functionality of update access credentials-negative case"""
-
- # Mock access_info
- access_info = {'vrops_site': 'https://192.169.241.13', 'vrops_user': 'admin',
- 'vrops_password': 'vmware', 'vcloud-site': 'https://192.169.241.15',
- 'admin_username': 'admin', 'admin_password': 'vmware',
- 'vcenter_ip': '192.169.241.13', 'vcenter_port': '443', 'vcenter_user': 'admin',
- 'vim_tenant_name': 'Org2', 'orgname': 'Org2', 'tenant_id': 'Org2'}
-
- # Mock return values
- expected_status = m_write_access_config.return_value = False
-
- # call publish update access credentials method under test
- actual_status = self.plugin_receiver.update_access_credentials(access_info)
-
- # check if mocked method not called
- m_write_access_config.assert_not_called()
-
- # verify update access credentials returns correct status
- self.assertEqual(expected_status, actual_status)
-
- @mock.patch.object(monPluginRec.PluginReceiver, 'write_access_config')
- def test_update_access_credentials_failed(self, m_write_access_config):
- """ Test functionality of update access credentials-failed case """
-
- # Mock access_info
- access_info = {'vrops_site': 'https://192.169.241.13', 'vrops_user': 'admin',
- 'vrops_password': 'vmware', 'vcloud-site': 'https://192.169.241.15',
- 'admin_username': 'admin', 'admin_password': 'vmware',
- 'vcenter_ip': '192.169.241.13', 'vcenter_port': '443',
- 'vcenter_user': 'admin', 'vcenter_password': 'vmware',
- 'vim_tenant_name': 'Org2', 'orgname': 'Org2', 'tenant_id': 'Org2'}
-
- # Mock return values
- expected_status = m_write_access_config.return_value = False
-
- # call publish update access credentials method under test
- actual_status = self.plugin_receiver.update_access_credentials(access_info)
-
- # check write_access_config called with correct params
- m_write_access_config.assert_called_with(access_info)
-
- # verify update access credentials returns correct status
- self.assertEqual(expected_status, actual_status)
-
- def test_write_access_config_successful(self):
- """ Test functionality of write access config method-positive case"""
-
- # Mock access_info
- access_info = {'vrops_sit': 'https://192.169.241.13', 'vrops_user': 'admin',
- 'vrops_password': 'vmware', 'vcloud-site': 'https://192.169.241.15',
- 'admin_username': 'admin', 'admin_password': 'vmware',
- 'vcenter_ip': '192.169.241.13', 'vcenter_port': '443',
- 'vcenter_user': 'admin', 'vcenter_password': 'vmware',
- 'vim_tenant_name': 'Org2', 'orgname': 'Org2', 'tenant_id': 'Org2'}
-
- # call write access config method under test
- actual_status = self.plugin_receiver.write_access_config(access_info)
-
- # verify write access config returns correct status
- self.assertEqual(True, actual_status)
-
- def test_write_access_config_failed(self):
- """ Test functionality of write access config method-negative case"""
-
- # Mock access_info
- access_info = [] # provided incorrect info to generate error
-
- # call write access config method under test
- actual_status = self.plugin_receiver.write_access_config(access_info)
-
- # verify write access config returns correct status
- self.assertEqual(False, actual_status)
-
- @mock.patch.object(monPluginRec.AuthManager, 'get_credentials')
- def test_get_vim_access_config(self, m_get_credentials):
- """ Test functionality of get_vim_access_config method-positive case"""
-
- # Mock vim_uuid & access_info
- vim_uuid = '1'
- vim_details = VimCredentials()
- vim_details.name = "vrops_vcd82"
- vim_details.password = "passwd"
- vim_details.tenant_name = "MANO-VDC"
- vim_details.type = "VMware"
- vim_details.url = "https://10.10.1.1"
- vim_details.user = "admin"
- vim_details.uuid = "1"
- vim_details.config = '{"orgname": "MANO-Org", "tenant_id": "MANO-VDC",\
- "admin_username": "administrator","admin_password": "vcd_pwd",\
- "vrops_user": "admin", "vrops_password": "vrops_pwd",\
- "vrops_site": "https://10.10.1.2","nsx_user": "admin",\
- "nsx_manager": "https://10.10.1.3", "nsx_password":"nsx_pwd",\
- "sdn_controller": "None", "sdn_port_mapping": "None",\
- "vcenter_ip": "10.10.1.4", "vcenter_user": "admin@vsphere.local",\
- "vcenter_password": "vcenter_pwd", "vcenter_port": "443"}'
- m_get_credentials.return_value = vim_details
- expected_config = {'vrops_password': 'vrops_pwd', 'vcenter_password': 'vcenter_pwd',
- 'name': 'vrops_vcd82', 'org_user': 'admin',
- 'org_password': 'passwd', 'nsx_user': 'admin', 'vim_tenant_name': 'MANO-VDC',
- 'admin_username': 'administrator', 'vcenter_port': '443',
- 'vim_url': 'https://10.10.1.1', 'orgname': 'MANO-Org',
- 'admin_password': 'vcd_pwd', 'vrops_user': 'admin', 'vcenter_ip': '10.10.1.4',
- 'vrops_site': 'https://10.10.1.2', 'nsx_manager': 'https://10.10.1.3',
- 'nsx_password': 'nsx_pwd', 'vim_type': 'VMware', 'vim_uuid': '1',
- 'vcenter_user': 'admin@vsphere.local'}
-
- # call get_vim_access_config method under test
- actual_config = self.plugin_receiver.get_vim_access_config('1')
-
- # verify that mocked method is called
- m_get_credentials.assert_called_with(vim_uuid)
-
- # Verify return value with expected value
- self.assertEqual(expected_config, actual_config)
-
-# For testing purpose
-# if __name__ == '__main__':
-
-# unittest.main()
+++ /dev/null
-# -*- 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
-##
\ No newline at end of file
# test suite on all supported python versions. To use it, "pip install tox"
# and then run "tox" from this directory.
[tox]
-envlist = py3
+envlist = py3, flake8
toxworkdir={homedir}/.tox
[testenv]
projects / osm / MON.git / commitdiff