def server_client_connect_post(server_id):
org_id = bson.ObjectId(flask.request.json['org_id'])
user_id = bson.ObjectId(flask.request.json['user_id'])
svr = server.get_by_id(server_id,
fields=['_id', 'name', 'network', 'links', 'organizations'])
if not svr:
return utils.jsonify({
'error': SERVER_INVALID,
'error_msg': SERVER_INVALID_MSG,
}, 401)
org = svr.get_org(org_id, fields=['_id'])
if not org:
return utils.jsonify({
'error': ORG_INVALID,
'error_msg': ORG_INVALID_MSG,
}, 401)
user = org.get_user(user_id, fields=['_id', 'name', 'disabled'])
if not user:
return utils.jsonify({
'error': USER_INVALID,
'error_msg': USER_INVALID_MSG,
}, 401)
client_conf = ''
link_svr_id = None
for link_doc in svr.links:
if link_doc['user_id'] == user.id:
link_svr_id = link_doc['server_id']
break
if link_svr_id:
link_svr = server.get_by_id(link_svr_id,
fields=['_id', 'network', 'local_networks'])
client_conf += 'iroute %s %s\n' % utils.parse_network(
link_svr.network)
for local_network in link_svr.local_networks:
push += 'iroute %s %s\n' % utils.parse_network(
local_network)
remote_ip_addr = svr.get_ip_addr(org.id, user_id)
if remote_ip_addr:
client_conf += 'ifconfig-push %s %s\n' % utils.parse_network(
remote_ip_addr)
return utils.jsonify({
'client_conf': client_conf,
})
def server_delete(server_id):
if settings.app.demo_mode:
return utils.demo_blocked()
svr = server.get_by_id(server_id,
fields=('_id', 'name', 'organizations', 'links'))
try:
link_ids = svr.remove()
except ServerLinkOnlineError:
return utils.jsonify(
{
'error': SERVER_NOT_OFFLINE,
'error_msg': SERVER_NOT_OFFLINE_UNLINK_SERVER_MSG,
}, 400)
logger.LogEntry(message='Deleted server "%s".' % svr.name)
event.Event(type=SERVERS_UPDATED)
event.Event(type=SERVER_LINKS_UPDATED, resource_id=server_id)
for link_id in link_ids:
event.Event(type=SERVER_LINKS_UPDATED, resource_id=link_id)
for org in svr.iter_orgs():
event.Event(type=USERS_UPDATED, resource_id=org.id)
return utils.jsonify({})
def server_operation_put(server_id, operation):
if settings.app.demo_mode:
return utils.demo_blocked()
svr = server.get_by_id(server_id, fields=server.operation_fields)
try:
if operation == START:
svr.start()
logger.LogEntry(message='Started server "%s".' % svr.name)
if operation == STOP:
svr.stop()
logger.LogEntry(message='Stopped server "%s".' % svr.name)
elif operation == RESTART:
svr.restart()
logger.LogEntry(message='Restarted server "%s".' % svr.name)
except:
event.Event(type=SERVERS_UPDATED)
raise
event.Event(type=SERVERS_UPDATED)
event.Event(type=SERVER_HOSTS_UPDATED, resource_id=svr.id)
for org in svr.iter_orgs():
event.Event(type=USERS_UPDATED, resource_id=org.id)
svr.send_link_events()
return utils.jsonify(svr.dict())
def server_host_put(server_id, host_id):
if settings.app.demo_mode:
return utils.demo_blocked()
svr = server.get_by_id(server_id, fields=('_id', 'hosts', 'links'))
hst = host.get_by_id(host_id, fields=('_id', 'name',
'public_address', 'auto_public_address'))
try:
svr.add_host(hst.id)
except ServerLinkCommonHostError:
return utils.jsonify({
'error': SERVER_LINK_COMMON_HOST,
'error_msg': SERVER_LINK_COMMON_HOST_MSG,
}, 400)
svr.commit('hosts')
event.Event(type=SERVER_HOSTS_UPDATED, resource_id=svr.id)
return utils.jsonify({
'id': hst.id,
'server': svr.id,
'status': OFFLINE,
'name': hst.name,
'address': hst.public_addr,
})
def server_host_get(server_id):
hosts = []
svr = server.get_by_id(server_id, fields=('_id', 'status',
'replica_count', 'hosts', 'instances'))
active_hosts = set([x['host_id'] for x in svr.instances])
hosts_offline = svr.replica_count - len(active_hosts) > 0
for hst in svr.iter_hosts(fields=('_id', 'name',
'public_address', 'auto_public_address',
'public_address6', 'auto_public_address6')):
if svr.status == ONLINE and hst.id in active_hosts:
status = ONLINE
elif svr.status == ONLINE and hosts_offline:
status = OFFLINE
else:
status = None
hosts.append({
'id': hst.id,
'server': svr.id,
'status': status,
'name': hst.name,
'address': hst.public_addr,
'address6': hst.public_addr6,
})
return utils.jsonify(hosts)
def server_operation_put(server_id, operation):
fields = server.dict_fields + ['hosts', 'links', 'replica_count',
'tls_auth_key', 'ca_certificate']
svr = server.get_by_id(server_id, fields=fields)
try:
if operation == START:
svr.start()
logger.LogEntry(message='Started server "%s".' % svr.name)
if operation == STOP:
svr.stop()
logger.LogEntry(message='Stopped server "%s".' % svr.name)
elif operation == RESTART:
svr.restart()
logger.LogEntry(message='Restarted server "%s".' % svr.name)
except:
event.Event(type=SERVERS_UPDATED)
raise
event.Event(type=SERVERS_UPDATED)
event.Event(type=SERVER_HOSTS_UPDATED, resource_id=svr.id)
svr.send_link_events()
return utils.jsonify(svr.dict())
def server_link_get(server_id):
links = []
svr = server.get_by_id(server_id, fields=['_id', 'status', 'links',
'replica_count', 'instances'])
hosts_offline = svr.replica_count - len(svr.instances) > 0
if svr.links:
spec = {
'_id': {'$in': [x['server_id'] for x in svr.links]},
}
for link_svr in server.iter_servers(spec=spec, fields=[
'_id', 'status', 'name', 'replica_count', 'instances']):
link_hosts_offline = link_svr.replica_count - len(
link_svr.instances) > 0
if svr.status == ONLINE:
if hosts_offline or link_hosts_offline:
status = OFFLINE
elif link_svr.status == ONLINE:
status = ONLINE
else:
status = OFFLINE
else:
status = None
links.append({
'id': link_svr.id,
'server': svr.id,
'status': status,
'name': link_svr.name,
'address': None,
})
return utils.jsonify(links)
def server_org_delete(server_id, org_id):
if settings.app.demo_mode:
return utils.demo_blocked()
svr = server.get_by_id(server_id,
fields=('_id', 'status', 'network', 'network_start',
'network_end', 'primary_organization',
'primary_user', 'organizations', 'routes', 'ipv6'))
org = organization.get_by_id(org_id, fields=('_id'))
if svr.status == ONLINE:
return utils.jsonify({
'error': SERVER_NOT_OFFLINE,
'error_msg': SERVER_NOT_OFFLINE_DETACH_ORG_MSG,
}, 400)
svr.remove_org(org)
svr.commit(svr.changed)
event.Event(type=SERVERS_UPDATED)
event.Event(type=SERVER_ROUTES_UPDATED, resource_id=svr.id)
event.Event(type=SERVER_ORGS_UPDATED, resource_id=svr.id)
event.Event(type=USERS_UPDATED, resource_id=org.id)
return utils.jsonify({})
def server_route_delete(server_id, route_network):
if settings.app.demo_mode:
return utils.demo_blocked()
svr = server.get_by_id(server_id)
route_network = route_network.decode('hex')
try:
route = svr.remove_route(route_network)
except ServerOnlineError:
return utils.jsonify({
'error': SERVER_ROUTE_ONLINE,
'error_msg': SERVER_ROUTE_ONLINE_MSG,
}, 400)
err, err_msg = svr.validate_conf()
if err:
return utils.jsonify({
'error': err,
'error_msg': err_msg,
}, 400)
svr.commit('routes')
event.Event(type=SERVER_ROUTES_UPDATED, resource_id=svr.id)
for svr_link in svr.links:
event.Event(type=SERVER_ROUTES_UPDATED,
resource_id=svr_link['server_id'])
return utils.jsonify(route)
def server_operation_put(server_id, operation):
if settings.app.demo_mode:
return utils.demo_blocked()
svr = server.get_by_id(server_id, fields=server.operation_fields)
try:
if operation == START:
svr.start()
logger.LogEntry(message='Started server "%s".' % svr.name)
if operation == STOP:
svr.stop()
logger.LogEntry(message='Stopped server "%s".' % svr.name)
elif operation == RESTART:
svr.restart()
logger.LogEntry(message='Restarted server "%s".' % svr.name)
except:
event.Event(type=SERVERS_UPDATED)
raise
event.Event(type=SERVERS_UPDATED)
event.Event(type=SERVER_HOSTS_UPDATED, resource_id=svr.id)
for org in svr.iter_orgs():
event.Event(type=USERS_UPDATED, resource_id=org.id)
svr.send_link_events()
return utils.jsonify(svr.dict())
def server_link_get(server_id):
links = []
svr = server.get_by_id(server_id, fields=['_id', 'status', 'links',
'replica_count', 'instances'])
hosts_offline = svr.replica_count - len(svr.instances) > 0
if svr.links:
spec = {
'_id': {'$in': [x['server_id'] for x in svr.links]},
}
for link_svr in server.iter_servers(spec=spec, fields=[
'_id', 'status', 'name', 'replica_count', 'instances']):
link_hosts_offline = link_svr.replica_count - len(
link_svr.instances) > 0
if svr.status == ONLINE:
if hosts_offline or link_hosts_offline:
status = OFFLINE
elif link_svr.status == ONLINE:
status = ONLINE
else:
status = OFFLINE
else:
status = None
links.append({
'id': link_svr.id,
'server': svr.id,
'status': status,
'name': link_svr.name,
'address': None,
})
return utils.jsonify(links)
def server_route_delete(server_id, route_network):
if settings.app.demo_mode:
return utils.demo_blocked()
svr = server.get_by_id(server_id, fields=('_id', 'network', 'links',
'network_start', 'network_end', 'routes', 'organizations', 'status',
'ipv6'))
route_network = route_network.decode('hex')
try:
route = svr.remove_route(route_network)
except ServerOnlineError:
return utils.jsonify({
'error': SERVER_ROUTE_ONLINE,
'error_msg': SERVER_ROUTE_ONLINE_MSG,
}, 400)
svr.commit('routes')
event.Event(type=SERVER_ROUTES_UPDATED, resource_id=svr.id)
for svr_link in svr.links:
event.Event(type=SERVER_ROUTES_UPDATED,
resource_id=svr_link['server_id'])
return utils.jsonify(route)
def server_route_delete(server_id, route_network):
if settings.app.demo_mode:
return utils.demo_blocked()
svr = server.get_by_id(server_id,
fields=('_id', 'network', 'links', 'network_start',
'network_end', 'routes', 'organizations',
'status'))
route_network = route_network.decode('hex')
try:
route = svr.remove_route(route_network)
except ServerOnlineError:
return utils.jsonify(
{
'error': SERVER_ROUTE_ONLINE,
'error_msg': SERVER_ROUTE_ONLINE_MSG,
}, 400)
svr.commit('routes')
event.Event(type=SERVER_ROUTES_UPDATED, resource_id=svr.id)
for svr_link in svr.links:
event.Event(type=SERVER_ROUTES_UPDATED,
resource_id=svr_link['server_id'])
return utils.jsonify(route)
def server_host_get(server_id):
if settings.app.demo_mode:
resp = utils.demo_get_cache()
if resp:
return utils.jsonify(resp)
hosts = []
svr = server.get_by_id(server_id, fields=('_id', 'status',
'replica_count', 'hosts', 'instances'))
active_hosts = set([x['host_id'] for x in svr.instances])
hosts_offline = svr.replica_count - len(active_hosts) > 0
for hst in svr.iter_hosts(fields=('_id', 'name',
'public_address', 'auto_public_address',
'public_address6', 'auto_public_address6')):
if svr.status == ONLINE and hst.id in active_hosts:
status = ONLINE
elif svr.status == ONLINE and hosts_offline:
status = OFFLINE
else:
status = None
hosts.append({
'id': hst.id,
'server': svr.id,
'status': status,
'name': hst.name,
'address': hst.public_addr,
'address6': hst.public_addr6,
})
if settings.app.demo_mode:
utils.demo_set_cache(hosts)
return utils.jsonify(hosts)
def server_org_put(server_id, org_id):
if settings.app.demo_mode:
return utils.demo_blocked()
svr = server.get_by_id(server_id,
fields=('_id', 'wg', 'status', 'network',
'network_wg', 'network_start',
'network_end', 'organizations', 'routes',
'ipv6'))
org = organization.get_by_id(org_id, fields=('_id', 'name'))
if svr.status == ONLINE:
return utils.jsonify(
{
'error': SERVER_NOT_OFFLINE,
'error_msg': SERVER_NOT_OFFLINE_ATTACH_ORG_MSG,
}, 400)
svr.add_org(org)
svr.commit(svr.changed)
event.Event(type=SERVERS_UPDATED)
event.Event(type=SERVER_ROUTES_UPDATED, resource_id=svr.id)
event.Event(type=SERVER_ORGS_UPDATED, resource_id=svr.id)
event.Event(type=USERS_UPDATED, resource_id=org.id)
return utils.jsonify({
'id': org.id,
'server': svr.id,
'name': org.name,
})
def server_route_delete(server_id, route_network):
if settings.app.demo_mode:
return utils.demo_blocked()
svr = server.get_by_id(server_id)
route_network = route_network.decode('hex')
try:
route = svr.remove_route(route_network)
except ServerOnlineError:
return utils.jsonify(
{
'error': SERVER_ROUTE_ONLINE,
'error_msg': SERVER_ROUTE_ONLINE_MSG,
}, 400)
err, err_msg = svr.validate_conf()
if err:
return utils.jsonify({
'error': err,
'error_msg': err_msg,
}, 400)
svr.commit('routes')
event.Event(type=SERVER_ROUTES_UPDATED, resource_id=svr.id)
for svr_link in svr.links:
event.Event(type=SERVER_ROUTES_UPDATED,
resource_id=svr_link['server_id'])
return utils.jsonify(route)
def server_client_disconnect_post(server_id):
org_id = bson.ObjectId(flask.request.json['org_id'])
user_id = bson.ObjectId(flask.request.json['user_id'])
svr = server.get_by_id(server_id, fields=['_id', 'organizations'])
if not svr:
return utils.jsonify({
'error': SERVER_INVALID,
'error_msg': SERVER_INVALID_MSG,
}, 401)
org = svr.get_org(org_id, fields=['_id'])
if not org:
return utils.jsonify({
'error': ORG_INVALID,
'error_msg': ORG_INVALID_MSG,
}, 401)
user = org.get_user(user_id, fields=['_id'])
if not user:
return utils.jsonify({
'error': USER_INVALID,
'error_msg': USER_INVALID_MSG,
}, 401)
return utils.jsonify({})
def server_client_disconnect_post(server_id):
org_id = bson.ObjectId(flask.request.json['org_id'])
user_id = bson.ObjectId(flask.request.json['user_id'])
svr = server.get_by_id(server_id, fields=['_id', 'organizations'])
if not svr:
return utils.jsonify({
'error': SERVER_INVALID,
'error_msg': SERVER_INVALID_MSG,
}, 401)
org = svr.get_org(org_id, fields=['_id'])
if not org:
return utils.jsonify({
'error': ORG_INVALID,
'error_msg': ORG_INVALID_MSG,
}, 401)
user = org.get_user(user_id, fields=['_id'])
if not user:
return utils.jsonify({
'error': USER_INVALID,
'error_msg': USER_INVALID_MSG,
}, 401)
return utils.jsonify({})
def server_host_put(server_id, host_id):
if settings.app.demo_mode:
return utils.demo_blocked()
svr = server.get_by_id(server_id, fields=('_id', 'hosts', 'links'))
hst = host.get_by_id(host_id, fields=('_id', 'name',
'public_address', 'auto_public_address'))
try:
svr.add_host(hst.id)
except ServerLinkCommonHostError:
return utils.jsonify({
'error': SERVER_LINK_COMMON_HOST,
'error_msg': SERVER_LINK_COMMON_HOST_MSG,
}, 400)
svr.commit('hosts')
event.Event(type=SERVER_HOSTS_UPDATED, resource_id=svr.id)
return utils.jsonify({
'id': hst.id,
'server': svr.id,
'status': OFFLINE,
'name': hst.name,
'address': hst.public_addr,
})
def server_operation_put(server_id, operation):
fields = server.dict_fields + [
'hosts', 'links', 'replica_count', 'tls_auth_key', 'ca_certificate'
]
svr = server.get_by_id(server_id, fields=fields)
try:
if operation == START:
svr.start()
logger.LogEntry(message='Started server "%s".' % svr.name)
if operation == STOP:
svr.stop()
logger.LogEntry(message='Stopped server "%s".' % svr.name)
elif operation == RESTART:
svr.restart()
logger.LogEntry(message='Restarted server "%s".' % svr.name)
except:
event.Event(type=SERVERS_UPDATED)
raise
event.Event(type=SERVERS_UPDATED)
event.Event(type=SERVER_HOSTS_UPDATED, resource_id=svr.id)
svr.send_link_events()
return utils.jsonify(svr.dict())
def server_host_get(server_id):
hosts = []
svr = server.get_by_id(server_id, fields=['_id', 'status',
'replica_count', 'hosts', 'instances'])
active_hosts = set([x['host_id'] for x in svr.instances])
hosts_offline = svr.replica_count - len(active_hosts) > 0
for hst in svr.iter_hosts(fields=['_id', 'name',
'public_address', 'auto_public_address']):
if svr.status == ONLINE and hst.id in active_hosts:
status = ONLINE
elif svr.status == ONLINE and hosts_offline:
status = OFFLINE
else:
status = None
hosts.append({
'id': hst.id,
'server': svr.id,
'status': status,
'name': hst.name,
'address': hst.public_addr,
})
return utils.jsonify(hosts)
def server_org_delete(server_id, org_id):
if settings.app.demo_mode:
return utils.demo_blocked()
svr = server.get_by_id(server_id,
fields=('_id', 'status', 'network', 'network_start',
'network_end', 'primary_organization',
'primary_user', 'organizations', 'routes',
'ipv6'))
org = organization.get_by_id(org_id, fields=('_id'))
if svr.status == ONLINE:
return utils.jsonify(
{
'error': SERVER_NOT_OFFLINE,
'error_msg': SERVER_NOT_OFFLINE_DETACH_ORG_MSG,
}, 400)
svr.remove_org(org)
svr.commit(svr.changed)
event.Event(type=SERVERS_UPDATED)
event.Event(type=SERVER_ORGS_UPDATED, resource_id=svr.id)
event.Event(type=USERS_UPDATED, resource_id=org.id)
return utils.jsonify({})
def server_delete(server_id):
svr = server.get_by_id(server_id, fields=('_id', 'name', 'organizations'))
svr.remove()
logger.LogEntry(message='Deleted server "%s".' % svr.name)
event.Event(type=SERVERS_UPDATED)
for org in svr.iter_orgs():
event.Event(type=USERS_UPDATED, resource_id=org.id)
return utils.jsonify({})
def server_delete(server_id):
svr = server.get_by_id(server_id, fields=['_id', 'name', 'organizations'])
svr.remove()
logger.LogEntry(message='Deleted server "%s".' % svr.name)
event.Event(type=SERVERS_UPDATED)
for org in svr.iter_orgs():
event.Event(type=USERS_UPDATED, resource_id=org.id)
return utils.jsonify({})
def server_route_put(server_id, route_network):
if settings.app.demo_mode:
return utils.demo_blocked()
svr = server.get_by_id(server_id)
route_network = route_network.decode('hex')
comment = flask.request.json.get('comment') or None
nat_route = True if flask.request.json.get('nat') else False
nat_interface = flask.request.json.get('nat_interface') or None
vpc_region = utils.filter_str(flask.request.json.get('vpc_region')) or None
vpc_id = utils.filter_str(flask.request.json.get('vpc_id')) or None
net_gateway = True if flask.request.json.get('net_gateway') else False
try:
route = svr.upsert_route(route_network, nat_route, nat_interface,
vpc_region, vpc_id, net_gateway, comment)
except ServerOnlineError:
return utils.jsonify({
'error': SERVER_ROUTE_ONLINE,
'error_msg': SERVER_ROUTE_ONLINE_MSG,
}, 400)
except NetworkInvalid:
return utils.jsonify({
'error': SERVER_ROUTE_INVALID,
'error_msg': SERVER_ROUTE_INVALID_MSG,
}, 400)
except ServerRouteNatVirtual:
return utils.jsonify({
'error': SERVER_ROUTE_VIRTUAL_NAT,
'error_msg': SERVER_ROUTE_VIRTUAL_NAT_MSG,
}, 400)
except ServerRouteNatServerLink:
return utils.jsonify({
'error': SERVER_ROUTE_SERVER_LINK_NAT,
'error_msg': SERVER_ROUTE_SERVER_LINK_NAT_MSG,
}, 400)
except ServerRouteNatNetworkLink:
return utils.jsonify({
'error': SERVER_ROUTE_NETWORK_LINK_NAT,
'error_msg': SERVER_ROUTE_NETWORK_LINK_NAT_MSG,
}, 400)
err, err_msg = svr.validate_conf()
if err:
return utils.jsonify({
'error': err,
'error_msg': err_msg,
}, 400)
svr.commit('routes')
event.Event(type=SERVER_ROUTES_UPDATED, resource_id=svr.id)
for svr_link in svr.links:
event.Event(type=SERVER_ROUTES_UPDATED,
resource_id=svr_link['server_id'])
return utils.jsonify(route)
def server_route_put(server_id, route_network):
if settings.app.demo_mode:
return utils.demo_blocked()
svr = server.get_by_id(server_id)
route_network = route_network.decode('hex')
comment = flask.request.json.get('comment') or None
nat_route = True if flask.request.json.get('nat') else False
nat_interface = flask.request.json.get('nat_interface') or None
vpc_region = utils.filter_str(flask.request.json.get('vpc_region')) or None
vpc_id = utils.filter_str(flask.request.json.get('vpc_id')) or None
net_gateway = True if flask.request.json.get('net_gateway') else False
try:
route = svr.upsert_route(route_network, nat_route, nat_interface,
vpc_region, vpc_id, net_gateway, comment)
except ServerOnlineError:
return utils.jsonify({
'error': SERVER_ROUTE_ONLINE,
'error_msg': SERVER_ROUTE_ONLINE_MSG,
}, 400)
except NetworkInvalid:
return utils.jsonify({
'error': SERVER_ROUTE_INVALID,
'error_msg': SERVER_ROUTE_INVALID_MSG,
}, 400)
except ServerRouteNatVirtual:
return utils.jsonify({
'error': SERVER_ROUTE_VIRTUAL_NAT,
'error_msg': SERVER_ROUTE_VIRTUAL_NAT_MSG,
}, 400)
except ServerRouteNatServerLink:
return utils.jsonify({
'error': SERVER_ROUTE_SERVER_LINK_NAT,
'error_msg': SERVER_ROUTE_SERVER_LINK_NAT_MSG,
}, 400)
except ServerRouteNatNetworkLink:
return utils.jsonify({
'error': SERVER_ROUTE_NETWORK_LINK_NAT,
'error_msg': SERVER_ROUTE_NETWORK_LINK_NAT_MSG,
}, 400)
err, err_msg = svr.validate_conf()
if err:
return utils.jsonify({
'error': err,
'error_msg': err_msg,
}, 400)
svr.commit('routes')
event.Event(type=SERVER_ROUTES_UPDATED, resource_id=svr.id)
for svr_link in svr.links:
event.Event(type=SERVER_ROUTES_UPDATED,
resource_id=svr_link['server_id'])
return utils.jsonify(route)
def server_org_get(server_id):
orgs = []
svr = server.get_by_id(server_id, fields=['_id', 'organizations'])
for org_doc in svr.get_org_fields(fields=['_id', 'name']):
org_doc['id'] = org_doc.pop('_id')
org_doc['server'] = svr.id
orgs.append(org_doc)
return utils.jsonify(orgs)
def server_org_get(server_id):
orgs = []
svr = server.get_by_id(server_id, fields=('_id', 'organizations'))
for org_doc in svr.get_org_fields(fields=('_id', 'name')):
org_doc['id'] = org_doc.pop('_id')
org_doc['server'] = svr.id
orgs.append(org_doc)
return utils.jsonify(orgs)
def server_route_post(server_id):
if settings.app.demo_mode:
return utils.demo_blocked()
svr = server.get_by_id(server_id,
fields=('_id', 'network', 'links', 'network_start',
'network_end', 'routes', 'organizations',
'status', 'ipv6'))
route_network = flask.request.json['network']
nat_route = True if flask.request.json.get('nat') else False
nat_interface = flask.request.json.get('nat_interface') or None
vpc_region = utils.filter_str(flask.request.json.get('vpc_region')) or None
vpc_id = utils.filter_str(flask.request.json.get('vpc_id')) or None
try:
route = svr.upsert_route(route_network, nat_route, nat_interface,
vpc_region, vpc_id)
except ServerOnlineError:
return utils.jsonify(
{
'error': SERVER_ROUTE_ONLINE,
'error_msg': SERVER_ROUTE_ONLINE_MSG,
}, 400)
except NetworkInvalid:
return utils.jsonify(
{
'error': SERVER_ROUTE_INVALID,
'error_msg': SERVER_ROUTE_INVALID_MSG,
}, 400)
except ServerRouteNatVirtual:
return utils.jsonify(
{
'error': SERVER_ROUTE_VIRTUAL_NAT,
'error_msg': SERVER_ROUTE_VIRTUAL_NAT_MSG,
}, 400)
except ServerRouteNatServerLink:
return utils.jsonify(
{
'error': SERVER_ROUTE_SERVER_LINK_NAT,
'error_msg': SERVER_ROUTE_SERVER_LINK_NAT_MSG,
}, 400)
except ServerRouteNatNetworkLink:
return utils.jsonify(
{
'error': SERVER_ROUTE_NETWORK_LINK_NAT,
'error_msg': SERVER_ROUTE_NETWORK_LINK_NAT_MSG,
}, 400)
svr.commit('routes')
event.Event(type=SERVER_ROUTES_UPDATED, resource_id=svr.id)
for svr_link in svr.links:
event.Event(type=SERVER_ROUTES_UPDATED,
resource_id=svr_link['server_id'])
return utils.jsonify(route)
def server_link_get(server_id):
if settings.app.demo_mode:
resp = utils.demo_get_cache()
if resp:
return utils.jsonify(resp)
links = []
svr = server.get_by_id(server_id,
fields=('_id', 'status', 'links', 'replica_count',
'instances'))
if not svr:
return flask.abort(404)
hosts_offline = svr.replica_count - len(svr.instances) > 0
if svr.links:
link_use_local = {}
link_server_ids = []
for link in svr.links:
link_server_id = link['server_id']
link_use_local[link_server_id] = link['use_local_address']
link_server_ids.append(link_server_id)
spec = {
'_id': {
'$in': link_server_ids
},
}
for link_svr in server.iter_servers(spec=spec,
fields=('_id', 'status', 'name',
'replica_count',
'instances')):
link_hosts_offline = link_svr.replica_count - len(
link_svr.instances) > 0
if svr.status == ONLINE:
if hosts_offline or link_hosts_offline:
status = OFFLINE
elif link_svr.status == ONLINE:
status = ONLINE
else:
status = OFFLINE
else:
status = None
links.append({
'id': link_svr.id,
'server': svr.id,
'status': status,
'name': link_svr.name,
'address': None,
'use_local_address': link_use_local[link_svr.id],
})
if settings.app.demo_mode:
utils.demo_set_cache(links)
return utils.jsonify(links)
def server_host_delete(server_id, host_id):
svr = server.get_by_id(server_id, fields=['_id', 'hosts'])
hst = host.get_by_id(host_id, fields=['_id', 'name'])
svr.remove_host(hst.id)
svr.commit('hosts')
event.Event(type=SERVERS_UPDATED)
event.Event(type=SERVER_HOSTS_UPDATED, resource_id=svr.id)
return utils.jsonify({})
def server_host_delete(server_id, host_id):
svr = server.get_by_id(server_id, fields=('_id', 'hosts', 'replica_count'))
hst = host.get_by_id(host_id, fields=('_id', 'name'))
svr.remove_host(hst.id)
svr.commit('hosts')
event.Event(type=SERVERS_UPDATED)
event.Event(type=SERVER_HOSTS_UPDATED, resource_id=svr.id)
return utils.jsonify({})
def task(self):
try:
timestamp_spec = utils.now() - datetime.timedelta(
seconds=settings.vpn.route_ping_ttl)
docs = self.routes_collection.find({
'timestamp': {
'$lt': timestamp_spec
},
})
yield
for doc in docs:
server_id = doc['server_id']
vpc_region = doc['vpc_region']
vpc_id = doc['vpc_id']
network = doc['network']
svr = server.get_by_id(server_id)
if not svr:
self.routes_collection.remove({
'_id': doc['_id'],
})
continue
match = False
for route in svr.get_routes(include_server_links=True):
route_advertise = route['advertise'] or \
(route['vpc_region'] and route['vpc_id'])
route_network = route['network']
netmap = route.get('nat_netmap')
if netmap:
route_network = netmap
if route_advertise and network == route_network:
match = True
if not match:
self.routes_collection.remove({
'_id': doc['_id'],
})
continue
messenger.publish('instance', [
'route_advertisement', server_id, vpc_region, vpc_id,
network
])
except GeneratorExit:
raise
except:
logger.exception('Error checking route states', 'tasks')
def server_route_get(server_id):
if settings.app.demo_mode:
resp = utils.demo_get_cache()
if resp:
return utils.jsonify(resp)
svr = server.get_by_id(server_id, fields=('_id', 'network', 'links',
'network_start', 'network_end', 'routes', 'organizations', 'ipv6'))
resp = svr.get_routes(include_server_links=True)
if settings.app.demo_mode:
utils.demo_set_cache(resp)
return utils.jsonify(resp)
def server_route_get(server_id):
if settings.app.demo_mode:
resp = utils.demo_get_cache()
if resp:
return utils.jsonify(resp)
svr = server.get_by_id(server_id, fields=('_id', 'network', 'links',
'network_start', 'network_end', 'routes', 'organizations', 'ipv6'))
resp = svr.get_routes(include_server_links=True)
if settings.app.demo_mode:
utils.demo_set_cache(resp)
return utils.jsonify(resp)
def server_route_post(server_id):
if settings.app.demo_mode:
return utils.demo_blocked()
svr = server.get_by_id(server_id, fields=('_id', 'network', 'links',
'network_start', 'network_end', 'routes', 'organizations', 'status',
'ipv6'))
route_network = flask.request.json['network']
nat_route = True if flask.request.json.get('nat') else False
nat_interface = flask.request.json.get('nat_interface') or None
vpc_region = utils.filter_str(flask.request.json.get('vpc_region')) or None
vpc_id = utils.filter_str(flask.request.json.get('vpc_id')) or None
try:
route = svr.upsert_route(route_network, nat_route, nat_interface,
vpc_region, vpc_id)
except ServerOnlineError:
return utils.jsonify({
'error': SERVER_ROUTE_ONLINE,
'error_msg': SERVER_ROUTE_ONLINE_MSG,
}, 400)
except NetworkInvalid:
return utils.jsonify({
'error': SERVER_ROUTE_INVALID,
'error_msg': SERVER_ROUTE_INVALID_MSG,
}, 400)
except ServerRouteNatVirtual:
return utils.jsonify({
'error': SERVER_ROUTE_VIRTUAL_NAT,
'error_msg': SERVER_ROUTE_VIRTUAL_NAT_MSG,
}, 400)
except ServerRouteNatServerLink:
return utils.jsonify({
'error': SERVER_ROUTE_SERVER_LINK_NAT,
'error_msg': SERVER_ROUTE_SERVER_LINK_NAT_MSG,
}, 400)
except ServerRouteNatNetworkLink:
return utils.jsonify({
'error': SERVER_ROUTE_NETWORK_LINK_NAT,
'error_msg': SERVER_ROUTE_NETWORK_LINK_NAT_MSG,
}, 400)
svr.commit('routes')
event.Event(type=SERVER_ROUTES_UPDATED, resource_id=svr.id)
for svr_link in svr.links:
event.Event(type=SERVER_ROUTES_UPDATED,
resource_id=svr_link['server_id'])
return utils.jsonify(route)
def server_host_delete(server_id, host_id):
if settings.app.demo_mode:
return utils.demo_blocked()
svr = server.get_by_id(server_id, fields=('_id', 'hosts', 'replica_count'))
hst = host.get_by_id(host_id, fields=('_id', 'name'))
svr.remove_host(hst.id)
svr.commit('hosts')
event.Event(type=SERVERS_UPDATED)
event.Event(type=SERVER_HOSTS_UPDATED, resource_id=svr.id)
return utils.jsonify({})
def server_host_put(server_id, host_id):
svr = server.get_by_id(server_id, fields=['_id', 'hosts'])
hst = host.get_by_id(host_id, fields=['_id', 'name', 'public_address'])
svr.add_host(hst.id)
svr.commit('hosts')
event.Event(type=SERVER_HOSTS_UPDATED, resource_id=svr.id)
return utils.jsonify({
'id': hst.id,
'server': svr.id,
'status': OFFLINE,
'name': hst.name,
'address': hst.public_addr,
})
def server_link_get(server_id):
if settings.app.demo_mode:
resp = utils.demo_get_cache()
if resp:
return utils.jsonify(resp)
links = []
svr = server.get_by_id(server_id, fields=('_id', 'status', 'links',
'replica_count', 'instances'))
if not svr:
return flask.abort(404)
hosts_offline = svr.replica_count - len(svr.instances) > 0
if svr.links:
link_use_local = {}
link_server_ids = []
for link in svr.links:
link_server_id = link['server_id']
link_use_local[link_server_id] = link['use_local_address']
link_server_ids.append(link_server_id)
spec = {
'_id': {'$in': link_server_ids},
}
for link_svr in server.iter_servers(spec=spec, fields=(
'_id', 'status', 'name', 'replica_count', 'instances')):
link_hosts_offline = link_svr.replica_count - len(
link_svr.instances) > 0
if svr.status == ONLINE:
if hosts_offline or link_hosts_offline:
status = OFFLINE
elif link_svr.status == ONLINE:
status = ONLINE
else:
status = OFFLINE
else:
status = None
links.append({
'id': link_svr.id,
'server': svr.id,
'status': status,
'name': link_svr.name,
'address': None,
'use_local_address': link_use_local[link_svr.id],
})
if settings.app.demo_mode:
utils.demo_set_cache(links)
return utils.jsonify(links)
def server_host_put(server_id, host_id):
svr = server.get_by_id(server_id, fields=['_id', 'hosts'])
hst = host.get_by_id(host_id, fields=['_id', 'name', 'public_address'])
svr.add_host(hst.id)
svr.commit('hosts')
event.Event(type=SERVER_HOSTS_UPDATED, resource_id=svr.id)
return utils.jsonify({
'id': hst.id,
'server': svr.id,
'status': OFFLINE,
'name': hst.name,
'address': hst.public_addr,
})
def task(self):
try:
timestamp_spec = utils.now() - datetime.timedelta(
seconds=settings.vpn.route_ping_ttl)
docs = self.routes_collection.find({
'timestamp': {'$lt': timestamp_spec},
})
yield
for doc in docs:
server_id = doc['server_id']
vpc_region = doc['vpc_region']
vpc_id = doc['vpc_id']
network = doc['network']
svr = server.get_by_id(server_id)
if not svr:
self.routes_collection.remove({
'_id': doc['_id'],
})
continue
match = False
for route in svr.get_routes(include_server_links=True):
route_advertise = route['advertise'] or \
(route['vpc_region'] and route['vpc_id'])
route_network = route['network']
netmap = route.get('nat_netmap')
if netmap:
route_network = netmap
if route_advertise and network == route_network:
match = True
if not match:
self.routes_collection.remove({
'_id': doc['_id'],
})
continue
messenger.publish('instance', ['route_advertisement',
server_id, vpc_region, vpc_id, network])
except GeneratorExit:
raise
except:
logger.exception('Error checking route states', 'tasks')
def server_org_get(server_id):
if settings.app.demo_mode:
resp = utils.demo_get_cache()
if resp:
return utils.jsonify(resp)
orgs = []
svr = server.get_by_id(server_id, fields=('_id', 'organizations'))
for org_doc in svr.get_org_fields(fields=('_id', 'name')):
org_doc['id'] = org_doc.pop('_id')
org_doc['server'] = svr.id
orgs.append(org_doc)
if settings.app.demo_mode:
utils.demo_set_cache(orgs)
return utils.jsonify(orgs)
def server_org_get(server_id):
if settings.app.demo_mode:
resp = utils.demo_get_cache()
if resp:
return utils.jsonify(resp)
orgs = []
svr = server.get_by_id(server_id, fields=('_id', 'organizations'))
for org_doc in svr.get_org_fields(fields=('_id', 'name')):
org_doc['id'] = org_doc.pop('_id')
org_doc['server'] = svr.id
orgs.append(org_doc)
if settings.app.demo_mode:
utils.demo_set_cache(orgs)
return utils.jsonify(orgs)
def server_otp_verify_post(server_id):
org_id = bson.ObjectId(flask.request.json['org_id'])
user_id = bson.ObjectId(flask.request.json['user_id'])
otp_code = flask.request.json['otp_code']
remote_ip = flask.request.json.get('remote_ip')
svr = server.get_by_id(server_id,
fields=['_id', 'name', 'organizations'])
if not svr:
return utils.jsonify({
'error': SERVER_INVALID,
'error_msg': SERVER_INVALID_MSG,
}, 401)
org = svr.get_org(org_id, fields=['_id'])
if not org:
logger.LogEntry(message='User failed authentication, ' +
'invalid organization on server "%s".' % svr.name)
return utils.jsonify({
'error': ORG_INVALID,
'error_msg': ORG_INVALID_MSG,
}, 401)
user = org.get_user(user_id, fields=['_id', 'name', 'type' ,'otp_secret'])
if not user:
logger.LogEntry(message='User failed authentication, ' +
'invalid user on server "%s".' % svr.name)
return utils.jsonify({
'error': USER_INVALID,
'error_msg': USER_INVALID_MSG,
}, 401)
if user.type == CERT_CLIENT and \
not user.verify_otp_code(otp_code, remote_ip):
logger.LogEntry(message='User failed two-step authentication "%s".' % (
user.name))
return utils.jsonify({
'error': OTP_CODE_INVALID,
'error_msg': OTP_CODE_INVALID_MSG,
}, 401)
return utils.jsonify({
'authenticated': True,
})
def server_otp_verify_post(server_id):
org_id = bson.ObjectId(flask.request.json['org_id'])
user_id = bson.ObjectId(flask.request.json['user_id'])
otp_code = flask.request.json['otp_code']
remote_ip = flask.request.json.get('remote_ip')
svr = server.get_by_id(server_id,
fields=['_id', 'name', 'organizations'])
if not svr:
return utils.jsonify({
'error': SERVER_INVALID,
'error_msg': SERVER_INVALID_MSG,
}, 401)
org = svr.get_org(org_id, fields=['_id'])
if not org:
logger.LogEntry(message='User failed authentication, ' +
'invalid organization on server "%s".' % svr.name)
return utils.jsonify({
'error': ORG_INVALID,
'error_msg': ORG_INVALID_MSG,
}, 401)
user = org.get_user(user_id, fields=['_id', 'name', 'type' ,'otp_secret'])
if not user:
logger.LogEntry(message='User failed authentication, ' +
'invalid user on server "%s".' % svr.name)
return utils.jsonify({
'error': USER_INVALID,
'error_msg': USER_INVALID_MSG,
}, 401)
if user.type == CERT_CLIENT and \
not user.verify_otp_code(otp_code, remote_ip):
logger.LogEntry(message='User failed two-step authentication "%s".' % (
user.name))
return utils.jsonify({
'error': OTP_CODE_INVALID,
'error_msg': OTP_CODE_INVALID_MSG,
}, 401)
return utils.jsonify({
'authenticated': True,
})
def server_org_put(server_id, org_id):
svr = server.get_by_id(server_id,
fields=['_id', 'status', 'network', 'organizations'])
org = organization.get_by_id(org_id, fields=['_id', 'name'])
if svr.status == ONLINE:
return utils.jsonify({
'error': SERVER_NOT_OFFLINE,
'error_msg': SERVER_NOT_OFFLINE_ATTACH_ORG_MSG,
}, 400)
svr.add_org(org)
svr.commit(svr.changed)
event.Event(type=SERVERS_UPDATED)
event.Event(type=SERVER_ORGS_UPDATED, resource_id=svr.id)
event.Event(type=USERS_UPDATED, resource_id=org.id)
return utils.jsonify({
'id': org.id,
'server': svr.id,
'name': org.name,
})
def server_host_delete(server_id, host_id):
if settings.app.demo_mode:
return utils.demo_blocked()
svr = server.get_by_id(server_id, fields=(
'_id', 'hosts', 'replica_count'))
if not svr:
return flask.abort(404)
hst = host.get_by_id(host_id, fields=('_id', 'name'))
if not hst:
return flask.abort(404)
svr.remove_host(hst.id)
svr.commit('hosts')
event.Event(type=SERVERS_UPDATED)
event.Event(type=SERVER_HOSTS_UPDATED, resource_id=svr.id)
return utils.jsonify({})
def server_org_put(server_id, org_id):
svr = server.get_by_id(server_id,
fields=('_id', 'status', 'network', 'organizations'))
org = organization.get_by_id(org_id, fields=('_id', 'name'))
if svr.status == ONLINE:
return utils.jsonify({
'error': SERVER_NOT_OFFLINE,
'error_msg': SERVER_NOT_OFFLINE_ATTACH_ORG_MSG,
}, 400)
svr.add_org(org)
svr.commit(svr.changed)
event.Event(type=SERVERS_UPDATED)
event.Event(type=SERVER_ORGS_UPDATED, resource_id=svr.id)
event.Event(type=USERS_UPDATED, resource_id=org.id)
return utils.jsonify({
'id': org.id,
'server': svr.id,
'name': org.name,
})
def task(self):
svr = server.get_by_id(self.server_id)
if not svr:
return
for _ in xrange(5):
if svr.network_lock:
time.sleep(2)
svr.load()
else:
break
if svr.network_lock:
raise ServerNetworkLocked('Server network is locked', {
'server_id': svr.id,
'queue_id': self.id,
'queue_type': self.type,
})
svr.ip_pool.assign_ip_addr(self.org_id, self.user_id)
def server_org_delete(server_id, org_id):
svr = server.get_by_id(server_id,
fields=['_id', 'status', 'network', 'primary_organization',
'primary_user', 'organizations'])
org = organization.get_by_id(org_id, fields=['_id'])
if svr.status == ONLINE:
return utils.jsonify({
'error': SERVER_NOT_OFFLINE,
'error_msg': SERVER_NOT_OFFLINE_DETACH_ORG_MSG,
}, 400)
svr.remove_org(org)
svr.commit(svr.changed)
event.Event(type=SERVERS_UPDATED)
event.Event(type=SERVER_ORGS_UPDATED, resource_id=svr.id)
event.Event(type=USERS_UPDATED, resource_id=org.id)
return utils.jsonify({})
def server_org_delete(server_id, org_id):
svr = server.get_by_id(server_id,
fields=['_id', 'status', 'network', 'primary_organization',
'primary_user', 'organizations'])
org = organization.get_by_id(org_id, fields=['_id'])
if svr.status == ONLINE:
return utils.jsonify({
'error': SERVER_NOT_OFFLINE,
'error_msg': SERVER_NOT_OFFLINE_DETACH_ORG_MSG,
}, 400)
svr.remove_org(org)
svr.commit(svr.changed)
event.Event(type=SERVERS_UPDATED)
event.Event(type=SERVER_ORGS_UPDATED, resource_id=svr.id)
event.Event(type=USERS_UPDATED, resource_id=org.id)
return utils.jsonify({})
def server_host_put(server_id, host_id):
if settings.app.demo_mode:
return utils.demo_blocked()
svr = server.get_by_id(server_id)
if not svr:
return flask.abort(404)
hst = host.get_by_id(host_id,
fields=('_id', 'name', 'public_address',
'auto_public_address', 'auto_public_host',
'public_address6', 'auto_public_address6',
'auto_public_host6'))
if not svr:
return flask.abort(404)
try:
svr.add_host(hst.id)
except ServerLinkCommonHostError:
return utils.jsonify(
{
'error': SERVER_LINK_COMMON_HOST,
'error_msg': SERVER_LINK_COMMON_HOST_MSG,
}, 400)
err, err_msg = svr.validate_conf(allow_online=True)
if err:
return utils.jsonify({
'error': err,
'error_msg': err_msg,
}, 400)
svr.commit('hosts')
event.Event(type=SERVER_HOSTS_UPDATED, resource_id=svr.id)
return utils.jsonify({
'id': hst.id,
'server': svr.id,
'status': OFFLINE,
'name': hst.name,
'address': hst.public_addr,
})
def _on_msg(msg):
if msg['message'] != 'start':
return
try:
svr = server.get_by_id(msg['server_id'])
if settings.local.host_id not in svr.hosts:
return
for instance in svr.instances:
if instance['host_id'] == settings.local.host_id:
return
prefered_hosts = msg.get('prefered_hosts')
if prefered_hosts and settings.local.host_id not in prefered_hosts:
time.sleep(0.1)
svr.run(send_events=msg.get('send_events'))
except:
logger.exception('Failed to run server', 'runners')
def _on_msg(msg):
if msg['message'] != 'start':
return
try:
svr = server.get_by_id(msg['server_id'])
if settings.local.host_id not in svr.hosts:
return
for instance in svr.instances:
if instance['host_id'] == settings.local.host_id:
return
prefered_hosts = msg.get('prefered_hosts')
if prefered_hosts and settings.local.host_id not in prefered_hosts:
time.sleep(0.1)
svr.run(send_events=msg.get('send_events'))
except:
logger.exception('Failed to run server', 'runners')
def server_tls_verify_post(server_id):
org_id = bson.ObjectId(flask.request.json['org_id'])
user_id = bson.ObjectId(flask.request.json['user_id'])
svr = server.get_by_id(server_id, fields=['_id', 'name', 'organizations'])
if not svr:
return utils.jsonify({
'error': SERVER_INVALID,
'error_msg': SERVER_INVALID_MSG,
}, 401)
org = svr.get_org(org_id, fields=['_id'])
if not org:
logger.LogEntry(message='User failed authentication, ' +
'invalid organization "%s" on server "%s".' % (org_id, svr.name))
return utils.jsonify({
'error': ORG_INVALID,
'error_msg': ORG_INVALID_MSG,
}, 401)
user = org.get_user(user_id, fields=['_id', 'name', 'disabled'])
if not user:
logger.LogEntry(message='User failed authentication, ' +
'invalid user "%s" on server "%s".' % (user_id, svr.name))
return utils.jsonify({
'error': USER_INVALID,
'error_msg': USER_INVALID_MSG,
}, 401)
if user.disabled:
logger.LogEntry(message='User failed authentication, ' +
'disabled user "%s" on server "%s".' % (user.name, svr.name))
return utils.jsonify({
'error': USER_INVALID,
'error_msg': USER_INVALID_MSG,
}, 401)
return utils.jsonify({
'authenticated': True,
})
def server_tls_verify_post(server_id):
org_id = bson.ObjectId(flask.request.json['org_id'])
user_id = bson.ObjectId(flask.request.json['user_id'])
svr = server.get_by_id(server_id, fields=['_id', 'name', 'organizations'])
if not svr:
return utils.jsonify({
'error': SERVER_INVALID,
'error_msg': SERVER_INVALID_MSG,
}, 401)
org = svr.get_org(org_id, fields=['_id'])
if not org:
logger.LogEntry(message='User failed authentication, ' +
'invalid organization "%s" on server "%s".' % (org_id, svr.name))
return utils.jsonify({
'error': ORG_INVALID,
'error_msg': ORG_INVALID_MSG,
}, 401)
user = org.get_user(user_id, fields=['_id', 'name', 'disabled'])
if not user:
logger.LogEntry(message='User failed authentication, ' +
'invalid user "%s" on server "%s".' % (user_id, svr.name))
return utils.jsonify({
'error': USER_INVALID,
'error_msg': USER_INVALID_MSG,
}, 401)
if user.disabled:
logger.LogEntry(message='User failed authentication, ' +
'disabled user "%s" on server "%s".' % (user.name, svr.name))
return utils.jsonify({
'error': USER_INVALID,
'error_msg': USER_INVALID_MSG,
}, 401)
return utils.jsonify({
'authenticated': True,
})
def server_host_put(server_id, host_id):
if settings.app.demo_mode:
return utils.demo_blocked()
svr = server.get_by_id(server_id)
if not svr:
return flask.abort(404)
hst = host.get_by_id(host_id, fields=('_id', 'name',
'public_address', 'auto_public_address', 'auto_public_host',
'public_address6', 'auto_public_address6', 'auto_public_host6'))
if not svr:
return flask.abort(404)
try:
svr.add_host(hst.id)
except ServerLinkCommonHostError:
return utils.jsonify({
'error': SERVER_LINK_COMMON_HOST,
'error_msg': SERVER_LINK_COMMON_HOST_MSG,
}, 400)
err, err_msg = svr.validate_conf(allow_online=True)
if err:
return utils.jsonify({
'error': err,
'error_msg': err_msg,
}, 400)
svr.commit('hosts')
event.Event(type=SERVER_HOSTS_UPDATED, resource_id=svr.id)
return utils.jsonify({
'id': hst.id,
'server': svr.id,
'status': OFFLINE,
'name': hst.name,
'address': hst.public_addr,
})
def task(self):
svr = server.get_by_id(self.server_id)
if not svr:
logger.warning(
"Tried to run assign_ip_addr queue " + "but server is no longer available",
"queues",
server_id=self.server_id,
)
return
for _ in xrange(5):
if svr.network_lock:
time.sleep(2)
svr.load()
else:
break
if svr.network_lock:
raise ServerNetworkLocked(
"Server network is locked", {"server_id": svr.id, "queue_id": self.id, "queue_type": self.type}
)
svr.ip_pool.assign_ip_addr(self.org_id, self.user_id)
def task(self):
svr = server.get_by_id(self.server_id)
if not svr:
logger.warning('Tried to run assign_ip_addr queue ' +
'but server is no longer available', 'queues',
server_id=self.server_id,
)
return
for _ in xrange(5):
if svr.network_lock:
time.sleep(2)
svr.load()
else:
break
if svr.network_lock:
raise ServerNetworkLocked('Server network is locked', {
'server_id': svr.id,
'queue_id': self.id,
'queue_type': self.type,
})
svr.ip_pool.assign_ip_addr(self.org_id, self.user_id)
def get_by_id(self, server_id):
from pritunl import server
svr = server.get_by_id(server_id)
if svr and self.id in svr.organizations:
return svr
