def test_load_data(self):
"""
"""
th = TestHelper()
p1 = th.add_prefix('192.168.0.0/16', 'reservation', 'test')
p2 = th.add_prefix('192.168.0.0/20', 'reservation', 'test')
p3 = th.add_prefix('192.168.0.0/24', 'reservation', 'test')
p4 = th.add_prefix('192.168.1.0/24', 'reservation', 'test')
p5 = th.add_prefix('192.168.2.0/24', 'reservation', 'test')
p6 = th.add_prefix('192.168.32.0/20', 'reservation', 'test')
p7 = th.add_prefix('192.168.32.0/24', 'reservation', 'test')
ps1 = th.add_prefix('2001:db8:1::/48', 'reservation', 'test')
ps2 = th.add_prefix('2001:db8:1::/64', 'reservation', 'test')
ps3 = th.add_prefix('2001:db8:2::/48', 'reservation', 'test')
pool1 = Pool()
pool1.name = 'upgrade-test'
pool1.save()
p2.pool = pool1
p2.save()
ps1.pool = pool1
ps1.save()
pool2 = Pool()
pool2.name = 'upgrade-test2'
pool2.save()
vrf1 = VRF()
vrf1.name = 'foo'
vrf1.rt = '123:123'
vrf1.save()
def test_add_pool(self):
""" We should NOT be able to execute add_pool as read-only user
"""
p = Pool()
p.name = 'test'
with self.assertRaises(NipapAuthorizationError):
p.save()
def test_load_data(self):
"""
"""
th = TestHelper()
p1 = th.add_prefix('192.168.0.0/16', 'reservation', 'test')
p2 = th.add_prefix('192.168.0.0/20', 'reservation', 'test')
p3 = th.add_prefix('192.168.0.0/24', 'reservation', 'test')
p4 = th.add_prefix('192.168.1.0/24', 'reservation', 'test')
p5 = th.add_prefix('192.168.2.0/24', 'reservation', 'test')
p6 = th.add_prefix('192.168.32.0/20', 'reservation', 'test')
p7 = th.add_prefix('192.168.32.0/24', 'reservation', 'test')
p8 = th.add_prefix('192.168.32.1/32', 'reservation', 'test')
ps1 = th.add_prefix('2001:db8:1::/48', 'reservation', 'test')
ps2 = th.add_prefix('2001:db8:1::/64', 'reservation', 'test')
ps3 = th.add_prefix('2001:db8:2::/48', 'reservation', 'test')
pool1 = Pool()
pool1.name = 'upgrade-test'
pool1.ipv4_default_prefix_length = 31
pool1.ipv6_default_prefix_length = 112
pool1.save()
p2.pool = pool1
p2.save()
ps1.pool = pool1
ps1.save()
pool2 = Pool()
pool2.name = 'upgrade-test2'
pool2.save()
vrf1 = VRF()
vrf1.name = 'foo'
vrf1.rt = '123:123'
vrf1.save()
def test_edit_pool(self):
""" We should NOT be able to execute edit_pool as read-only user
"""
p = Pool()
p.id = 123
with self.assertRaises(NipapAuthorizationError):
p.save()
def add_pool(self):
""" Add a pool.
"""
# extract attributes
p = Pool()
if 'name' in request.json:
p.name = validate_string(request.json, 'name')
if 'description' in request.json:
p.description = validate_string(request.json, 'description')
if 'default_type' in request.json:
p.default_type = validate_string(request.json, 'default_type')
# TODO: handle integers
if 'ipv4_default_prefix_length' in request.json:
p.ipv4_default_prefix_length = request.json['ipv4_default_prefix_length']
if 'ipv6_default_prefix_length' in request.json:
p.ipv6_default_prefix_length = request.json['ipv6_default_prefix_length']
if 'tags' in request.json:
p.tags = request.json['tags']
if 'avps' in request.json:
p.avps = request.json['avps']
try:
p.save()
except NipapError, e:
return json.dumps({'error': 1, 'message': e.args, 'type': type(e).__name__})
def test_remove_pool(self):
""" We should NOT be able to execute remove_pool as read-only user
"""
p = Pool()
p.id = 0
with self.assertRaises(NipapAuthorizationError):
p.remove()
def add(self):
""" Add a pool.
"""
if 'schema' not in request.params:
redirect(url(controller = 'schema', action = 'list'))
c.schema = Schema.get(int(request.params['schema']))
# Adding to NIPAP
if request.method == 'POST':
p = Pool()
p.schema = c.schema
p.name = request.params.get('name')
p.description = request.params.get('description')
p.default_type = request.params.get('default_type')
if request.params['ipv4_default_prefix_length'].strip() != '':
p.ipv4_default_prefix_length = request.params['ipv4_default_prefix_length']
if request.params['ipv6_default_prefix_length'].strip() != '':
p.ipv6_default_prefix_length = request.params['ipv6_default_prefix_length']
p.save()
redirect(url(controller = 'pool', action = 'list', schema = c.schema.id))
return render("/pool_add.html")
def add_pool(self):
""" Add a pool.
"""
# extract attributes
p = Pool()
p.name = request.params.get('name')
p.description = request.params.get('description')
p.default_type = request.params.get('default_type')
if 'ipv4_default_prefix_length' in request.params:
if request.params['ipv4_default_prefix_length'].strip() != '':
p.ipv4_default_prefix_length = request.params[
'ipv4_default_prefix_length']
if 'ipv6_default_prefix_length' in request.params:
if request.params['ipv6_default_prefix_length'].strip() != '':
p.ipv6_default_prefix_length = request.params[
'ipv6_default_prefix_length']
try:
p.save()
except NipapError, e:
return json.dumps({
'error': 1,
'message': e.args,
'type': type(e).__name__
})
def test_stats3(self):
""" Check total stats are correct when adding and removing child prefixes from pool
"""
th = TestHelper()
# add a pool
pool1 = th.add_pool('test', 'assignment', 31, 112)
# add some members to the pool
p1 = th.add_prefix('1.0.0.0/24', 'reservation', 'test', pool_id=pool1.id)
p2 = th.add_prefix('2001:db8::/48', 'reservation', 'test', pool_id=pool1.id)
# add child from pool
pc1 = th.add_prefix_from_pool(pool1, 4, 'foo')
pc2 = th.add_prefix_from_pool(pool1, 6, 'foo')
# check stats for pool1
res = Pool.list({ 'id': pool1.id })
# ipv4
self.assertEqual(1, res[0].member_prefixes_v4)
self.assertEqual(1, res[0].used_prefixes_v4)
self.assertEqual(256, res[0].total_addresses_v4)
self.assertEqual(2, res[0].used_addresses_v4)
self.assertEqual(254, res[0].free_addresses_v4)
# ipv6
self.assertEqual(1, res[0].member_prefixes_v6)
self.assertEqual(1, res[0].used_prefixes_v6)
self.assertEqual(1208925819614629174706176, res[0].total_addresses_v6)
self.assertEqual(65536, res[0].used_addresses_v6)
self.assertEqual(1208925819614629174640640, res[0].free_addresses_v6)
# remove child prefixes
pc1.remove()
pc2.remove()
# check stats for pool1
res = Pool.list({ 'id': pool1.id })
# ipv4
self.assertEqual(1, res[0].member_prefixes_v4)
self.assertEqual(0, res[0].used_prefixes_v4)
self.assertEqual(256, res[0].total_addresses_v4)
self.assertEqual(0, res[0].used_addresses_v4)
self.assertEqual(256, res[0].free_addresses_v4)
# ipv6
self.assertEqual(1, res[0].member_prefixes_v6)
self.assertEqual(0, res[0].used_prefixes_v6)
self.assertEqual(1208925819614629174706176, res[0].total_addresses_v6)
self.assertEqual(0, res[0].used_addresses_v6)
self.assertEqual(1208925819614629174706176, res[0].free_addresses_v6)
def smart_search_pool(self):
""" Perform a smart pool search.
The "smart" search function tries extract a query from
a text string. This query is then passed to the search_pool
function, which performs the search.
"""
search_options = {}
if 'query_id' in request.params:
search_options['query_id'] = request.params['query_id']
if 'max_result' in request.params:
search_options['max_result'] = request.params['max_result']
if 'offset' in request.params:
search_options['offset'] = request.params['offset']
log.debug("params: %s" % str(request.params))
log.debug("Smart search query: schema=%d q=%s search_options=%s" %
(int(request.params['schema']),
request.params['query_string'],
str(search_options)
))
try:
schema = Schema.get(int(request.params['schema']))
result = Pool.smart_search(schema,
request.params['query_string'],
search_options
)
except NipapError, e:
return json.dumps({'error': 1, 'message': e.args, 'type': type(e).__name__})
def modify_pool(arg, opts):
""" Modify a pool with the options set in opts
"""
s = get_schema()
res = Pool.list(s, { 'name': arg })
if len(res) < 1:
print >> sys.stderr, "No pool with name %s found." % arg
sys.exit(1)
p = res[0]
if 'name' in opts:
p.name = opts['name']
if 'description' in opts:
p.description = opts['description']
if 'default-type' in opts:
p.default_type = opts['default-type']
if 'ipv4_default_prefix_length' in opts:
p.ipv4_default_prefix_length = opts['ipv4_default_prefix_length']
if 'ipv6_default_prefix_length' in opts:
p.ipv6_default_prefix_length = opts['ipv6_default_prefix_length']
p.save()
print "Pool %s saved." % p.name
def list(self):
""" Displays a list of pools.
"""
c.pools = Pool.list()
return render('/pool_list.html')
def list_pool(arg, opts):
""" List pools matching a search criteria
"""
s = get_schema()
query = _expand_list_query(opts)
res = Pool.search(s, query)
if len(res['result']) > 0:
print "%-19s %-39s %-14s %-8s" % (
"Name", "Description", "Default type", "4 / 6"
)
print "-----------------------------------------------------------------------------------"
else:
print "No matching pools found"
for p in res['result']:
if len(p.description) > 38:
desc = p.description[0:34] + "..."
else:
desc = p.description
print "%-19s %-39s %-14s %-2s / %-3s" % (
p.name, desc, p.default_type,
str(p.ipv4_default_prefix_length),
str(p.ipv6_default_prefix_length)
)
def edit_pool(self, id):
""" Edit a pool.
"""
# extract attributes
p = Pool.get(int(id))
if 'name' in request.params:
p.name = request.params.get('name')
if 'description' in request.params:
p.description = request.params.get('description')
if 'default_type' in request.params:
p.default_type = request.params.get('default_type')
if 'ipv4_default_prefix_length' in request.params:
if request.params['ipv4_default_prefix_length'].strip() != '':
p.ipv4_default_prefix_length = request.params['ipv4_default_prefix_length']
else:
p.ipv4_default_prefix_length = None
if 'ipv6_default_prefix_length' in request.params:
if request.params['ipv6_default_prefix_length'].strip() != '':
p.ipv6_default_prefix_length = request.params['ipv6_default_prefix_length']
else:
p.ipv6_default_prefix_length = None
if 'tags' in request.params:
p.tags = json.loads(request.params['tags'])
if 'avps' in request.params:
p.avps = json.loads(request.params['avps'])
try:
p.save()
except NipapError, e:
return json.dumps({'error': 1, 'message': e.args, 'type': type(e).__name__})
def smart_search_pool(self):
""" Perform a smart pool search.
The "smart" search function tries extract a query from
a text string. This query is then passed to the search_pool
function, which performs the search.
"""
search_options = {}
if 'query_id' in request.params:
search_options['query_id'] = request.params['query_id']
if 'max_result' in request.params:
search_options['max_result'] = request.params['max_result']
if 'offset' in request.params:
search_options['offset'] = request.params['offset']
try:
result = Pool.smart_search(request.params['query_string'],
search_options)
except NipapError, e:
return json.dumps({
'error': 1,
'message': e.args,
'type': type(e).__name__
})
def smart_search_pool(self):
""" Perform a smart pool search.
The "smart" search function tries extract a query from
a text string. This query is then passed to the search_pool
function, which performs the search.
"""
search_options = {}
if 'query_id' in request.json:
search_options['query_id'] = request.json['query_id']
if 'max_result' in request.json:
search_options['max_result'] = request.json['max_result']
if 'offset' in request.json:
search_options['offset'] = request.json['offset']
try:
result = Pool.smart_search(request.json['query_string'],
search_options
)
# Remove error key in result from backend as it interferes with the
# error handling of the web interface.
# TODO: Reevaluate how to deal with different types of errors; soft
# errors like query string parser errors and hard errors like lost
# database.
del result['error']
except NipapError, e:
return json.dumps({'error': 1, 'message': e.args, 'type': type(e).__name__})
def edit(self, id):
""" Edit a pool.
"""
c.pool = Pool.get(int(id))
c.prefix_list = Prefix.list({'pool_id': c.pool.id})
c.prefix = ''
# save changes to NIPAP
if request.method == 'POST':
c.pool.name = request.params['name']
c.pool.description = request.params['description']
c.pool.default_type = request.params['default_type']
if request.params['ipv4_default_prefix_length'].strip() == '':
c.pool.ipv4_default_prefix_length = None
else:
c.pool.ipv4_default_prefix_length = request.params[
'ipv4_default_prefix_length']
if request.params['ipv6_default_prefix_length'].strip() == '':
c.pool.ipv6_default_prefix_length = None
else:
c.pool.ipv6_default_prefix_length = request.params[
'ipv6_default_prefix_length']
c.pool.save()
redirect(url(controller='pool', action='list'))
c.search_opt_parent = 'all'
c.search_opt_child = 'none'
return render("/pool_edit.html")
def edit(self, id):
""" Edit a pool.
"""
c.pool = Pool.get(int(id))
c.prefix_list = Prefix.list({ 'pool_id': c.pool.id })
c.prefix = ''
# save changes to NIPAP
if request.method == 'POST':
c.pool.name = request.params['name']
c.pool.description = request.params['description']
c.pool.default_type = request.params['default_type']
if request.params['ipv4_default_prefix_length'].strip() == '':
c.pool.ipv4_default_prefix_length = None
else:
c.pool.ipv4_default_prefix_length = request.params['ipv4_default_prefix_length']
if request.params['ipv6_default_prefix_length'].strip() == '':
c.pool.ipv6_default_prefix_length = None
else:
c.pool.ipv6_default_prefix_length = request.params['ipv6_default_prefix_length']
c.pool.save()
redirect(url(controller = 'pool', action = 'list'))
c.search_opt_parent = 'all'
c.search_opt_child = 'none'
return render("/pool_edit.html")
def edit_pool(self, id):
""" Edit a pool.
"""
# extract attributes
p = Pool.get(int(id))
if 'name' in request.json:
p.name = validate_string(request.json, 'name')
if 'description' in request.json:
p.description = validate_string(request.json, 'description')
if 'default_type' in request.json:
p.default_type = validate_string(request.json, 'default_type')
# TODO: handle integers
if 'ipv4_default_prefix_length' in request.json:
p.ipv4_default_prefix_length = request.json[
'ipv4_default_prefix_length']
if 'ipv6_default_prefix_length' in request.json:
p.ipv6_default_prefix_length = request.json[
'ipv6_default_prefix_length']
if 'tags' in request.json:
p.tags = request.json['tags']
if 'avps' in request.json:
p.avps = request.json['avps']
try:
p.save()
except NipapError, e:
return json.dumps({
'error': 1,
'message': e.args,
'type': type(e).__name__
})
def remove(self, id):
""" Remove pool.
"""
p = Pool.get(int(id))
p.remove()
redirect(url(controller = 'pool', action = 'list'))
def smart_search_pool(self):
""" Perform a smart pool search.
The "smart" search function tries extract a query from
a text string. This query is then passed to the search_pool
function, which performs the search.
"""
search_options = {}
if 'query_id' in request.json:
search_options['query_id'] = request.json['query_id']
if 'max_result' in request.json:
search_options['max_result'] = request.json['max_result']
if 'offset' in request.json:
search_options['offset'] = request.json['offset']
try:
result = Pool.smart_search(request.json['query_string'],
search_options)
# Remove error key in result from backend as it interferes with the
# error handling of the web interface.
# TODO: Reevaluate how to deal with different types of errors; soft
# errors like query string parser errors and hard errors like lost
# database.
del result['error']
except NipapError, e:
return json.dumps({
'error': 1,
'message': e.args,
'type': type(e).__name__
})
def test_stats2(self):
""" Check total stats are correct when updating member prefix
"""
th = TestHelper()
# add a pool
pool1 = th.add_pool('test', 'assignment', 31, 112)
# add some members to the pool
p1 = th.add_prefix('1.0.0.0/24', 'reservation', 'test', pool_id=pool1.id)
p2 = th.add_prefix('2001:db8::/48', 'reservation', 'test', pool_id=pool1.id)
p1.prefix = '1.0.0.0/25'
p1.save()
p2.prefix = '2001:db8::/64'
p2.save()
# check stats for pool1
res = Pool.list({ 'id': pool1.id })
# ipv4
self.assertEqual(1, res[0].member_prefixes_v4)
self.assertEqual(0, res[0].used_prefixes_v4)
self.assertEqual(128, res[0].total_addresses_v4)
self.assertEqual(0, res[0].used_addresses_v4)
self.assertEqual(128, res[0].free_addresses_v4)
# ipv6
self.assertEqual(1, res[0].member_prefixes_v6)
self.assertEqual(0, res[0].used_prefixes_v6)
self.assertEqual(18446744073709551616, res[0].total_addresses_v6)
self.assertEqual(0, res[0].used_addresses_v6)
self.assertEqual(18446744073709551616, res[0].free_addresses_v6)
def delete_pool(self, name):
if len(name) > 0:
pool = Pool.list({"name": name})
try:
pool.remove()
except NipapError as exc:
print("Error: could not remove pool: %s" % str(exc))
def remove(self, id):
""" Remove pool.
"""
p = Pool.get(int(id))
p.remove()
redirect(url(controller='pool', action='list'))
def edit_pool(self, id):
""" Edit a pool.
"""
# extract attributes
p = Pool.get(int(id))
if 'name' in request.params:
p.name = request.params.get('name')
if 'description' in request.params:
p.description = request.params.get('description')
if 'default_type' in request.params:
p.default_type = request.params.get('default_type')
if 'ipv4_default_prefix_length' in request.params:
if request.params['ipv4_default_prefix_length'].strip() != '':
p.ipv4_default_prefix_length = request.params[
'ipv4_default_prefix_length']
else:
p.ipv4_default_prefix_length = None
if 'ipv6_default_prefix_length' in request.params:
if request.params['ipv6_default_prefix_length'].strip() != '':
p.ipv6_default_prefix_length = request.params[
'ipv6_default_prefix_length']
else:
p.ipv6_default_prefix_length = None
try:
p.save()
except NipapError, e:
return json.dumps({
'error': 1,
'message': e.args,
'type': type(e).__name__
})
def get_pools(self):
self.lock.acquire()
try:
self.pools = Pool.list()
except Exception as e:
self.lock.release()
raise e
self.lock.release()
def edit_prefix(self, id):
""" Edit a prefix.
"""
try:
p = Prefix.get(int(id))
# extract attributes
if 'prefix' in request.json:
p.prefix = validate_string(request.json, 'prefix')
if 'type' in request.json:
p.type = validate_string(request.json, 'type')
if 'description' in request.json:
p.description = validate_string(request.json, 'description')
if 'expires' in request.json:
p.expires = validate_string(request.json, 'expires')
if 'comment' in request.json:
p.comment = validate_string(request.json, 'comment')
if 'node' in request.json:
p.node = validate_string(request.json, 'node')
if 'status' in request.json:
p.status = validate_string(request.json, 'status')
if 'pool' in request.json:
if request.json['pool'] is None:
p.pool = None
else:
try:
p.pool = Pool.get(int(request.json['pool']))
except NipapError, e:
return json.dumps({'error': 1, 'message': e.args, 'type': type(e).__name__})
if 'alarm_priority' in request.json:
p.alarm_priority = validate_string(request.json, 'alarm_priority')
if 'monitor' in request.json:
if request.json['monitor'] == 'true':
p.monitor = True
else:
p.monitor = False
if 'country' in request.json:
p.country = validate_string(request.json, 'country')
if 'order_id' in request.json:
p.order_id = validate_string(request.json, 'order_id')
if 'customer_id' in request.json:
p.customer_id = validate_string(request.json, 'customer_id')
if 'vrf' in request.json:
try:
if request.json['vrf'] is None or len(unicode(request.json['vrf'])) == 0:
p.vrf = None
else:
p.vrf = VRF.get(int(request.json['vrf']))
except ValueError:
return json.dumps({'error': 1, 'message': "Invalid VRF ID '%s'" % request.json['vrf']})
except NipapError, e:
return json.dumps({'error': 1, 'message': e.args, 'type': type(e).__name__})
def list_pool(self):
""" List pools and return JSON encoded result.
"""
try:
schema = Schema.get(int(request.params['schema']))
pools = Pool.list(schema)
except NipapError, e:
return json.dumps({'error': 1, 'message': e.args, 'type': type(e).__name__})
def add_pool(self, name, default_type, ipv4_default_prefix_length, ipv6_default_prefix_length):
pool = Pool()
pool.name = name
pool.default_type = default_type
pool.ipv4_default_prefix_length = ipv4_default_prefix_length
pool.ipv6_default_prefix_length = ipv6_default_prefix_length
pool.save()
return pool
def add(self):
""" Add a prefix.
"""
# make sure we have a schema
try:
c.schema = Schema.get(int(request.params['schema']))
c.pools = Pool.list(c.schema)
except (KeyError, NipapNonExistentError), e:
redirect(url(controller = 'schema', action = 'list'))
def add_pool(self, name, description, default_type, ipv4_default_prefix_length):
pool = Pool()
pool.name = name
pool.description = description
pool.default_type = default_type
pool.ipv4_default_prefix_length = ipv4_default_prefix_length
try:
pool.save()
return pool
except NipapError as exc:
print("Error: could not add pool to NIPAP: %s" % str(exc))
return None
def remove_pool(self, id):
""" Remove a pool.
"""
try:
pool = Pool.get(int(id))
pool.remove()
except NipapError, e:
return json.dumps({'error': 1, 'message': e.args, 'type': type(e).__name__})
def list(self):
""" Displays a list of pools.
"""
if 'schema' not in request.params:
redirect(url(controller = 'schema', action = 'list'))
c.schema = Schema.get(int(request.params['schema']))
c.pools = Pool.list(c.schema)
return render('/pool_list.html')
def list_pool(self):
""" List pools and return JSON encoded result.
"""
# fetch attributes from request.json
attr = XhrController.extract_pool_attr(request.json)
try:
pools = Pool.list(attr)
except NipapError, e:
return json.dumps({'error': 1, 'message': e.args, 'type': type(e).__name__})
def remove(self, id):
""" Remove pool.
"""
if 'schema' not in request.params:
redirect(url(controller = 'schema', action = 'list'))
schema = Schema.get(int(request.params['schema']))
p = Pool.get(schema, int(id))
p.remove()
redirect(url(controller = 'pool', action = 'list', schema = schema.id))
def add_pool(arg, opts):
""" Add a pool.
"""
p = Pool()
p.schema = get_schema(opts.get('schema'))
p.name = opts.get('name')
p.description = opts.get('description')
p.default_type = opts.get('default-type')
p.ipv4_default_prefix_length = opts.get('ipv4_default_prefix_length')
p.ipv6_default_prefix_length = opts.get('ipv6_default_prefix_length')
try:
p.save()
except pynipap.NipapError, e:
print >> sys.stderr, "Could not add pool to NIPAP: %s" % e.message
sys.exit(1)
def add_prefix(self, prefix, type, description, tags=[], pool_id=None):
p = Prefix()
p.prefix = prefix
p.type = type
p.description = description
p.tags = tags
if pool_id:
pool = Pool.get(pool_id)
p.pool = pool
p.save()
return p
def remove_pool(self, id):
""" Remove a pool.
"""
try:
pool = Pool.get(int(id))
pool.remove()
except NipapError, e:
return json.dumps({
'error': 1,
'message': e.args,
'type': type(e).__name__
})
def add_prefix(self, id):
""" Add a prefix to pool 'id'
"""
if 'prefix' not in request.params:
abort(400, 'Missing prefix.')
pool = Pool.get(int(id))
prefix = Prefix.get(int(request.params['prefix']))
prefix.pool = pool
prefix.save()
redirect(url(controller = 'pool', action = 'edit', id = id))
def add_prefix(self, id):
""" Add a prefix to pool 'id'
"""
if 'prefix' not in request.params:
abort(400, 'Missing prefix.')
pool = Pool.get(int(id))
prefix = Prefix.get(int(request.params['prefix']))
prefix.pool = pool
prefix.save()
redirect(url(controller='pool', action='edit', id=id))
def add_prefix(arg, opts):
""" Add prefix to NIPAP
"""
s = get_schema()
p = Prefix()
p.schema = s
p.prefix = opts.get('prefix')
p.type = opts.get('type')
p.description = opts.get('description')
p.node = opts.get('node')
p.country = opts.get('country')
p.order_id = opts.get('order_id')
p.vrf = opts.get('vrf')
p.alarm_priority = opts.get('alarm_priority')
p.comment = opts.get('comment')
p.monitor = _str_to_bool(opts.get('monitor'))
args = {}
if 'from-pool' in opts:
res = Pool.list(s, { 'name': opts['from-pool'] })
if len(res) == 0:
print >> sys.stderr, "No pool named %s found." % opts['from-pool']
sys.exit(1)
args['from-pool'] = res[0]
if 'from-prefix' in opts:
args['from-prefix'] = [ opts['from-prefix'], ]
if 'prefix-length' in opts:
args['prefix_length'] = int(opts['prefix-length'])
if 'family' in opts:
family = opts['family']
if opts['family'] == 'ipv4':
family = 4
elif opts['family'] == 'ipv6':
family = 6
args['family'] = family
try:
p.save(args)
except NipapError, e:
print >> sys.stderr, "Could not add prefix to NIPAP: %s" % e.message
sys.exit(1)
def list_pool(self):
""" List pools and return JSON encoded result.
"""
# fetch attributes from request.json
attr = XhrController.extract_pool_attr(request.json)
try:
pools = Pool.list(attr)
except NipapError, e:
return json.dumps({
'error': 1,
'message': e.args,
'type': type(e).__name__
})
def remove_pool(self, id):
""" Remove a pool.
"""
try:
pool = Pool.get(int(id))
name = pool.name
pool.remove()
log.info('remove_pool (%s) %s' % (session['user'], name))
except NipapError, e:
return json.dumps({
'error': 1,
'message': e.args,
'type': type(e).__name__
})
def add(self):
""" Add a pool.
"""
# Adding to NIPAP
if request.method == 'POST':
p = Pool()
p.name = request.params.get('name')
p.description = request.params.get('description')
p.default_type = request.params.get('default_type')
if request.params['ipv4_default_prefix_length'].strip() != '':
p.ipv4_default_prefix_length = request.params[
'ipv4_default_prefix_length']
if request.params['ipv6_default_prefix_length'].strip() != '':
p.ipv6_default_prefix_length = request.params[
'ipv6_default_prefix_length']
p.save()
redirect(url(controller='pool', action='list'))
return render("/pool_add.html")
def add_pool(self):
""" Add a pool.
"""
# extract attributes
p = Pool()
p.name = request.params.get('name')
p.description = request.params.get('description')
p.default_type = request.params.get('default_type')
if 'ipv4_default_prefix_length' in request.params:
if request.params['ipv4_default_prefix_length'].strip() != '':
p.ipv4_default_prefix_length = request.params['ipv4_default_prefix_length']
if 'ipv6_default_prefix_length' in request.params:
if request.params['ipv6_default_prefix_length'].strip() != '':
p.ipv6_default_prefix_length = request.params['ipv6_default_prefix_length']
try:
p.save()
except NipapError, e:
return json.dumps({'error': 1, 'message': e.args, 'type': type(e).__name__})
def remove_pool(arg, opts):
""" Remove pool
"""
s = get_schema()
res = Pool.list(s, { 'name': arg })
if len(res) < 1:
print >> sys.stderr, "No pool with name %s found." % arg
sys.exit(1)
p = res[0]
res = raw_input("Do you really want to remove the pool %s? [y/n]: " % p.name)
if res == 'y':
p.remove()
print "Pool %s removed." % p.name
else:
print "Operation canceled."
def get_pools(self, name=''):
if len(name) > 0:
pools = Pool.list({"name": name})
else:
pools = Pool.list()
return pools
sys.stdout.write(".")
sys.stdout.flush()
print " done!"
if args.clear_pools:
remove_confirmed = args.force
if not remove_confirmed:
res = raw_input("Are you sure you want to remove all pools? [y/N]")
if len(res) > 0 and res.lower()[0] == 'y':
remove_confirmed = True
else:
print "Operation aborted."
if remove_confirmed:
print "Removing: ",
for p in Pool.list():
p.remove()
sys.stdout.write(".")
sys.stdout.flush()
print " done!"
if args.clear_prefixes:
remove_confirmed = args.force
if not remove_confirmed:
res = raw_input("Are you sure you want to remove all prefixes? [y/N]")
if len(res) > 0 and res.lower()[0] == 'y':
remove_confirmed = True
else:
print "Aborted"
if remove_confirmed:
if 'comment' in request.params:
if request.params['comment'].strip() != '':
p.comment = request.params['comment'].strip()
if 'node' in request.params:
if request.params['node'].strip() != '':
p.node = request.params['node'].strip()
if 'type' in request.params:
p.type = request.params['type'].strip()
if 'pool' in request.params:
if request.params['pool'].strip() != '':
try:
p.pool = Pool.get(int(request.params['pool']))
except NipapError, e:
return json.dumps({
'error': 1,
'message': e.args,
'type': type(e).__name__
})
if 'country' in request.params:
if request.params['country'].strip() != '':
p.country = request.params['country'].strip()
if 'order_id' in request.params:
if request.params['order_id'].strip() != '':
p.order_id = request.params['order_id'].strip()
def add_pool(self):
""" Add a pool.
"""
# extract attributes
p = Pool()
if 'name' in request.json:
p.name = validate_string(request.json, 'name')
if 'description' in request.json:
p.description = validate_string(request.json, 'description')
if 'default_type' in request.json:
p.default_type = validate_string(request.json, 'default_type')
# TODO: handle integers
if 'ipv4_default_prefix_length' in request.json:
p.ipv4_default_prefix_length = request.json[
'ipv4_default_prefix_length']
if 'ipv6_default_prefix_length' in request.json:
p.ipv6_default_prefix_length = request.json[
'ipv6_default_prefix_length']
if 'tags' in request.json:
p.tags = request.json['tags']
if 'avps' in request.json:
p.avps = request.json['avps']
try:
p.save()
log.info('add_pool (%s) %s' % (session['user'], request.json))
except NipapError, e:
return json.dumps({
'error': 1,
'message': e.args,
'type': type(e).__name__
})
_register_inet(conn_or_curs=con_pg_new)
# set up pynipap
aopts = pynipap.AuthOptions({'authoritative_source': 'nipap'})
pynipap.xmlrpc_uri = nipapd_xmlrpc_uri
#
# Create pools
#
print "Creating pools... ",
sql = "SELECT * FROM ip_net_pool"
curs_pg_old.execute(sql)
pools = {}
for r in curs_pg_old:
p = Pool()
p.name = r['name']
p.description = r['description']
p.default_type = r['default_type']
p.ipv4_default_prefix_length = r['ipv4_default_prefix_length']
p.ipv6_default_prefix_length = r['ipv6_default_prefix_length']
try:
p.save()
except NipapError, e:
print "ERR: %s" % str(e)
pools[r['id']] = p
# remove new audit log entries
sql = "DELETE FROM ip_net_log WHERE pool_id = %s"
curs_pg_new.execute(sql, (p.id, ))
def test_list_pool(self):
""" We should be able to execute list_pool as read-only user
"""
with self.assertRaises(NipapNonExistentError):
p = Pool.get(0)
def test_smart_search_pool(self):
""" We should be able to execute smart_search_pool as read-only user
"""
p = Pool.smart_search('default')
def edit_prefix(self, id):
""" Edit a prefix.
"""
try:
p = Prefix.get(int(id))
# extract attributes
if 'prefix' in request.params:
p.prefix = request.params['prefix']
if 'type' in request.params:
p.type = request.params['type'].strip()
if 'description' in request.params:
if request.params['description'].strip() == '':
p.description = None
else:
p.description = request.params['description'].strip()
if 'comment' in request.params:
if request.params['comment'].strip() == '':
p.comment = None
else:
p.comment = request.params['comment'].strip()
if 'node' in request.params:
if request.params['node'].strip() == '':
p.node = None
else:
p.node = request.params['node'].strip()
if 'pool' in request.params:
if request.params['pool'].strip() == '':
p.pool = None
else:
try:
p.pool = Pool.get(int(request.params['pool']))
except NipapError, e:
return json.dumps({
'error': 1,
'message': e.args,
'type': type(e).__name__
})
if 'alarm_priority' in request.params:
p.alarm_priority = request.params['alarm_priority'].strip()
if 'monitor' in request.params:
if request.params['monitor'] == 'true':
p.monitor = True
else:
p.monitor = False
if 'country' in request.params:
if request.params['country'].strip() == '':
p.country = None
else:
p.country = request.params['country'].strip()
if 'order_id' in request.params:
if request.params['order_id'].strip() == '':
p.order_id = None
else:
p.order_id = request.params['order_id'].strip()
if 'customer_id' in request.params:
if request.params['customer_id'].strip() == '':
p.customer_id = None
else:
p.customer_id = request.params['customer_id'].strip()
if 'vrf' in request.params:
try:
if request.params['vrf'] is None or len(
request.params['vrf']) == 0:
p.vrf = None
else:
p.vrf = VRF.get(int(request.params['vrf']))
except ValueError:
return json.dumps({
'error':
1,
'message':
"Invalid VRF ID '%s'" % request.params['vrf']
})
except NipapError, e:
return json.dumps({
'error': 1,
'message': e.args,
'type': type(e).__name__
})
p.description = validate_string(request.json, 'description')
if 'expires' in request.json:
p.expires = validate_string(request.json, 'expires')
if 'comment' in request.json:
p.comment = validate_string(request.json, 'comment')
if 'node' in request.json:
p.node = validate_string(request.json, 'node')
if 'status' in request.json:
p.status = validate_string(request.json, 'status')
if 'type' in request.json:
p.type = validate_string(request.json, 'type')
if 'pool' in request.json:
if request.json['pool'] is not None:
try:
p.pool = Pool.get(int(request.json['pool']))
except NipapError, e:
return json.dumps({
'error': 1,
'message': e.args,
'type': type(e).__name__
})
if 'country' in request.json:
p.country = validate_string(request.json, 'country')
if 'order_id' in request.json:
p.order_id = validate_string(request.json, 'order_id')
if 'customer_id' in request.json:
p.customer_id = validate_string(request.json, 'customer_id')
if 'alarm_priority' in request.json:
p.alarm_priority = validate_string(request.json, 'alarm_priority')
def edit_prefix(self, id):
""" Edit a prefix.
"""
try:
p = Prefix.get(int(id))
# extract attributes
if 'prefix' in request.json:
p.prefix = validate_string(request.json, 'prefix')
if 'type' in request.json:
p.type = validate_string(request.json, 'type')
if 'description' in request.json:
p.description = validate_string(request.json, 'description')
if 'expires' in request.json:
p.expires = validate_string(request.json, 'expires')
if 'comment' in request.json:
p.comment = validate_string(request.json, 'comment')
if 'node' in request.json:
p.node = validate_string(request.json, 'node')
if 'status' in request.json:
p.status = validate_string(request.json, 'status')
if 'pool' in request.json:
if request.json['pool'] is None:
p.pool = None
else:
try:
p.pool = Pool.get(int(request.json['pool']))
except NipapError, e:
return json.dumps({
'error': 1,
'message': e.args,
'type': type(e).__name__
})
if 'alarm_priority' in request.json:
p.alarm_priority = validate_string(request.json,
'alarm_priority')
if 'monitor' in request.json:
if request.json['monitor'] == 'true':
p.monitor = True
else:
p.monitor = False
if 'country' in request.json:
p.country = validate_string(request.json, 'country')
if 'order_id' in request.json:
p.order_id = validate_string(request.json, 'order_id')
if 'customer_id' in request.json:
p.customer_id = validate_string(request.json, 'customer_id')
if 'vrf' in request.json:
try:
if request.json['vrf'] is None or len(
unicode(request.json['vrf'])) == 0:
p.vrf = None
else:
p.vrf = VRF.get(int(request.json['vrf']))
except ValueError:
return json.dumps({
'error':
1,
'message':
"Invalid VRF ID '%s'" % request.json['vrf']
})
except NipapError, e:
return json.dumps({
'error': 1,
'message': e.args,
'type': type(e).__name__
})
def test_search_pool(self):
""" We should be able to execute search_pool as read-only user
"""
p = Pool.search({ 'val1': 'id',
'operator': 'equals',
'val2': 0 })
