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)