def _upgrade_data(self):
version = self._get_version()
cur_version = self._get_data_version()
if cur_version and cur_version < self._get_version_int('0.10.5'):
logger.info('Upgrading data to v0.10.5...')
from server import Server
for server in Server.iter_servers():
server._upgrade_0_10_5()
from organization import Organization
for org in Organization.iter_orgs():
org._upgrade_0_10_5()
if cur_version and cur_version < self._get_version_int('0.10.6'):
logger.info('Upgrading data to v0.10.6...')
if self.password:
from cache import persist_db
logger.info('Upgrading config to v0.10.6...')
salt = base64.b64encode(
'2511cebca93d028393735637bbc8029207731fcf')
password = base64.b64encode(self.password.decode('hex'))
persist_db.dict_set('auth', 'password',
'0$%s$%s' % (salt, password))
self.password = None
self.commit()
from server import Server
for server in Server.iter_servers():
server._upgrade_0_10_6()
if cur_version and cur_version < self._get_version_int('0.10.9'):
logger.info('Upgrading data to v0.10.9...')
from server import Server
for server in Server.iter_servers():
server._upgrade_0_10_9()
from organization import Organization
for org in Organization.iter_orgs():
for user in org.iter_users():
user._upgrade_0_10_9()
org.sort_users_cache()
if cur_version != version:
from pritunl import __version__
version_path = os.path.join(self.data_path, VERSION_NAME)
with open(version_path, 'w') as version_file:
version_file.write('%s\n' % __version__)
def _update_clients_bandwidth(self, clients):
# Remove client no longer connected
for client_id in cache_db.dict_keys(self.get_cache_key('clients')):
if client_id not in clients:
cache_db.dict_remove(self.get_cache_key('clients'), client_id)
# Get total bytes send and recv for all clients
bytes_recv_t = 0
bytes_sent_t = 0
for client_id in clients:
bytes_recv = clients[client_id]['bytes_received']
bytes_sent = clients[client_id]['bytes_sent']
prev_bytes_recv = 0
prev_bytes_sent = 0
client_prev = cache_db.dict_get(self.get_cache_key('clients'),
client_id)
cache_db.dict_set(self.get_cache_key('clients'), client_id,
'%s,%s' % (bytes_recv, bytes_sent))
if client_prev:
client_prev = client_prev.split(',')
prev_bytes_recv = int(client_prev[0])
prev_bytes_sent = int(client_prev[1])
if prev_bytes_recv > bytes_recv or prev_bytes_sent > bytes_sent:
prev_bytes_recv = 0
prev_bytes_sent = 0
bytes_recv_t += bytes_recv - prev_bytes_recv
bytes_sent_t += bytes_sent - prev_bytes_sent
# Store bytes send recv into time periods
if bytes_recv_t != 0 or bytes_sent_t != 0:
date = datetime.datetime.utcnow()
date -= datetime.timedelta(microseconds=date.microsecond,
seconds=date.second)
timestamp_1m = date.strftime('%s')
timestamp_1m_min = int((date - datetime.timedelta(
hours=6)).strftime('%s'))
date_5m = date - datetime.timedelta(minutes=date.minute % 5)
timestamp_5m = date_5m.strftime('%s')
timestamp_5m_min = int((date_5m - datetime.timedelta(
days=1)).strftime('%s'))
date_30m = date - datetime.timedelta(minutes=date.minute % 30)
timestamp_30m = date_30m.strftime('%s')
timestamp_30m_min = int((date_30m - datetime.timedelta(
days=7)).strftime('%s'))
date_2h = date - datetime.timedelta(
hours=date.hour % 2, minutes=date.minute)
timestamp_2h = date_2h.strftime('%s')
timestamp_2h_min = int((date_2h - datetime.timedelta(
days=30)).strftime('%s'))
date_1d = date - datetime.timedelta(
hours=date.hour, minutes=date.minute)
timestamp_1d = date_1d.strftime('%s')
timestamp_1d_min = int((date_1d - datetime.timedelta(
days=365)).strftime('%s'))
for period, timestamp, timestamp_min in (
('1m', timestamp_1m, timestamp_1m_min),
('5m', timestamp_5m, timestamp_5m_min),
('30m', timestamp_30m, timestamp_30m_min),
('2h', timestamp_2h, timestamp_2h_min),
('1d', timestamp_1d, timestamp_1d_min),
):
bytes_recv = bytes_recv_t
bytes_sent = bytes_sent_t
prev_bandwidth = persist_db.dict_get(
self.get_cache_key('bandwidth-%s' % period), timestamp)
if prev_bandwidth:
prev_bandwidth = prev_bandwidth.split(',')
bytes_recv += int(prev_bandwidth[0])
bytes_sent += int(prev_bandwidth[1])
persist_db.dict_set(self.get_cache_key(
'bandwidth-%s' % period), timestamp,
'%s,%s' % (bytes_recv, bytes_sent))
for timestamp_p in persist_db.dict_keys(self.get_cache_key(
'bandwidth-%s' % period)):
if int(timestamp_p) <= timestamp_min:
persist_db.dict_remove(self.get_cache_key(
'bandwidth-%s' % period), timestamp_p)
