def domain_delete(aDict): """Function docstring for domain_delete. Args: - id (required) - transfer (optional) Output: """ if aDict['id'] != aDict.get('transfer') and int(aDict['id']) > 0: with DB() as db: db.do( "SELECT foreign_id, server, node FROM domain_servers LEFT JOIN domains ON domains.server_id = domain_servers.id WHERE domains.id = %s" % aDict['id']) infra = db.get_row() ret = node_call(infra['node'], infra['server'], 'domain_delete', {'id': infra['foreign_id']}) ret['devices'] = db.do( "UPDATE devices SET a_id = 0, a_dom_id = %s WHERE a_dom_id = %s" % (aDict.get('transfer', 0), aDict['id'])) ret['cache'] = db.do("DELETE FROM domains WHERE id = %s" % (aDict['id'])) else: ret = {'devices': 0, 'cache': 0, 'records': 0} return ret
def info(aDict): """Function docstring for info TBD Args: - id (required) - subnet (optional) - description (optional) - mask (optional) - gateway (optional) Output: """ ret = {} args = aDict id = args.pop('id', 'new') op = args.pop('op', None) with DB() as db: if op == 'update': from struct import unpack from socket import inet_aton def GL_ip2int(addr): return unpack("!I", inet_aton(addr))[0] # Check gateway low = GL_ip2int(args['subnet']) high = low + 2**(32 - int(args['mask'])) - 1 try: gwint = GL_ip2int(args['gateway']) except: gwint = 0 if not (low < gwint and gwint < high): gwint = low + 1 ret['info'] = "illegal gateway" args['gateway'] = str(gwint) args['subnet'] = str(low) if id == 'new': ret['update'] = db.insert_dict( 'ipam_networks', args, 'ON DUPLICATE KEY UPDATE id = id') id = db.get_last_id() if ret['update'] > 0 else 'new' else: ret['update'] = db.update_dict('ipam_networks', args, 'id=%s' % id) if not id == 'new': ret['xist'] = db.do( "SELECT id, mask, description, INET_NTOA(subnet) AS subnet, INET_NTOA(gateway) AS gateway FROM ipam_networks WHERE id = %s" % id) ret['data'] = db.get_row() else: ret['data'] = { 'id': 'new', 'subnet': '0.0.0.0', 'mask': '24', 'gateway': '0.0.0.0', 'description': 'New' } return ret
def settings_save(aDict): """Function docstring for settings_save TBD Args: Output: """ from sdcp.core.common import rest_call ret = {'config_file': SC['system']['config_file']} try: settings = {} with open(ret['config_file']) as sfile: temp = loads(sfile.read()) for section, content in temp.iteritems(): for key, params in content.iteritems(): if not settings.get(section): settings[section] = {} settings[section][key] = params['value'] settings['system']['config_file'] = ret['config_file'] if settings['system']['id'] == 'master': with DB() as db: db.do( "SELECT section,parameter,value FROM settings WHERE node = 'master'" ) data = db.get_rows() db.do( "SELECT 'node' AS section, node AS parameter, url AS value FROM nodes" ) data.extend(db.get_rows()) for setting in data: section = setting.pop('section') if not settings.get(section): settings[section] = {} settings[section][setting['parameter']] = setting['value'] else: try: master = rest_call( "%s?system_settings_fetch" % settings['system']['master'], {'node': settings['system']['id']})['data'] except: pass else: for section, content in master.iteritems(): if settings.get(section): settings[section].update(content) else: settings[section] = content container = ospath.abspath( ospath.join(ospath.dirname(__file__), '..', 'SettingsContainer.py')) with open(container, 'w') as f: f.write("SC=%s\n" % dumps(settings)) ret['result'] = 'OK' except Exception as e: ret['result'] = 'NOT_OK' ret['error'] = str(e) return ret
def info(aDict): """Function docstring for info TBD Args: - id (required) - op (optional) Output: """ ret = {} args = aDict id = args.pop('id', 'new') op = args.pop('op', None) with DB() as db: if op == 'update': if not id == 'new': ret['update'] = db.update_dict('racks', args, 'id=%s' % id) else: ret['update'] = db.insert_dict('racks', args) id = db.get_last_id() if ret['update'] > 0 else 'new' if not id == 'new': ret['xist'] = db.do("SELECT racks.* FROM racks WHERE id = %s" % id) ret['data'] = db.get_row() else: ret['data'] = { 'id': 'new', 'name': 'new-name', 'size': '48', 'pdu_1': None, 'pdu_2': None, 'console': None, 'image_url': None } sqlbase = "SELECT devices.id, devices.hostname FROM devices INNER JOIN device_types ON devices.type_id = device_types.id WHERE device_types.base = '%s' ORDER BY devices.hostname" db.do(sqlbase % ('console')) ret['consoles'] = db.get_rows() ret['consoles'].append({'id': 'NULL', 'hostname': 'No Console'}) db.do(sqlbase % ('pdu')) ret['pdus'] = db.get_rows() ret['pdus'].append({'id': 'NULL', 'hostname': 'No PDU'}) try: from os import listdir, path directory = listdir( path.join(SC['generic']['docroot'], "images") ) if not SC['generic'].get( 'rack_image_directory') else SC['generic']['rack_image_directory'] ret['images'] = [ f for f in listdir(directory) if (f[-3:] == "png" or f[-3:] == "jpg") and not (f[:4] == 'btn-' or f[:5] == 'icon-') ] except Exception as err: ret['error'] = "Error loading generic -> rack_image_directory: %s" % str( err) return ret
def domain_list(aDict): """Function docstring for domain_list. Args: - filter (optional) - dict (optional) - sync (optional) - exclude (optional) Output: - filter:forward/reverse """ ret = {} with DB() as db: if aDict.get('sync') == 'true': org = {} db.do("SELECT id, server, node FROM domain_servers") servers = db.get_rows() for server in servers: org[server['id']] = node_call(server['node'], server['server'], 'domain_list')['domains'] ret.update({'sync': {'added': [], 'deleted': []}}) db.do("SELECT domains.* FROM domains") cache = db.get_dict('foreign_id') for srv, domains in org.iteritems(): for dom in domains: if not cache.pop(dom['id'], None): ret['sync']['added'].append(dom) # Add forward here db.insert_dict( 'domains', { 'name': dom['name'], 'server_id': srv, 'foreign_id': dom['id'] }, "ON DUPLICATE KEY UPDATE name = '%s'" % dom['name']) for id, dom in cache.iteritems(): ret['sync']['deleted'].append(dom) db.do("DELETE FROM domains WHERE id = '%s'" % id) filter = [] if aDict.get('filter'): filter.append("name %s LIKE '%%arpa'" % ('' if aDict.get('filter') == 'reverse' else "NOT")) if aDict.get('exclude'): db.do("SELECT server_id FROM domains WHERE id = '%s'" % (aDict.get('exclude'))) filter.append('server_id = %s' % (db.get_val('server_id'))) filter.append("domains.id <> '%s'" % aDict.get('exclude')) ret['xist'] = db.do( "SELECT domains.*, server FROM domains LEFT JOIN domain_servers ON domains.server_id = domain_servers.id WHERE %s ORDER BY name" % ('TRUE' if len(filter) == 0 else " AND ".join(filter))) ret['domains'] = db.get_rows( ) if not aDict.get('dict') else db.get_dict(aDict.get('dict')) return ret
def resources_delete(aDict): """Function docstring for resources_delete TBD Args: - id (required) Output: """ with DB() as db: deleted = db.do("DELETE FROM resources WHERE id = '%s'" % aDict['id']) return {'deleted': deleted}
def users_delete(aDict): """Function docstring for users_delete TBD Args: - id (required) Output: """ with DB() as db: res = db.do("DELETE FROM users WHERE id = '%s'" % aDict['id']) return {'deleted': res}
def delete(aDict): """Function docstring for delete TBD Args: - id (required) Output: """ with DB() as db: deleted = db.do("DELETE FROM racks WHERE id = %s" % aDict['id']) return {'deleted': deleted}
def server_list(aDict): """Function docstring for server_list TBD Args: Output: """ ret = {} with DB() as db: db.do("SELECT id, server, node FROM domain_servers") ret['servers'] = db.get_rows() return ret
def webpage_list(aDict): """ List webpages for devices Args: Output: """ ret = {} with DB() as db: ret['xist'] = db.do("SELECT id,hostname,webpage FROM devices WHERE webpage IS NOT NULL") ret['data'] = db.get_rows() return ret
def activities_type_list(aDict): """ Function docstring for activities_type_list. TBD Args: Output: """ ret = {} with DB() as db: db.do("SELECT * FROM activity_types") ret['data'] = db.get_rows() return ret
def node_delete(aDict): """Function docstring for node_delete TBD Args: - id (required) Output: """ ret = {} with DB() as db: ret['delete'] = db.do("DELETE FROM nodes WHERE id = %s" % aDict['id']) return ret
def record_delete(aDict): """Function docstring for record_delete TBD Args: - id (required) Output: """ with DB(SC['powerdns']['database'], 'localhost', SC['powerdns']['username'], SC['powerdns']['password']) as db: deleted = db.do("DELETE FROM records WHERE id = '%s'" % (aDict['id'])) return {'deleted': deleted}
def authenticate(aDict): """Function docstring for authenticate TBD Args: - node (required) - username (required) - project_id (required) - password (required) - project_name (required) Output: """ from sdcp.core.logger import log ret = {} controller = Device(SC['node'][aDict['node']], None) res = controller.auth({ 'project': aDict['project_name'], 'username': aDict['username'], 'password': aDict['password'] }) ret = {'authenticated': res['auth']} if res['auth'] == 'OK': with DB() as db: ret.update({ 'project_name': aDict['project_name'], 'project_id': aDict['project_id'], 'username': aDict['username'], 'token': controller.get_token(), 'expires': controller.get_cookie_expire() }) db.do( "INSERT INTO openstack_tokens(token,expires,project_id,username,node) VALUES('%s','%s','%s','%s','%s')" % (controller.get_token(), controller.get_token_expire(), aDict['project_id'], aDict['username'], SC['node'][aDict['node']])) token_id = db.get_last_id() for service in ['heat', 'nova', 'neutron', 'glance']: svc = controller.get_service(service, 'public') if len(svc['path']) > 0: svc['path'] = svc['path'] + '/' db.do( "INSERT INTO openstack_services(id,service,service_port,service_url,service_id) VALUES('%s','%s','%s','%s','%s')" % (token_id, service, svc['port'], svc['path'], svc['id'])) db.do( "INSERT INTO openstack_services(id,service,service_port,service_url,service_id) VALUES('%s','%s','%s','%s','%s')" % (token_id, "contrail", 8082, '', '')) log("openstack_authenticate - successful login and catalog init for %s@%s" % (aDict['username'], aDict['node'])) else: log("openstack_authenticate - error logging in for %s@%s" % (aDict['username'], ctrl)) return ret
def server_delete(aDict): """Function docstring for server_delete TBD Args: - id (required) Output: """ ret = {} with DB() as db: ret['deleted'] = db.do("DELETE FROM domain_servers WHERE id = %s" % aDict['id']) return ret
def basics(aDict): """Function docstring for basics TBD Args: - id (required) Output: """ ret = {} with DB() as db: ret['xist'] = db.do("SELECT INET_NTOA(ip) as ip, hostname, domains.name AS domain FROM devices LEFT JOIN domains ON devices.a_dom_id = domains.id WHERE devices.id = '%s'"%aDict['id']) ret.update(db.get_row()) return ret
def activities_type_delete(aDict): """ Function docstring for activity_type_delete. TBD Args: - id (required) Output: """ ret = {} with DB() as db: ret['delete'] = db.do("DELETE FROM activity_types WHERE id = '%s'" % aDict['id']) return ret
def users_list(aDict): """Function docstring for users_list TBD Args: Output: """ ret = {} with DB() as db: ret['xist'] = db.do( "SELECT id, alias, name, email FROM users ORDER by name") ret['data'] = db.get_rows() return ret
def node_list(aDict): """Function docstring for node_list TBD Args: Output: """ ret = {} args = aDict with DB() as db: ret['xist'] = db.do("SELECT * FROM nodes") ret['data'] = db.get_rows() return ret
def delete(aDict): """ Deletes a map Args: - id Output: - deleted """ ret = {} with DB() as db: ret['deleted'] = db.do("DELETE FROM visualize WHERE id = %s"%aDict['id']) return ret
def list(aDict): """ Function produces a list of available maps/networks Args: Output: - maps: list of (id,name) """ ret = {} with DB() as db: ret['xist'] = db.do("SELECT id,name FROM visualize") ret['maps'] = db.get_rows() return ret
def new(aDict): """Function docstring for new TBD Args: - a_dom_id (required) - hostname (required) - target (optional) - subnet_id (optional) - ip (optional) - vm (optional) - mac (optional) - arg (optional) Output: - target is 'rack_id' or nothing - arg is rack_id """ def GL_ip2int(addr): from struct import unpack from socket import inet_aton return unpack("!I", inet_aton(addr))[0] def GL_mac2int(aMAC): try: return int(aMAC.replace(":",""),16) except: return 0 ip = aDict.get('ip') ipint = GL_ip2int(ip) subnet_id = aDict.get('subnet_id') ret = {'info':None} with DB() as db: # ZEB TODO -> replace with ipam function in_sub = db.do("SELECT subnet FROM ipam_networks WHERE id = {0} AND {1} > subnet AND {1} < (subnet + POW(2,(32-mask))-1)".format(subnet_id,ipint)) if in_sub == 0: ret['info'] = "IP not in subnet range" elif aDict['hostname'] == 'unknown': ret['info'] = "Hostname unknown not allowed" else: ret['xist'] = db.do("SELECT id, hostname, INET_NTOA(ip) AS ipasc, a_dom_id FROM devices WHERE subnet_id = {} AND (ip = {} OR hostname = '{}')".format(subnet_id,ipint,aDict['hostname'])) if ret['xist'] == 0: mac = GL_mac2int(aDict.get('mac',0)) args = {'ip':str(ipint), 'vm':str(aDict.get('vm','0')), 'mac':str(mac), 'a_dom_id':aDict['a_dom_id'], 'subnet_id':str(subnet_id), 'hostname':aDict['hostname'], 'snmp':'unknown', 'model':'unknown'} ret['insert'] = db.insert_dict('devices',args) ret['id'] = db.get_last_id() if aDict.get('target') == 'rack_id' and aDict.get('arg'): db.do("INSERT INTO rackinfo SET device_id = %s, rack_id = %s ON DUPLICATE KEY UPDATE rack_unit = 0, rack_size = 1"%(ret['id'],aDict.get('arg'))) ret['rack'] = aDict.get('arg') ret['info'] = "rack" else: ret['info'] = "existing" ret.update(db.get_row()) return ret
def contrail_interfaces(aDict): """Function docstring for contrail_interfaces TBD Args: - token (required) - virtual_network (required) Output: """ ret = {'virtual-network': aDict['virtual_network'], 'ip_addresses': []} with DB() as db: db.do( "SELECT node, service_port, service_url FROM openstack_tokens LEFT JOIN openstack_services ON openstack_tokens.id = openstack_services.id WHERE openstack_tokens.token = '%s' AND service = 'contrail'" % (aDict['token'])) data = db.get_row() controller = Device(data['node'], aDict['token']) res = controller.call( data['service_port'], data['service_url'] + "virtual-network/%s" % aDict['virtual_network']) vn = res['data']['virtual-network'] fqdn = vn['fq_name'] fqdn.reverse() ret['fqdn'] = ".".join(fqdn) ret['name'] = vn['name'] for ip in vn.get('instance_ip_back_refs', []): iip = controller.href(ip['href'])['data']['instance-ip'] vmi = controller.href(iip['virtual_machine_interface_refs'][0] ['href'])['data']['virtual-machine-interface'] record = { 'ip_address': iip['instance_ip_address'], 'mac_address': vmi['virtual_machine_interface_mac_addresses']['mac_address'][0] } if vmi.get('virtual_machine_refs'): record['vm_uuid'] = vmi['virtual_machine_refs'][0]['uuid'] if vmi.get('virtual_machine_interface_bindings'): host = vmi['virtual_machine_interface_bindings']['key_value_pair'] for kvp in host: if kvp['key'] == 'host_id': record['vm_binding'] = kvp['value'] break if vmi.get('logical_interface_back_refs'): li = vmi['logical_interface_back_refs'][0] record['logical_interface'] = li['to'][1] + "-" + li['to'][3] record['logical_interface_uuid'] = li['uuid'] if vmi.get('virtual_machine_interface_device_owner'): record['vm_interface_owner'] = vmi[ 'virtual_machine_interface_device_owner'] ret['ip_addresses'].append(record) return ret
def list(aDict): """Function docstring for list TBD Args: Output: """ ret = {} with DB() as db: ret['xist'] = db.do( "SELECT user_id, device_id, DATE_FORMAT(time_start,'%Y-%m-%d %H:%i') as start, NOW() < ADDTIME(time_start, '30 0:0:0.0') AS valid, DATE_FORMAT(ADDTIME(time_start, '30 0:0:0.0'),'%Y-%m-%d %H:%i') as end, devices.hostname, users.alias FROM bookings INNER JOIN devices ON device_id = devices.id INNER JOIN users ON user_id = users.id ORDER by user_id" ) ret['list'] = db.get_rows() return ret
def list(aDict): """Function docstring for list TBD Args: - sort (optional) Output: """ ret = [] sort = aDict.get('sort', 'id') with DB() as db: db.do("SELECT racks.* FROM racks ORDER BY %s" % sort) ret = db.get_rows() return ret
def vm_networks(aDict): """Function docstring for vm_networks TBD Args: - token (required) - vm (required) Output: """ ret = {'result': 'OK', 'vm': None, 'interfaces': []} with DB() as db: db.do( "node, service_port, service_url FROM openstack_tokens LEFT JOIN openstack_services ON openstack_tokens.id = openstack_services.id WHERE openstack_tokens.token = '%s' AND service = 'contrail'" % (aDict['token'])) data = db.get_row() controller = Device(data['node'], aDict['token']) vm = controller.call( data['service_port'], data['service_url'] + "virtual-machine/%s" % aDict['vm'])['data']['virtual-machine'] ret['vm'] = vm['name'] for vmir in vm['virtual_machine_interface_back_refs']: vmi = controller.href( vmir['href'])['data']['virtual-machine-interface'] ip = controller.href( vmi['instance_ip_back_refs'][0]['href'])['data']['instance-ip'] network = vmi['virtual_network_refs'][0]['to'] network.reverse() record = { 'mac_address': vmi['virtual_machine_interface_mac_addresses']['mac_address'][0], 'routing-instance': vmi['routing_instance_refs'][0]['to'][3], 'network_uuid': vmi['virtual_network_refs'][0]['uuid'], 'network_fqdn': ".".join(network), 'ip_address': ip['instance_ip_address'] } if vmi.get('floating_ip_back_refs'): fip = controller.href( vmi['floating_ip_back_refs'][0]['href'])['data']['floating-ip'] record.update({ 'floating_ip_address': fip['floating_ip_address'], 'floating_ip_name': fip['fq_name'][2], 'floating_ip_uuid': fip['uuid'] }) ret['interfaces'].append(record) return ret
def settings_delete(aDict): """Function docstring for settings_delete TBD Args: - node (required) - id (required) Output: """ ret = {} with DB() as db: ret['deleted'] = db.do( "DELETE FROM settings WHERE id = '%s' AND node = '%s'" % (aDict['id'], aDict['node'])) return ret
def delete(aDict): """Function docstring for delete TBD Args: - id (required) Output: """ ret = {} with DB() as db: ret['devices'] = db.do("DELETE FROM devices WHERE subnet_id = " + aDict['id']) ret['deleted'] = db.do("DELETE FROM ipam_networks WHERE id = " + aDict['id']) return ret
def list_type(aDict): """Function docstring for list_type TBD Args: - base (optional) - name (optional) Output: """ ret = {} with DB() as db: select = "device_types.%s ='%s'"%(('name',aDict.get('name')) if aDict.get('name') else ('base',aDict.get('base'))) ret['xist'] = db.do("SELECT devices.id, INET_NTOA(ip) AS ipasc, hostname, device_types.base as type_base, device_types.name as type_name FROM devices LEFT JOIN device_types ON devices.type_id = device_types.id WHERE %s ORDER BY type_name,hostname"%select) ret['data'] = db.get_rows() return ret
def interface_delete(aDict): """Function docstring for interface_delete TBD. Delete a certain interface Args: - id (required) - device_id (required) Output: """ ret = {} id = aDict['id'] with DB() as db: ret['cleared'] = db.do("UPDATE device_interfaces SET peer_interface = NULL WHERE peer_interface = %s"%id) ret['deleted'] = db.do("DELETE FROM device_interfaces WHERE id = %s"%id) return ret