def __init__(self, svr, instance, instance_com):
self.server = svr
self.instance = instance
self.instance_com = instance_com
self.iroutes = {}
self.iroutes_thread = {}
self.iroutes_lock = threading.RLock()
self.iroutes_index = collections.defaultdict(set)
self.call_queue = callqueue.CallQueue(self.instance.is_sock_interrupt,
512)
self.clients_call_queue = callqueue.CallQueue(
self.instance.is_sock_interrupt)
self.obj_cache = objcache.ObjCache()
self.client_routes = set()
self.clients = docdb.DocDb(
'user_id',
'mac_addr',
'virt_address',
)
self.clients_queue = collections.deque()
self.ip_pool = []
self.ip_network = ipaddress.IPv4Network(self.server.network)
for ip_addr in self.ip_network.iterhosts():
self.ip_pool.append(ip_addr)
def assign_ip_addr(self, org_id, user_id):
network_hash = self.server.network_hash
server_id = self.server.id
response = self.collection.update({
'network': network_hash,
'server_id': server_id,
'user_id': {'$exists': False},
}, {'$set': {
'org_id': org_id,
'user_id': user_id,
}})
if response['updatedExisting']:
return
network = ipaddress.IPv4Network(self.server.network)
if self.server.network_start:
network_start = ipaddress.IPv4Address(self.server.network_start)
else:
network_start = None
if self.server.network_end:
network_end = ipaddress.IPv4Address(self.server.network_end)
else:
network_end = None
ip_pool = self.get_ip_pool(network, network_start)
if not ip_pool:
return
try:
doc = self.collection.find({
'network': network_hash,
'server_id': server_id,
}).sort('_id', pymongo.DESCENDING)[0]
if doc:
last_addr = doc['_id']
for remote_ip_addr in ip_pool:
if int(remote_ip_addr) == last_addr:
break
except IndexError:
pass
for remote_ip_addr in ip_pool:
if network_end and remote_ip_addr > network_end:
break
try:
self.collection.insert({
'_id': int(remote_ip_addr),
'network': network_hash,
'server_id': server_id,
'org_id': org_id,
'user_id': user_id,
'address': '%s/%s' % (remote_ip_addr, network.prefixlen),
})
return True
except pymongo.errors.DuplicateKeyError:
pass
return False
def assign_ip_pool(self, network, network_start,
network_end, network_hash):
server_id = self.server.id
pool_end = False
network = ipaddress.IPv4Network(network)
if network_start:
network_start = ipaddress.IPv4Address(network_start)
if network_end:
network_end = ipaddress.IPv4Address(network_end)
ip_pool = self.get_ip_pool(network, network_start)
if not ip_pool:
return
bulk = self.collection.initialize_unordered_bulk_op()
bulk_empty = True
for org in self.server.iter_orgs():
org_id = org.id
for user in org.iter_users(include_pool=True):
try:
remote_ip_addr = next(ip_pool)
if network_end and remote_ip_addr > network_end:
raise StopIteration()
except StopIteration:
pool_end = True
break
doc_id = int(remote_ip_addr)
spec = {
'_id': doc_id,
}
doc = {'$set': {
'_id': doc_id,
'network': network_hash,
'server_id': server_id,
'org_id': org_id,
'user_id': user.id,
'address': '%s/%s' % (remote_ip_addr, network.prefixlen),
}}
if bulk:
bulk.find(spec).upsert().update(doc)
bulk_empty = False
else:
self.collection.update(spec, doc, upsert=True)
if pool_end:
logger.warning('Failed to assign ip addresses ' +
'to server, ip pool empty', 'server',
server_id=server_id,
org_id=org_id,
)
break
if not bulk_empty:
bulk.execute()
def assign_ip_addr(self, org_id, user_id):
network = self.server.network
server_id = self.server.id
response = self.collection.update(
{
'network': network,
'server_id': server_id,
'user_id': {
'$exists': False
},
}, {'$set': {
'org_id': org_id,
'user_id': user_id,
}})
if response['updatedExisting']:
return
ip_network = ipaddress.IPv4Network(network)
ip_pool = ip_network.iterhosts()
ip_pool.next()
try:
doc = self.collection.find({
'network': network,
'server_id': server_id,
}).sort('_id', pymongo.DESCENDING)[0]
if doc:
last_addr = doc['_id']
for remote_ip_addr in ip_pool:
if int(remote_ip_addr) == last_addr:
break
except IndexError:
pass
for remote_ip_addr in ip_pool:
try:
self.collection.insert({
'_id':
int(remote_ip_addr),
'network':
network,
'server_id':
server_id,
'org_id':
org_id,
'user_id':
user_id,
'address':
'%s/%s' % (remote_ip_addr, ip_network.prefixlen),
})
return True
except pymongo.errors.DuplicateKeyError:
pass
return False
def assign_ip_pool(self, network):
server_id = self.server.id
pool_end = False
ip_network = ipaddress.IPv4Network(network)
ip_pool = ip_network.iterhosts()
ip_pool.next()
if mongo.has_bulk:
bulk = self.collection.initialize_unordered_bulk_op()
bulk_empty = True
else:
bulk = None
bulk_empty = None
for org in self.server.iter_orgs():
org_id = org.id
for user in org.iter_users(include_pool=True):
try:
remote_ip_addr = ip_pool.next()
except StopIteration:
pool_end = True
break
doc_id = int(remote_ip_addr)
spec = {
'_id': doc_id,
}
doc = {'$set': {
'_id': doc_id,
'network': network,
'server_id': server_id,
'org_id': org_id,
'user_id': user.id,
'address': '%s/%s' % (remote_ip_addr,
ip_network.prefixlen),
}}
if bulk:
bulk.find(spec).upsert().update(doc)
bulk_empty = False
else:
self.collection.update(spec, doc, upsert=True)
if pool_end:
logger.warning('Failed to assign ip addresses ' +
'to server, ip pool empty', 'server',
server_id=server_id,
org_id=org_id,
)
break
if bulk and not bulk_empty:
bulk.execute()
def __init__(self, server, instance, instance_com):
self.server = server
self.instance = instance
self.instance_com = instance_com
self.clients = collections.deque()
self.ips = {}
self.dyn_ips = set()
self.devices = collections.defaultdict(dict)
self.ip_pool = []
self.ip_network = ipaddress.IPv4Network(self.server.network)
for ip_addr in self.ip_network.iterhosts():
self.ip_pool.append(ip_addr)
def __init__(self, server, instance, instance_com):
self.server = server
self.instance = instance
self.instance_com = instance_com
self.clients = docdb.DocDb(
'user_id',
'device_id',
'virt_address',
)
self.clients_queue = collections.deque()
self.ip_pool = []
self.ip_network = ipaddress.IPv4Network(self.server.network)
for ip_addr in self.ip_network.iterhosts():
self.ip_pool.append(ip_addr)
def __init__(self, server, instance):
self.server = server
self.instance = instance
self.sock = None
self.socket_path = instance.management_socket_path
self.bytes_lock = threading.Lock()
self.bytes_recv = 0
self.bytes_sent = 0
self.client = None
self.clients = []
self.clients_active = 0
self.client_count = 0
self.client_bytes = {}
self.client_devices = collections.defaultdict(list)
self.client_ips = set()
self.client_dyn_ips = set()
self.cur_timestamp = utils.now()
self.ip_network = ipaddress.IPv4Network(self.server.network)
self.ip_pool = []
self.bandwidth_rate = settings.vpn.bandwidth_update_rate
for ip_addr in self.ip_network.iterhosts():
self.ip_pool.append(ip_addr)
def assign_ip_pool_org(self, org_id):
org = organization.get_by_id(org_id)
network_hash = self.server.network_hash
server_id = self.server.id
org_id = org.id
ip_pool_avial = True
pool_end = False
network = ipaddress.IPv4Network(self.server.network)
network_start = self.server.network_start
network_end = self.server.network_end
if network_start:
network_start = ipaddress.IPv4Address(network_start)
if network_end:
network_end = ipaddress.IPv4Address(network_end)
ip_pool = self.get_ip_pool(network, network_start)
if not ip_pool:
return
try:
doc = self.collection.find({
'network': network_hash,
'server_id': server_id,
}).sort('_id', pymongo.DESCENDING)[0]
if doc:
last_addr = doc['_id']
for remote_ip_addr in ip_pool:
if int(remote_ip_addr) == last_addr:
break
if network_end and remote_ip_addr > network_end:
break
except IndexError:
pass
if mongo.has_bulk:
bulk = self.collection.initialize_unordered_bulk_op()
bulk_empty = True
else:
bulk = None
bulk_empty = None
for user in org.iter_users(include_pool=True):
if ip_pool_avial:
response = self.collection.update(
{
'network': network_hash,
'server_id': server_id,
'user_id': {
'$exists': False
},
}, {'$set': {
'org_id': org_id,
'user_id': user.id,
}})
if response['updatedExisting']:
continue
ip_pool_avial = False
try:
remote_ip_addr = ip_pool.next()
if network_end and remote_ip_addr > network_end:
raise StopIteration()
except StopIteration:
pool_end = True
break
doc_id = int(remote_ip_addr)
spec = {
'_id': doc_id,
}
doc = {
'$set': {
'_id': doc_id,
'network': network_hash,
'server_id': server_id,
'org_id': org_id,
'user_id': user.id,
'address': '%s/%s' % (remote_ip_addr, network.prefixlen),
}
}
if bulk:
bulk.find(spec).upsert().update(doc)
bulk_empty = False
else:
self.collection.update(spec, doc, upsert=True)
if bulk and not bulk_empty:
bulk.execute()
if pool_end:
logger.warning(
'Failed to assign ip addresses ' + 'to org, ip pool empty',
'server',
org_id=org_id,
)
