def deleteNetworks():
opts = {
"host": "infoblox url",
"username": "******",
"password": "******"
}
conn = connector.Connector(opts)
all_networks = conn.get_object("network", {
"network~": "XX.XX",
"network_view": "default"
})
keep_networks = ["list of networks"]
remove_networks = []
remove_shared = []
add_back_networks = []
for network in all_networks:
if network["network"] in keep_networks:
remove_networks = remove_networks
else:
shared_name = network["comment"]
shared_name = shared_name[:-11]
remove_shared.append(shared_name)
remove_networks.append(network["_ref"])
add_back_networks.append(network)
for network in remove_shared:
r = conn.get_object("sharednetwork", {"name": network})
for network in remove_networks:
delete = conn.delete_object(network)
def _infoblox_connector(self, context):
logger = self._get_logger(context)
cs_api = CloudShellAPISession(
host=context.connectivity.server_address,
token_id=context.connectivity.admin_auth_token,
domain="Global")
infoblox_address = context.resource.address
infoblox_username = context.resource.attributes.get(
f"{context.resource.model}.User")
infoblox_password = cs_api.DecryptPassword(
context.resource.attributes.get(
f"{context.resource.model}.Password")).Value
# infoblox version as attribute
infoblox_config = {
"host": infoblox_address,
"username": infoblox_username,
"password": infoblox_password,
"ssl_verify": False,
"wapi_version": "2.5"
}
try:
cs_api.WriteMessageToReservationOutput(
context.reservation.reservation_id,
f"Connecting to InfoBlox: '{infoblox_address}'")
logger.info(f"Connecting to InfoBlox: '{infoblox_address}'")
connector.LOG = logger
infoblox_connector = connector.Connector(infoblox_config)
return infoblox_connector
except Exception as e:
msg = f"Error connecting to infoblox: '{e}'"
logger.error(msg)
raise Exception(msg)
def get_connector(credentials=None):
grid_id = cfg.CONF.infoblox.cloud_data_center_id
grid_opts = cfg.get_infoblox_grid_opts(grid_id)
# map connector options to config
# None as value means no name change needed
mapping = {
'host': 'grid_master_host',
'username': '******',
'password': '******',
'wapi_version': None,
'ssl_verify': None,
'http_pool_connections': None,
'http_pool_maxsize': None,
'http_request_timeout': None
}
opts = {
field:
grid_opts[mapping[field]] if mapping[field] else grid_opts[field]
for field in mapping
}
if opts['ssl_verify'] == 'False':
opts['silent_ssl_warnings'] = True
if credentials:
opts['username'] = credentials['username']
opts['password'] = credentials['password']
return conn.Connector(opts)
def test_default_options(self):
opts = dict(host='infoblox.example.org',
username='******',
password='******')
conn = connector.Connector(opts)
self.assertEqual(False, conn.ssl_verify)
self.assertEqual(10, conn.http_request_timeout)
self.assertEqual(10, conn.http_pool_connections)
self.assertEqual(10, conn.http_pool_maxsize)
self.assertEqual('1.4', conn.wapi_version)
def __init__(self, network, record, alias):
self.network = network
self.record = record
self.alias = alias
self.config.readfp(open(IBLOX_CONF))
self.opts = {
'host': self.config.get('iblox', 'iblox_server'),
'username': self.config.get('iblox', 'iblox_username'),
'password': self.config.get('iblox', 'iblox_password')
}
self.conn = connector.Connector(self.opts)
def __init__(self, network, record, alias):
requests.packages.urllib3.disable_warnings(InsecureRequestWarning)
self.network = network
self.record = record
self.alias = alias
self.config.readfp(open(iblox_kit.config.CRED_CONF))
self.opts = {
'host': self.config.get('terraformware', 'iblox_server'),
'username': self.config.get('terraformware', 'iblox_username'),
'password': self.config.get('terraformware', 'iblox_password')
}
self.conn = connector.Connector(self.opts)
def span_ipv4(start=96):
""" span IPv4 from 62.40.96.1 to 62.40.127.254 """
net_prefix = '62.40.'
config = ConfigParser.RawConfigParser()
config.readfp(open(IBLOX_CONF))
opts = {
'host': config.get('iblox', 'iblox_server'),
'username': config.get('iblox', 'iblox_username'),
'password': config.get('iblox', 'iblox_password')
}
conn = connector.Connector(opts)
def yield_ipv4(scope):
""" return generator with IPv4 """
_host_types = conn.get_object('record:host', {'ipv4addr~': scope})
host_types = [str(s['ipv4addrs'][0]['ipv4addr']) for s in _host_types]
_a_types = conn.get_object('record:a', {'ipv4addr~': scope})
a_types = [str(s['ipv4addr']) for s in _a_types]
_merged_types = host_types + a_types
merged_types = [s.split('.')[-1] for s in _merged_types]
for ipv4_addr in merged_types:
yield int(ipv4_addr)
while start < 128:
ip_items = []
net_scope = '{}{}.'.format(net_prefix, start)
ip_generator = yield_ipv4(net_scope)
try:
pre_ip_items = sorted(list(ip_generator))
except TypeError:
pre_ip_items = []
os.sys.stdout.write(
"Free IPs WITHIN {}0 => WHOLE NETWORK".format(net_scope))
else:
os.sys.stdout.write("Free IPs within {}0 => ".format(net_scope))
# removing possible duplicates and weird records that I have seen
for i in pre_ip_items:
if i not in ip_items and i != 0:
ip_items.append(i)
free_ip = []
for octet in ip_items:
index_number = ip_items.index(octet) + 1
if index_number != octet:
free_ip.append("{}{}".format(net_scope, index_number))
# os.sys.stdout.write("{}{}, ".format(net_scope, index_number))
# break
joined_free_ip = ", ".join(free_ip)
print "{}\n".format(joined_free_ip)
start += 1
def add_server(data):
conn = connector.Connector({
'host': INFOBLOX_HOST,
'username': INFOBLOX_USERNAME,
'password': INFOBLOX_PASSWORD
})
hostname = get_hostname(data)
ip = get_ip(data)
logging.info('Registering %s : %s', hostname, ip)
my_ip = objects.IP.create(ip=ip)
host = objects.HostRecord.create(conn, name=hostname, ip=my_ip)
# additional fields in host record?
# additional DNS records? CNAMES?
return 'Ok {}'.format(host)
def main():
module = AnsibleModule(argument_spec=dict(
host=dict(type='str', required=True),
name=dict(type='str', required=True),
ip_address=dict(type='str', required=True),
username=dict(type='str', required=True),
password=dict(type='str', required=True, no_log=True),
validate_certs=dict(type='bool',
choices=[True, False],
default=True,
required=False),
state=dict(type='str',
choices=['present', 'absent'],
default='present',
required=False),
wapi_version=dict(type='str', default='2.2', required=False),
extattrs=dict(type='dict', default=None, required=False),
dns_view=dict(type='str', required=True)),
supports_check_mode=False)
if not HAS_INFOBLOX_CLIENT:
module.fail_json(
msg=
'infoblox-client is not installed. Please see details here: https://github.com/infobloxopen/infoblox-client'
)
try:
conn = connector.Connector({
'host':
module.params['host'],
'username':
module.params['username'],
'password':
module.params['password'],
'ssl_verify':
module.params['validate_certs'],
'wapi_version':
module.params['wapi_version']
})
a_record = objects.ARecord.search(conn,
name=module.params['name'],
ipv4addr=module.params['ip_address'])
if module.params['state'] == 'present':
create_a_record(conn, module, a_record)
else:
delete_a_record(module, a_record)
except exceptions.InfobloxException as error:
module.fail_json(msg=str(error))
def claim_master_role(args):
opts = {
'host': args.host,
'username': args.username,
'password': args.password
}
if args.wapi_version:
opts['wapi_version'] = args.wapi_version
conn = connector.Connector(opts)
arecord_name = args.arecord.format(cluster=args.cluster)
if not arecord_name:
logger.error("Record name not specified")
return
for _ in exponential_backoff():
try:
found = None
old_records = objects.ARecord.search_all(conn,
name=arecord_name,
view=args.dns_view)
logger.info("Found %d existing records for %s", len(old_records),
arecord_name)
for old_record in old_records:
logger.info("Existing mapping for %s: %s", arecord_name,
old_record.ipv4addr)
if old_record.ipv4addr != args.ip:
logger.info("Deleting existing mapping for %s",
old_record.ipv4addr)
old_record.delete()
else:
found = True
if found is None:
new_record = objects.ARecord.create(
conn,
update_if_exists=True,
name=arecord_name,
ipv4addr=args.ip,
view=args.dns_view,
comment=args.comment.format(cluster=args.cluster))
logger.info("Host %s updated to %s", new_record.name,
new_record.ipv4addr)
else:
logger.info("Keeping existing mapping %s", old_record.ipv4addr)
return
except ib_exc.BaseExc as e:
logger.error("Error when updating DNS record %s to %s: %s",
arecord_name, args.ip, e)
def ipv4(net_prefix, start, end):
""" span IPv4 within provided range """
requests.packages.urllib3.disable_warnings(InsecureRequestWarning)
config = ConfigParser.RawConfigParser()
config.readfp(open(iblox_kit.config.CRED_CONF))
opts = {
'host': config.get('terraformware', 'iblox_server'),
'username': config.get('terraformware', 'iblox_username'),
'password': config.get('terraformware', 'iblox_password')
}
conn = connector.Connector(opts)
def yield_ipv4(scope):
""" return generator with IPv4 """
_host_types = conn.get_object('record:host', {'ipv4addr~': scope})
host_types = [str(s['ipv4addrs'][0]['ipv4addr']) for s in _host_types]
_a_types = conn.get_object('record:a', {'ipv4addr~': scope})
a_types = [str(s['ipv4addr']) for s in _a_types]
_merged_types = host_types + a_types
merged_types = [s.split('.')[-1] for s in _merged_types]
for ipv4_addr in merged_types:
yield int(ipv4_addr)
while start < end:
ip_items = []
net_scope = '{}{}.'.format(net_prefix, start)
ip_generator = yield_ipv4(net_scope)
try:
pre_ip_items = sorted(list(ip_generator))
except TypeError:
pre_ip_items = []
os.sys.stdout.write("Free IPs WITHIN {}0 => WHOLE NETWORK".format(net_scope))
else:
os.sys.stdout.write("Free IPs within {}0 => ".format(net_scope))
# removing possible duplicates and weird records that I have seen
for i in pre_ip_items:
if i not in ip_items and i != 0:
ip_items.append(i)
free_ip = []
for octet in ip_items:
index_number = ip_items.index(octet) + 1
if index_number != octet:
free_ip.append("{}{}".format(net_scope, index_number))
# os.sys.stdout.write("{}{}, ".format(net_scope, index_number))
# break
print "{}\n".format(", ".join(free_ip))
start += 1
def __init__(self, config):
super(InfobloxBaseAction, self).__init__(config)
_hostname = self.config['hostname']
_username = self.config['username']
_password = self.config['password']
opts = {
'host': _hostname,
'username': _username,
'password': _password,
'ssl_verify': self.config['verify_ssl'],
'silent_ssl_warnings': (not self.config['verify_ssl'])
}
self.connection = connector.Connector(opts)
def delete_server(data):
conn = connector.Connector({
'host': INFOBLOX_HOST,
'username': INFOBLOX_USERNAME,
'password': INFOBLOX_PASSWORD
})
hostname = get_hostname(data)
ip = get_ip(data)
logging.info('Deregistering %s : %s', hostname, ip)
my_ip = objects.IP.create(ip=ip)
hr = objects.HostRecord.search(conn, name=hostname, ip=my_ip)
if not hr:
logging.warning('Host Record not found, nothing to delete.')
return 'Not changed'
hr.delete()
return 'Deletion ok'
def main():
module = AnsibleModule (
argument_spec = dict(
host = dict(type='str' ,required=True),
name = dict(type='str', required=True),
mac = dict(type='str', default=None, required=False),
#required if not using next_avail_ip
ip_address = dict(type='str',required=False),
username = dict(type='str', required=True),
password = dict(type='str', required=True, no_log=True),
validate_certs = dict(type='bool', default=True,choices=[True,False],required=False),
dns_view = dict(type='str', required=True),
network_view = dict(type='str',required=False),
wapi_version = dict(type='str', default='2.2', required=False),
state = dict(type='str', default='present',choices = ['present','absent'],required=False),
comment = dict(type='str', default=None,required=False),
ttl = dict(default=None, required=False,type='str'),
configure_for_dns = dict(type='bool', default=True, choices=[True,False],required=False),
configure_for_dhcp = dict(type='bool',default=False, choices=[True,False], required=False),
next_avail_ip = dict(type='bool',default=False, choices=[True,False], required=False),
#required if using next_avail_ip
cidr = dict(type='str', default=None, required=False),
extattrs = dict(type='dict',default=None,required=False)
),
supports_check_mode=False,
required_one_of=(['ip_address','next_avail_ip'],)
)
if not HAS_INFOBLOX_CLIENT:
module.fail_json(msg='infoblox-client is not installed. Please see details here: https://github.com/infobloxopen/infoblox-client')
if module.params['next_avail_ip']:
if not module.params['cidr'] or not module.params['network_view']:
module.fail_json(msg='"cidr" and "network_view" are required when using "next_avail_ip"')
try:
conn = connector.Connector({'host':module.params['host'],'username':module.params['username'],'password':module.params['password'],
'ssl_verify':module.params['validate_certs'],'wapi_version':module.params['wapi_version']})
ip_addr = ip_gen(module)
host_record = objects.HostRecord.search(conn, name=module.params['name'], view=module.params['dns_view'])
if module.params['state'] == 'present':
create_host_record(conn, host_record, module, ip_addr)
elif module.params['state'] == 'absent':
delete_host_record(conn, host_record, module)
except exceptions.InfobloxException as error:
module.fail_json(msg=str(error))
def test_get_objects_with_max_results_as_connector_opt(self):
objtype = 'network'
with patch.object(requests.Session, 'get',
return_value=mock.Mock()) as patched_get:
patched_get.return_value.status_code = 200
patched_get.return_value.content = '{}'
opts = self._prepare_options()
opts.max_results = 10
conn = connector.Connector(opts)
conn.get_object(objtype, {})
patched_get.assert_called_once_with(
'https://infoblox.example.org/wapi/'
'v1.1/network?_max_results=10',
headers=self.connector.DEFAULT_HEADER,
timeout=self.default_opts.http_request_timeout,
)
def test_max_results_priority(self):
objtype = 'network'
with patch.object(requests.Session, 'get',
return_value=mock.Mock()) as patched_get:
patched_get.return_value.status_code = 200
patched_get.return_value.content = '{}'
opts = self._prepare_options()
opts.max_results = 10
conn = connector.Connector(opts)
# max_results passed to get_object should have higher priority
# over max_results connector option
conn.get_object(objtype, {}, max_results=-20)
patched_get.assert_called_once_with(
'https://infoblox.example.org/wapi/v1.1/network?_max_results=-20', # noqa: E501
headers=self.connector.DEFAULT_HEADER,
timeout=self.default_opts.http_request_timeout,
verify=self.default_opts.ssl_verify,
)
def test_allow_options_as_dict(self):
opts = dict(host='infoblox.example.org',
wapi_version='v1.1',
username='******',
password='******',
ssl_verify=False,
http_pool_connections=10,
http_pool_maxsize=10,
http_request_timeout=10)
conn = connector.Connector(opts)
self.assertEqual(opts['host'], conn.host)
self.assertEqual(opts['wapi_version'], conn.wapi_version)
self.assertEqual(opts['username'], conn.username)
self.assertEqual(opts['password'], conn.password)
self.assertEqual(opts['ssl_verify'], conn.ssl_verify)
self.assertEqual(opts['http_pool_connections'],
conn.http_pool_connections)
self.assertEqual(opts['http_pool_maxsize'], conn.http_pool_maxsize)
self.assertEqual(opts['http_request_timeout'],
conn.http_request_timeout)
def _create_grid_configuration(context):
grid_conf = GridConfiguration(context)
grid_conf.grid_id = cfg.CONF.infoblox.cloud_data_center_id
grid_opts = cfg.get_infoblox_grid_opts(grid_conf.grid_id)
if not grid_opts['grid_master_host']:
raise exc.InfobloxInvalidCloudDataCenter(
data_center_id=grid_conf.grid_id)
grid_conf.grid_name = grid_opts['data_center_name']
grid_conf.grid_master_host = grid_opts['grid_master_host']
grid_conf.grid_master_name = grid_opts['grid_master_name']
grid_conf.admin_user_name = grid_opts['admin_user_name']
grid_conf.admin_password = grid_opts['admin_password']
grid_conf.wapi_version = grid_opts['wapi_version']
grid_conf.ssl_verify = grid_opts['ssl_verify']
grid_conf.http_request_timeout = grid_opts['http_request_timeout']
grid_conf.http_pool_connections = grid_opts['http_pool_connections']
grid_conf.http_pool_maxsize = grid_opts['http_pool_maxsize']
grid_conf.wapi_max_results = grid_opts['wapi_max_results']
grid_conf.wapi_paging = grid_opts['wapi_paging']
# cloud user is used as admin, it needs to have proper permissions to
# deal with non-delegated objects.
gm_connection_opts = {
'host': grid_conf.grid_master_host,
'username': grid_conf.admin_user_name,
'password': grid_conf.admin_password,
'wapi_version': grid_conf.wapi_version,
'ssl_verify': grid_conf.ssl_verify,
'log_api_calls_as_info': True,
'http_request_timeout': grid_conf.http_request_timeout,
'http_pool_connections': grid_conf.http_pool_connections,
'http_pool_maxsize': grid_conf.http_pool_maxsize,
'max_results': grid_conf.wapi_max_results,
'paging': grid_conf.wapi_paging
}
# Silent ssl warnings, if certificate verification is not enabled
if gm_connection_opts['ssl_verify'] == 'False':
gm_connection_opts['silent_ssl_warnings'] = True
grid_conf.gm_connector = connector.Connector(gm_connection_opts)
return grid_conf
def _get_connector(self):
if self.grid_config.is_cloud_wapi is False:
return self.grid_config.gm_connector
# if mapping network view does not exist yet, connect to GM
if self.mapping.network_view_id is None:
return self.grid_config.gm_connector
# use gm_connector in the following cases:
# 1. authority member is not set
# 2. authority member type is GM
# 3. authority member status is OFF
if (self.mapping.authority_member is None or
self.mapping.authority_member.member_type ==
const.MEMBER_TYPE_GRID_MASTER or
self.mapping.authority_member.member_status !=
const.MEMBER_STATUS_ON):
return self.grid_config.gm_connector
grid_connection = self.grid_config.get_grid_connection()
wapi_user = grid_connection['admin_user'].get('name')
wapi_pwd = grid_connection['admin_user'].get('password')
opts = {
'host': self.mapping.authority_member.member_wapi,
'wapi_version': grid_connection['wapi_version'],
'username': wapi_user,
'password': wapi_pwd,
'ssl_verify': grid_connection['ssl_verify'],
'log_api_calls_as_info': True,
'http_pool_connections':
grid_connection['http_pool_connections'],
'http_pool_maxsize': grid_connection['http_pool_maxsize'],
'http_request_timeout': grid_connection['http_request_timeout']
}
# Silent ssl warnings, if certificate verification is not enabled
if opts['ssl_verify'] == 'False':
opts['silent_ssl_warnings'] = True
return connector.Connector(opts)
def main():
module = AnsibleModule(argument_spec=dict(host=dict(required=True),
username=dict(required=True),
password=dict(required=True)), )
infohost = module.params['host']
infousername = module.params['username']
infopassword = module.params['password']
opts = {
'host': infohost,
'username': infousername,
'password': infopassword
}
conn = connector.Connector(opts)
#curl_result_dict = json.loads(conn[1])
#http_resp_code = curl_result_dict['cod']
network = objects.Network.create(conn,
network_view='default',
cidr='12.0.0.0/24')
module.exit_json(changed=True, decision='tp')
parser.add_argument('dnszone', help='DNS zone where host records will be created')
parser.add_argument('--count', dest='num', type=int, default=1, help='Number of VMs to create')
args=parser.parse_args()
subnet = args.subnet[0]
num = args.num
niosip = '10.60.27.4'
niosuser = '******'
niospw = 'infoblox'
project='mythic-brook-146218'
zone='us-west1-a'
nameprefix = args.prefix
dnszone = args.dnszone
opts = {'host': niosip, 'username': niosuser, 'password': niospw}
conn = connector.Connector(opts)
wapiurl = niosutils.get_wapiurl(niosip, niosuser, niospw)
iplist = niosutils.get_nextips(subnet, num, wapiurl, niosuser, niospw)
i = 1
for addr in iplist:
name = nameprefix + str(i)
output = gcloudutils.create_instance(compute, project, zone, name, addr)
operation = (output['name'])
gcloudutils.wait_for_operation(compute, project, zone, operation)
host = name + '.' + dnszone
print 'Creating record %s' % host
my_ip = objects.IP.create(ip=addr)
hr = objects.HostRecord.create(conn, name=host, ip=my_ip)
if message.rstrip() != "":
self.logger.log(self.level, message.rstrip())
# Replace stdout with logging to file at INFO level
sys.stdout = MyLogger(logger, logging.INFO)
# Replace stderr with logging to file at ERROR level
sys.stderr = MyLogger(logger, logging.ERROR)
# ====================================================================================
# GLOBALS
# ------------------------------------------------------------------------------------
# Read in settings
settings = yaml.load(open('settings.yml'))
# Connect to infoblox
conn = connector.Connector(settings['infoblox'])
# Connect to tetration
rc = tetration.CreateRestClient(settings['tetration'])
# Debug function used for printing formatted dictionaries
def PrettyPrint(target):
print json.dumps(target, sort_keys=True, indent=4)
def create_filter_csv(filename):
# Get defined networks
logger.info("Getting networks from infoblox")
networks = conn.get_object('network')
# Find networks with a comment defined
network_list = [network for network in networks if 'comment' in network]
def setUp(self):
super(TestInfobloxConnector, self).setUp()
self.default_opts = self._prepare_options()
self.connector = connector.Connector(self.default_opts)
def __init__(self, opts=None, pigeon=None):
self.client = connector.Connector(opts)
self.pigeon = pigeon
self.boolean = Boolean_Helper()
def main():
module = AnsibleModule(
argument_spec=dict(
provider=dict(type='dict', required=True),
state=dict(type='str', required=True),
network_view=dict(type='str', required=True),
network=dict(type='str', required=False),
extattrs=dict(type='dict', required=False),
comment=dict(type='str', required=False),
filters=dict(type='str', required=False),
dhcp_options=dict(type='list', required=False),
members=dict(type='list', required=False),
),
required_one_of=(
['network', 'filters'],
),
supports_check_mode=False
)
if not HAS_INFOBLOX_CLIENT:
raise Exception('infoblox-client is not installed. Please see details here: https://github.com/infobloxopen/infoblox-client')
provider = module.params['provider'] or {}
no_log = ['password']
for param in no_log:
if provider.get(param):
module.no_log_values.update(return_values(provider[param]))
else:
module.fail_json(msg="Invalid item found in provider.")
valid_provider = ['host', 'username', 'password', 'validate_certs', 'wapi_version']
for param, pvalue in provider.items():
if param in valid_provider:
module.params[param] = module.params.get(param) or pvalue
required_params = ['host', 'username', 'password']
for param in required_params:
if not module.params.get(param):
module.fail_json(msg="Provider option {} is required.".format(provider))
host = module.params['host']
username = module.params['username']
password = module.params['password']
validate_certs = module.params.get('validate_certs', False)
wapi_version = module.params.get('wapi_version', BASE_WAPI)
state = module.params['state']
network_view = module.params.get('network_view', 'default')
network = module.params['network']
extattrs = module.params['extattrs']
comment = module.params['comment']
filters = module.params['filters']
dhcp_options = module.params.get('dhcp_options', None)
members = module.params['members']
if members is not None:
module.fail_json(msg="Members has not yet been implemented.")
opts = {'host': host, 'username': username, 'password': password, 'ssl_verify': validate_certs,
'silent_ssl_warnings': validate_certs is False, wapi_version: wapi_version}
conn = connector.Connector(opts)
extattrs = build_extattrs(module, conn, extattrs)
if state == 'get':
if network:
obj = get_network(module, conn, network_view, network=network)
if isinstance(obj, list):
module.exit_json(changed=False, results=obj)
else:
module.fail_json(msg="Network {} was not found".format(network))
elif filters:
# TODO
pass
get_network(module, conn, network_view, filters=filters)
elif state == 'present':
return_fields = objects.Network._return_fields
obj = get_network(module, conn, network_view, network=network)
if isinstance(obj, list):
if compare_fields(module, conn, module.params, obj[0]) is False:
results = objects.Network.create(conn, update_if_exists=True,
network_view=network_view, cidr=network,
comment=comment, options=dhcp_options, extattrs=extattrs)
obj = get_network(module, conn, network_view, network=network)
module.exit_json(changed=True, results=str(obj))
else:
module.exit_json(changed=False, results=obj)
else:
results = objects.Network.create(conn,
network_view=network_view, cidr=network,
comment=comment, options=dhcp_options, extattrs=extattrs)
obj = get_network(module, conn, network_view, network=network)
module.exit_json(changed=True, results=str(obj))
elif state == 'absent':
find_network = objects.Network.search(conn, network_view=network_view, cidr=network)
if find_network is None:
module.exit_json(changed=False, results="Network {} did not exit".format(network))
find_network.delete()
module.exit_json(changed=True, results="Network {} has been deleted".format(network))
def import_data(self):
# connect API
return False
conn = connector.Connector(self.connector_opts)
top_level_nets = [net for net in conn.get_object('networkcontainer')]
print(top_level_nets)
