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