164 lines
7.4 KiB
Python
164 lines
7.4 KiB
Python
# This code is part of Ansible, but is an independent component.
|
|
# This particular file snippet, and this file snippet only, is BSD licensed.
|
|
# Modules you write using this snippet, which is embedded dynamically by Ansible
|
|
# still belong to the author of the module, and may assign their own license
|
|
# to the complete work.
|
|
#
|
|
# (c) 2019 Red Hat Inc.
|
|
#
|
|
# Redistribution and use in source and binary forms, with or without modification,
|
|
# are permitted provided that the following conditions are met:
|
|
#
|
|
# * Redistributions of source code must retain the above copyright
|
|
# notice, this list of conditions and the following disclaimer.
|
|
# * Redistributions in binary form must reproduce the above copyright notice,
|
|
# this list of conditions and the following disclaimer in the documentation
|
|
# and/or other materials provided with the distribution.
|
|
#
|
|
# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
|
|
# ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
|
|
# WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
|
|
# IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
|
|
# INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
|
|
# PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
|
|
# INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
|
|
# LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
|
|
# USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
|
#
|
|
|
|
import os
|
|
|
|
from ansible.module_utils.six import iteritems
|
|
from ansible.module_utils.six import iterkeys
|
|
from ansible.module_utils._text import to_text
|
|
from ansible.module_utils.basic import env_fallback
|
|
|
|
try:
|
|
from skydive.rest.client import RESTClient
|
|
HAS_SKYDIVE_CLIENT = True
|
|
except ImportError:
|
|
HAS_SKYDIVE_CLIENT = False
|
|
|
|
# defining skydive constants
|
|
SKYDIVE_GREMLIN_QUERY = 'G.V().Has'
|
|
|
|
SKYDIVE_PROVIDER_SPEC = {
|
|
'endpoint': dict(fallback=(env_fallback, ['SKYDIVE_ENDPOINT'])),
|
|
'username': dict(fallback=(env_fallback, ['SKYDIVE_USERNAME'])),
|
|
'password': dict(fallback=(env_fallback, ['SKYDIVE_PASSWORD']), no_log=True),
|
|
'insecure': dict(type='bool', default=False, fallback=(env_fallback, ['SKYDIVE_INSECURE'])),
|
|
'ssl': dict(type='bool', default=False, fallback=(env_fallback, ['SKYDIVE_SSL']))
|
|
}
|
|
|
|
|
|
class skydive_restclient(object):
|
|
''' Base class for implementing Skydive Rest API '''
|
|
provider_spec = {'provider': dict(type='dict', options=SKYDIVE_PROVIDER_SPEC)}
|
|
|
|
def __init__(self, **kwargs):
|
|
if not HAS_SKYDIVE_CLIENT:
|
|
raise Exception('skydive-client is required but does not appear '
|
|
'to be installed. It can be installed using the '
|
|
'command `pip install skydive-client`')
|
|
|
|
if not set(kwargs.keys()).issubset(SKYDIVE_PROVIDER_SPEC.keys()):
|
|
raise Exception('invalid or unsupported keyword argument for skydive_restclient connection.')
|
|
for key, value in iteritems(SKYDIVE_PROVIDER_SPEC):
|
|
if key not in kwargs:
|
|
# apply default values from SKYDIVE_PROVIDER_SPEC since we cannot just
|
|
# assume the provider values are coming from AnsibleModule
|
|
if 'default' in value:
|
|
kwargs[key] = value['default']
|
|
# override any values with env variables unless they were
|
|
# explicitly set
|
|
env = ('SKYDIVE_%s' % key).upper()
|
|
if env in os.environ:
|
|
kwargs[key] = os.environ.get(env)
|
|
kwargs['scheme'] = "http"
|
|
if 'ssl' in kwargs:
|
|
if kwargs['ssl']:
|
|
kwargs['scheme'] = "https"
|
|
if 'insecure' not in kwargs:
|
|
kwargs['insecure'] = False
|
|
self.restclient_object = RESTClient(kwargs['endpoint'],
|
|
scheme=kwargs['scheme'],
|
|
insecure=kwargs['insecure'],
|
|
username=kwargs['username'],
|
|
password=kwargs['password'])
|
|
|
|
|
|
class skydive_lookup(skydive_restclient):
|
|
provider_spec = {'provider': dict(type='dict', options=SKYDIVE_PROVIDER_SPEC)}
|
|
|
|
def __init__(self, provider):
|
|
super(skydive_lookup, self).__init__(**provider)
|
|
self.query_str = ""
|
|
|
|
def lookup_query(self, filter_data):
|
|
query_key = filter_data.keys()[0]
|
|
self.query_str = filter_data[query_key]
|
|
nodes = self.restclient_object.lookup_nodes(self.query_str)
|
|
result = []
|
|
for each in nodes:
|
|
result.append(each.__dict__)
|
|
if len(result) == 0:
|
|
raise Exception("Cannot find any entry for the input Gremlin query!")
|
|
return result
|
|
|
|
|
|
class skydive_flow_capture(skydive_restclient):
|
|
''' Implements Skydive Flow capture modules '''
|
|
def __init__(self, module):
|
|
self.module = module
|
|
provider = module.params['provider']
|
|
|
|
super(skydive_flow_capture, self).__init__(**provider)
|
|
|
|
def run(self, ib_spec):
|
|
state = self.module.params['state']
|
|
if state not in ('present', 'absent'):
|
|
self.module.fail_json(msg='state must be one of `present`, `absent`, got `%s`' % state)
|
|
|
|
result = {'changed': False}
|
|
obj_filter = dict([(k, self.module.params[k]) for k, v in iteritems(ib_spec) if v.get('ib_req')])
|
|
|
|
proposed_object = {}
|
|
for key in iterkeys(ib_spec):
|
|
if self.module.params[key] is not None:
|
|
proposed_object[key] = self.module.params[key]
|
|
|
|
if obj_filter['query']:
|
|
cature_query = obj_filter['query']
|
|
elif obj_filter['interface_name'] and obj_filter['type']:
|
|
cature_query = SKYDIVE_GREMLIN_QUERY + "('Name', '{0}', 'Type', '{1}')".format(obj_filter['interface_name'],
|
|
obj_filter['type'])
|
|
else:
|
|
raise self.module.fail_json(msg="Interface name and Type is required if gremlin query is not defined!")
|
|
|
|
# to check current object ref for idempotency
|
|
captured_list_objs = self.restclient_object.capture_list()
|
|
current_ref_uuid = None
|
|
for each_capture in captured_list_objs:
|
|
if cature_query == each_capture.__dict__['query']:
|
|
current_ref_uuid = each_capture.__dict__['uuid']
|
|
break
|
|
if state == 'present':
|
|
if not current_ref_uuid:
|
|
try:
|
|
self.restclient_object.capture_create(cature_query, obj_filter['capture_name'],
|
|
obj_filter['description'], obj_filter['extra_tcp_metric'],
|
|
obj_filter['ip_defrag'], obj_filter['reassemble_tcp'],
|
|
obj_filter['layer_key_mode'])
|
|
except Exception as e:
|
|
self.module.fail_json(msg=to_text(e))
|
|
result['changed'] = True
|
|
if state == 'absent':
|
|
if current_ref_uuid:
|
|
try:
|
|
self.restclient_object.capture_delete(current_ref_uuid)
|
|
except Exception as e:
|
|
self.module.fail_json(msg=to_text(e))
|
|
result['changed'] = True
|
|
|
|
return result
|