def getCusts(custid=None, fields=None):
vals = []
if not custid:
sql = "SELECT * FROM customers"
else:
sql = 'SELECT * FROM customers where id=%s'
vals.append(custid)
db = nfw.Mysql()
results = db.execute(sql, vals)
customers = {}
for result in results:
field_values = {'text': OrderedDict(), 'textarea': OrderedDict()}
if result['fields'] and fields:
field_results = json.loads(result['fields'])
for t in fields['text']:
field_values['text'][
t] = field_results[t] if t in field_results else ''
for t in fields['textarea']:
field_values['textarea'][
t] = field_results[t] if t in field_results else ''
else:
field_values = None
customers[result['id']] = {
"name": result['name'],
"fields": field_values
}
return json.dumps(customers)
def updateSR(srid, status):
db = nfw.Mysql()
if srid:
sql = 'UPDATE service_requests SET status=%s WHERE id=%s'
vals = (status, srid)
db.execute(sql, vals)
db.commit()
def createSR(req):
values = json.loads(req.read())
deviceID = values['device']
serviceID = values['service'] if 'service' in values else None
customerID = values['customer'] if 'customer' in values else None
port = values['interface'] if 'interface' in values else None
snippet = getSnippet(serviceID)
jsnip = Template(snippet[0])
resources = {}
for i in snippet[3]:
try:
resources[i] = values[i]
except:
raise nfw.HTTPError(nfw.HTTP_404, 'Service creation failed',
'Missing attribute: %s' % i)
snippet = jsnip.render(**resources)
db = nfw.Mysql()
deviceIP = inttoip(deviceID)
unit = re.search(r'interfaces.*{\n.*\n* +unit (.*) {', snippet)
if port and unit:
port += "." + unit.group(1)
srid = addSR(device=deviceID,
customer=customerID,
port=port,
service=serviceID,
snippet=snippet,
resources=json.dumps(resources))
loggedInUser = getLoggedInUser(req)
user = loggedInUser['username']
task = confDevice.delay(deviceIP, user=user, snippet=snippet, srid=srid)
addSR(taskID=task.id, srid=srid)
result = {"Service Request ID": srid, "Task ID": task.id}
return result
def getIGroups(igid=None, view=None):
vals = []
if not igid:
sql = "SELECT * FROM interface_groups"
else:
sql = 'SELECT * FROM interface where id=%s'
vals.append(igid)
db = nfw.Mysql()
results = db.execute(sql, vals)
if view == "select2":
igroups = []
for result in results:
igroups.append({'id': result['id'], 'text': result['name']})
elif view == "datatable":
igroups = []
for result in results:
igroups.append({'name': result['name'], 'id': result['id']})
else:
igroups = {}
for result in results:
igroups[result['id']] = result['name']
return igroups
def getServices(req, resp, sid=None):
db = nfw.Mysql()
if sid:
w = {'services.id': sid}
else:
w = {}
rmap = {'services.*': ''}
rmap['interface_groups.name'] = 'igroupname'
ljo = OrderedDict()
ljo['interface_groups'] = {
'services.interface_group': 'interface_groups.id'
}
left_join = api.LeftJoin(rmap, ljo)
results = api.sql_get_query('services',
req,
resp,
None,
where=w.keys(),
where_values=w.values(),
left_join=left_join)
services = []
for result in results:
services.append({
'id': result['id'],
'name': result['name'],
'interface_group': result['igroupname'],
'igroup': result['interface_group'],
'user_role': result['user_role'],
'snippet': result['config_snippet'],
'activate': result['activate_snippet'],
'deactivate': result['deactivate_snippet'],
'fields': result['fields']
})
return services
def getCustServices(cid):
db = nfw.Mysql()
rmap = {'service_requests.port': 'port'}
rmap['service_requests.creation_date'] = 'date'
rmap['service_requests.status'] = 'status'
rmap['service_requests.result'] = 'result'
rmap['services.name'] = 'name'
rmap['device.name'] = 'device'
ljo = OrderedDict()
ljo['services'] = {'service_requests.service': 'services.id'}
ljo['device'] = {'service_requests.device': 'device.ip'}
result = mysqlLJ(rmap, 'service_requests', ljo,
{'service_requests.customer': cid})
nresults = len(result)
services = []
if nresults > 0:
for i in range(nresults):
services.append({
'name': result[i]['name'],
'device': result[i]['device'],
'port': result[i]['port'],
'status': result[i]['status'],
'result': result[i]['result'],
'date': result[i]['date']
})
return services
def deviceExists(id):
db = nfw.Mysql()
sql = 'SELECT count(id) as count FROM device where id=%s'
result = db.execute(sql, (id, ))
if result[0]['count'] > 0:
return True
else:
return False
def getSNMPComm(device_id):
db = nfw.Mysql()
results = db.execute('SELECT snmp_comm FROM device WHERE ip = %s',
(device_id, ))
if results:
return results[0]['snmp_comm']
else:
return None
def checkResourceUsage(resource, rid):
if resource == "igroup":
sql = 'SELECT port FROM device_port WHERE igroup = %s'
elif resource == "customer":
sql = 'SELECT id FROM service_requests WHERE customer = %s AND status="ACTIVE"'
db = nfw.Mysql()
resources = db.execute(sql, (rid, ))
if resources:
return json.dumps(len(resources))
else:
return json.dumps(0)
def getLoggedInUser(req):
token = req.headers.get('X-Auth-Token', None)
if token:
db = nfw.Mysql()
sql = ('SELECT user_id,user.username ' +
'FROM token LEFT JOIN user ON ' +
'user_id=user.id WHERE token=%s')
result = db.execute(sql, (token, ))
if result:
user_id = result[0]['user_id']
username = result[0]['username']
return {'user_id': user_id, 'username': username}
def addIGroup(values, igid=None):
igroup = values.get('interface_group')
db = nfw.Mysql()
if igid:
sql = 'UPDATE interface_groups set name=%s WHERE id=%s'
vals = (igroup, igid)
else:
igid = uuid.uuid4()
sql = 'INSERT INTO interface_groups (id,name) VALUES (%s,%s)'
vals = (igid, igroup)
db.execute(sql, vals)
db.commit()
def removeDevice(did):
try:
db = nfw.Mysql()
sql = 'DELETE FROM device WHERE ip=%s'
vals = (did, )
db.execute(sql, vals)
db.commit()
return json.dumps({'result': 'Success'})
except:
return json.dumps(
{'result': {
'Failed': 'Failed to remove device %s' % id
}})
def updateSupernets(did):
minpl = config.get('netrino').get('minimum_prefix_length')
db = nfw.Mysql()
sresults = db.execute('SELECT * FROM supernets')
ipresults = db.execute(
'''SELECT alias,prefix_len
FROM device_port WHERE alias
IS NOT NULL AND present=1 AND
ip=%s''', (did, ))
existing_supernets = {}
new_supernets = []
for sr in sresults:
ipnet = IPNetwork(dec2ip(sr['network'], 4) + '/' + str(sr['prefix']))
existing_supernets[sr['id']] = ipnet
for ipresult in ipresults:
ip = ipresult['alias']
pl = ipresult['prefix_len']
pl = pl if pl > 0 else 32
iprefix = '/' + str(pl)
ipnet = IPNetwork(ip + iprefix)
if not isRFC5735(ipnet):
dec_ip = ip2dec(ip, ipnet._version)
if not existing_supernets:
existing_supernets[1] = ipnet
else:
known = False
for sid in existing_supernets:
if existing_supernets[sid].contains(ipnet):
known = True
break
if not known:
for sid in existing_supernets:
biggersn = supernet(existing_supernets[sid], ipnet,
minpl)
if biggersn:
existing_supernets[sid] = biggersn
break
if not biggersn:
new_supernets.append(ipnet)
for sid in existing_supernets:
sql = "UPDATE supernets SET network=%s,prefix=%s WHERE id=%s"
s = existing_supernets[sid]
network = ip2dec(s.ip_network, s._version)
prefix = s._cidr
db.execute(sql, (network, prefix, sid))
for s in new_supernets:
sql = 'INSERT INTO supernets (network,prefix) VALUES (%s,%s)'
network = ip2dec(s.ip_network, s._version)
prefix = s._cidr
db.execute(sql, (network, prefix))
db.commit()
def getSnippet(serviceID):
db = nfw.Mysql()
snippet = []
sql = '''SELECT config_snippet,activate_snippet,
deactivate_snippet,fields from services where id=%s'''
result = db.execute(sql, (serviceID, ))
nresults = len(result)
if nresults > 0:
snippet.append(result[0]['config_snippet'])
snippet.append(result[0]['activate_snippet'])
snippet.append(result[0]['deactivate_snippet'])
fields = result[0]['fields'] or ''
snippet.append(fields.split(','))
return snippet
def discoverDevice(req, id=None):
if id:
id = int(id)
db = nfw.Mysql()
sql = 'SELECT snmp_comm FROM device where id=%s'
result = db.execute(sql, (id, ))
if result:
community = result[0]['snmp_comm']
else:
raise nfw.HTTPError(nfw.HTTP_404, "Device not found",
"POST don't PUT")
else:
rvalues = json.loads(req.read())
if not 'snmp_comm' in rvalues:
raise nfw.HTTPError(nfw.HTTP_404, "Missing required paramater",
"Required paramater 'snmp_comm' not found")
elif not 'id' in rvalues:
raise nfw.HTTPError(nfw.HTTP_404, "Missing required paramater",
"Required paramater 'id' not found")
else:
try:
id = int(rvalues['id'])
except:
raise nfw.HTTPError(nfw.HTTP_404, 'Invalid type',
"'id' must be integer")
if deviceExists(id):
raise nfw.HTTPError(nfw.HTTP_404, 'Device already exists',
"PUT don't POST")
community = rvalues['snmp_comm']
try:
ip = dec2ip(id, 4)
except:
raise nfw.HTTPError(nfw.HTTP_404, 'Invalid type',
"'id' is not a valid ip address")
srid = addSR(device=id, snippet="Running discovery on " + ip)
loggedInUser = getLoggedInUser(req)
user = loggedInUser['username']
task = addDevice.delay(host=ip, user=user, srid=srid, community=community)
if task:
addSR(taskID=task.task_id, srid=srid)
return {
'Service Request': {
'id': str(srid),
'task id': str(task.task_id)
}
}
else:
raise nfw.HTTPError(nfw.HTTP_404, 'Failed to create service request',
"Failed to create service request")
def addCust(values, custid):
name = values.get('customer_name')
text_fields = OrderedDict()
for field in sorted(values):
text_fields[field] = values.get(field)
fields = json.dumps(text_fields)
db = nfw.Mysql()
if custid:
sql = 'UPDATE customers set name=%s,fields=%s WHERE id=%s'
vals = (name, fields, custid)
else:
sql = 'INSERT INTO customers (id,name,fields) VALUES (%s,%s,%s)'
vals = (uuid.uuid4(), name, fields)
db.execute(sql, vals)
db.commit()
def addSupernet(values, supernet, sid=None):
supernet = values.get('supernet')
db = nfw.Mysql()
supernet = supernet.split('/')
network = ip2dec(supernet[0], 4)
prefix = int(supernet[1])
vals = [network, prefix]
if sid:
sql = 'UPDATE supernets set network=%s,prefix=%s where id=%s'
vals.append(sid)
else:
sql = 'INSERT INTO supernets (network,prefix,id) VALUES (%s,%s,%s)'
vals.append(uuid.uuid4())
db.execute(sql, vals)
db.commit()
def assignIGPort(req, id):
values = json.loads(req.read())
port = values['port']
ip = values['device']
db = nfw.Mysql()
sql = 'UPDATE device_port set igroup=%s WHERE id=%s AND port=%s'
result = db.execute(sql, (id, ip, port))
db.commit()
if result > 0:
port_igroup = {'id': port, 'igroup': id, 'device': ip}
return port_igroup
else:
raise nfw.HTTPError(nfw.HTTP_404,
'Port Interface group assignment failed',
'Item not found %s' % (str(result), ))
def getSupernets(sid=None):
if not sid:
sql = "SELECT * FROM supernets"
vars = ()
else:
sql = 'SELECT * FROM supernets where id="%s"'
vars = (sid, )
db = nfw.Mysql()
results = db.execute(sql, vars)
supernets = {}
for result in results:
# perhaps the supernets table needs a version column
supernets[result['id']] = str(dec2ip(result['network'], 4))
supernets[result['id']] += "/" + str(result['prefix'])
return supernets
def mysqlLJ(s, f, ljo, w=None, g=None):
sql = ['SELECT']
vals = []
for i, k in enumerate(s):
if i > 0:
sql.append(',')
sql.append(k)
if not re.search('\.\*$', k):
sql.append('AS')
sql.append(s[k])
sql.append('FROM')
sql.append(f)
for k in ljo:
sql.append('LEFT JOIN')
sql.append(k)
sql.append('ON')
for i, o in enumerate(ljo[k]):
if i > 0:
sql.append('AND')
sql.append(o + "=" + ljo[k][o])
if w:
sql.append('WHERE')
for i, k in enumerate(w):
if i > 0:
sql.append('AND')
if w[k]:
sql.append(k + '=%s')
vals.append(w[k])
else:
sql.append(k + " IS NULL")
if g:
sql.append('GROUP BY')
for i, a in enumerate(g):
if i > 0:
sql.append(',')
sql.append(g[i])
db = nfw.Mysql()
results = db.execute(' '.join(sql), vals)
resources = []
for result in results:
res = {}
for k in result:
if result[k]:
res[k] = result[k]
else:
res[k] = None
resources.append(res)
return resources
def addDevice(host, user, srid=None, community=None):
db = nfw.Mysql(host=mysql.get('host'),
database=mysql.get('database'),
username=mysql.get('username'),
password=mysql.get('password'))
intIP = ip2dec(host, 4)
session = Session(hostname=host, community=community, version=2)
try:
# getting system.sysDescr.0
sysdescription = session.get('1.3.6.1.2.1.1.1.0')
except Exception, e:
print(str(e))
if srid:
sql = 'UPDATE service_requests SET result="%s",status="UNKNOWN" where id="%s"'
db.execute(sql, (str(e), srid))
db.commit()
sys.exit(0)
def addService(values, service_id):
db = nfw.Mysql()
serviceName = values.get('service_name', '')
interfaceGroup = values.get('interface_group', '')
userRole = values.get('user_role', '')
snippet = values.get('config_snippet', '')
activate_snippet = values.get('activate_snippet', None)
deactivate_snippet = values.get('deactivate_snippet', None)
fields = re.findall('{{ ?(.*?) ?}}', snippet)
if activate_snippet:
afields = re.findall('{{ ?(.*?) ?}}', activate_snippet)
else:
afields = None
if deactivate_snippet:
dfields = re.findall('{{ ?(.*?) ?}}', deactivate_snippet)
else:
dfields = None
if not fields:
fields = []
if afields:
fields.extend(afields)
if dfields:
fields.extend(dfields)
if fields:
fields = ','.join(list(set(fields)))
else:
fields = None
values = [
serviceName, interfaceGroup, userRole, snippet, activate_snippet,
deactivate_snippet, fields
]
if service_id:
sql = ("UPDATE services" + " SET name=%s," + " interface_group=%s," +
" user_role=%s," + " config_snippet=%s," +
" activate_snippet=%s," + " deactivate_snippet=%s," +
" fields=%s" + " WHERE id=%s")
values.append(service_id)
else:
values.append(uuid.uuid4())
sql = ("INSERT INTO services" +
" (name,interface_group,user_role,config_snippet," +
" activate_snippet,deactivate_snippet,fields,id)" +
" VALUES (%s,%s, %s, %s, %s, %s, %s, %s)")
db.execute(sql, values)
db.commit()
def viewDevicePorts(req, resp, ip, view=None):
if view == "select2":
vals = []
sql = 'SELECT * FROM interface where id=%s'
vals.append(int(ip))
db = nfw.Mysql()
results = db.execute(sql, vals)
if len(results) == 0:
raise HTTPNotFound("Not Found", "Device/ports not found")
ports = []
for result in results:
ports.append({'id': result['port'], 'text': result['name']})
return json.dumps(ports, indent=4)
else:
rmap = {}
rmap['interface_groups.name'] = 'igroupname'
rmap['tenant.name'] = 'customername'
rmap['services.name'] = 'service'
ljo = OrderedDict()
left_join = api.LeftJoin(rmap, ljo)
ljo['(select max(id) as srid,device,port from service_requests group by device,port) srport'] = {
'device_port.port': 'srport.port',
'device_port.id': 'srport.device'
}
ljo['(select id,customer,service FROM service_requests WHERE status in ("SUCCESS","ACTIVE") ) srrest'] = {
'srrest.id': 'srid'
}
ljo['tenant'] = {'srrest.customer': 'tenant.id'}
ljo['interface_groups'] = {'device_port.igroup': 'interface_groups.id'}
ljo['services'] = {'srrest.service': 'services.id'}
where = "device_port.id"
where_values = [ip]
return api.sql_get('device_port',
req,
resp,
None,
where=where,
where_values=where_values,
left_join=left_join)
def addSR(device=None,
taskID=None,
srid=None,
customer=None,
port=None,
service=None,
snippet=None,
resources=None):
db = nfw.Mysql()
if taskID and srid:
sql = 'UPDATE service_requests set task_id=%s WHERE id=%s'
vals = (taskID, srid)
else:
srid = str(uuid.uuid4())
sql = ('INSERT INTO service_requests' +
' (id,device,customer,port,service,result,resources)' +
' VALUES (%s,%s,%s,%s,%s,%s,%s)')
vals = (srid, device, customer, port, service, snippet, resources)
db.execute(sql, vals)
db.commit()
return srid
def deactivateSR(req, srid):
db = nfw.Mysql()
sql = 'SELECT service,resources,device FROM service_requests WHERE id=%s'
result = db.execute(sql, (srid, ))
if result:
device = result[0]['device']
sid = result[0]['service']
resources = result[0]['resources']
resources = json.loads(resources) if resources else None
sql = 'SELECT deactivate_snippet FROM services WHERE id=%s'
sresult = db.execute(sql, (sid, ))
if sresult[0]['deactivate_snippet']:
djsnip = Template(sresult[0]['deactivate_snippet'])
deactivation_snippet = djsnip.render(**resources)
sql = ('UPDATE service_requests SET status="PENDING"' +
' WHERE id=%s')
db.execute(sql, (srid, ))
db.commit()
deviceIP = dec2ip(int(device), 4)
loggedInUser = getLoggedInUser(req)
user = loggedInUser['username']
task = confDevice.delay(deviceIP,
user=user,
snippet=deactivation_snippet,
srid=srid,
deactivate=True)
addSR(taskID=task.task_id, srid=srid)
return {"Service Request ID": srid, "Task ID": task.id}
else:
sql = ('UPDATE service_requests SET status="INACTIVE"' +
' WHERE id=%s')
db.execute(sql, (srid, ))
db.commit()
return {"Service Request ID": srid}
else:
raise nfw.HTTPError(nfw.HTTP_404, 'Service activation failed',
'Service request not found: %s' % (srid, ))
def removeCust(custid):
db = nfw.Mysql()
sql = 'DELETE FROM customers WHERE id=%s'
db.execute(sql, (custid, ))
db.commit()
def _interface(self, environ, start_response):
# environ points to a dictionary containing CGI like environment
# variables which is populated by the server for each
# received request from the client
# start_response is a callback function supplied by the server
# which takes the HTTP status and headers as arguments
# When the method is POST the variable will be sent
# in the HTTP request body which is passed by the WSGI server
# in the file like wsgi.input environment variable.
debug = self.log_config.getboolean('debug')
if 'redis' in self.config:
redis = nfw.redis(self.config)
session = nfw.SessionRedis(self.config, redis=redis)
else:
session = nfw.SessionFile(self.config, app_root=self.app_root)
session_cookie = session.setup(environ)
mysql_config = self.config.get('mysql')
if mysql_config.get('database') is not None:
nfw.Mysql(**mysql_config.data)
req = nfw.Request(environ, self.config, session, self.router,
self.logger, self)
resp = nfw.Response(req)
resp.headers['Set-Cookie'] = session_cookie
r = self.router.route(req)
if debug is True:
log.debug("Request URI: %s" % (req.get_full_path()))
log.debug("Request QUERY: %s" % (req.environ['QUERY_STRING'], ))
response_headers = []
nfw.jinja.globals['SITE'] = req.environ['SCRIPT_NAME']
nfw.jinja.request['REQUEST'] = req
if nfw.jinja.globals['SITE'] == '/':
nfw.jinja.globals['SITE'] = ''
nfw.jinja.globals['STATIC'] = self.app_config.get('static',
'').rstrip('/')
if nfw.jinja.globals['STATIC'] == '/':
nfw.jinja.globals['STATIC'] = ''
returned = None
try:
if r is not None:
route, obj_kwargs = r
method, route, obj, name = route
req.args = obj_kwargs
req.view = name
else:
obj_kwargs = {}
policy = nfw.Policy(self.policy,
context=req.context,
session=req.session,
kwargs=obj_kwargs,
qwargs=req.query)
req.policy = policy
for m in self.middleware:
if hasattr(m, 'pre'):
m.pre(req, resp)
if r is not None:
if policy.validate(req.view):
returned = nfw.utils.if_unicode_to_utf8(
obj(req, resp, **obj_kwargs))
else:
raise nfw.HTTPForbidden(
'Access Forbidden',
'Access denied by application policy')
else:
raise nfw.HTTPNotFound(description=req.environ['PATH_INFO'])
for m in reversed(self.middleware):
if hasattr(m, 'post'):
m.post(req, resp)
except nfw.HTTPError as e:
if debug is True:
trace = str(traceback.format_exc())
log.error("%s\n%s" % (e, trace))
self._error(e, req, resp)
except Exception as e:
trace = str(traceback.format_exc())
log.error("%s\n%s" % (e, trace))
self._error(e, req, resp)
resp.headers['X-Powered-By'] = 'Neutrino'
resp.headers['X-Request-ID'] = req.request_id
# HTTP headers expected by the client
# They must be wrapped as a list of tupled pairs:
# [(Header name, Header value)].
for header in resp.headers:
header = nfw.utils.if_unicode_to_utf8(header)
value = nfw.utils.if_unicode_to_utf8(resp.headers[header])
h = (header, value)
response_headers.append(h)
content_length = None
if returned is None:
content_length = resp.content_length
else:
if isinstance(returned, str):
content_length = len(returned)
if content_length is not None:
response_headers.append(('Content-Length'.encode('utf-8'),
str(content_length).encode('utf-8')))
# Send status and headers to the server using the supplied function
start_response(resp.status, response_headers)
self._cleanup()
session.save()
if returned is not None:
return returned
else:
return resp
def removeSupernet(sid):
db = nfw.Mysql()
sql = 'DELETE FROM supernets WHERE id=%s'
vals = (sid, )
db.execute(sql, vals)
db.commit()
def removeIGroup(igid):
db = nfw.Mysql()
sql = 'DELETE FROM interface_groups WHERE id=%s'
vals = (igid, )
db.execute(sql, vals)
db.commit()
def removeService(sid):
db = nfw.Mysql()
sql = 'DELETE FROM services WHERE id=%s'
vals = (sid, )
db.execute(sql, vals)
db.commit()
