def check_auth(username, password, remote_addr=None):
if remote_addr:
cache_key = 'ip_' + remote_addr
count = cache_db.list_length(cache_key)
if count and count > 10:
raise flask.abort(403)
key_exists = cache_db.exists(cache_key)
cache_db.list_rpush(cache_key, '')
if not key_exists:
cache_db.expire(cache_key, 20)
db_username = persist_db.dict_get('auth', 'username') or DEFAULT_USERNAME
if username != db_username:
return False
db_password = persist_db.dict_get('auth', 'password')
if not db_password:
if password == DEFAULT_PASSWORD:
return True
return False
pass_ver, pass_salt, db_pass_hash = db_password.split('$')
if pass_ver == '0':
pass_hash = _hash_password_v0(pass_salt, password)
elif pass_ver == '1':
pass_hash = _hash_password_v1(pass_salt, password)
else:
return False
return pass_hash == db_pass_hash
def push_output(self, output):
if not app_server.server_log_lines:
return
cache_db.list_rpush(self.get_cache_key('output'), output.rstrip('\n'))
clear_lines = cache_db.list_length(self.get_cache_key('output')) - \
app_server.server_log_lines
for _ in xrange(clear_lines):
cache_db.list_lpop(self.get_cache_key('output'))
self._event_delay(type=SERVER_OUTPUT_UPDATED, resource_id=self.id)
def sort_users_cache(self):
user_count = 0
users_dict = {}
users_sort = []
# Create temp uuid key to prevent multiple threads modifying same key
temp_suffix = 'temp_' + uuid.uuid4().hex
temp_users_sorted_key = 'users_sorted_' + temp_suffix
users_page_index_key = 'users_page_index_' + temp_suffix
try:
for user_id in cache_db.set_elements(self.get_cache_key('users')):
user = User.get_user(self, id=user_id)
if not user:
continue
name_id = '%s_%s' % (user.name, user_id)
if user.type == CERT_CLIENT:
user_count += 1
users_dict[name_id] = (user_id, user.type)
users_sort.append(name_id)
cache_db.set(self.get_cache_key('user_count'), str(user_count))
cur_page = 0
user_count = 0
client_count = 0
for name_id in sorted(users_sort):
if users_dict[name_id][1] == CERT_CLIENT:
page = client_count / USER_PAGE_COUNT
if page != cur_page:
cur_page = page
cache_db.dict_set(self.get_cache_key(users_page_index_key),
str(cur_page), str(user_count))
client_count += 1
user_count += 1
cache_db.list_rpush(self.get_cache_key(temp_users_sorted_key),
users_dict[name_id][0])
cache_db.lock_acquire(self.get_cache_key('sort'))
try:
cache_db.rename(self.get_cache_key(users_page_index_key),
self.get_cache_key('users_page_index'))
cache_db.rename(self.get_cache_key(temp_users_sorted_key),
self.get_cache_key('users_sorted'))
cache_db.set(self.get_cache_key('users_page_total'),
str(cur_page))
finally:
cache_db.lock_release(self.get_cache_key('sort'))
except:
cache_db.remove(self.get_cache_key(users_page_index_key))
cache_db.remove(self.get_cache_key(temp_users_sorted_key))
raise
def check_auth(username, password, remote_addr=None):
from administrator import Administrator
if remote_addr:
# TODO
cache_key = 'ip_' + remote_addr
count = cache_db.list_length(cache_key)
if count and count > 10:
raise flask.abort(403)
# TODO
key_exists = cache_db.exists(cache_key)
cache_db.list_rpush(cache_key, '')
if not key_exists:
cache_db.expire(cache_key, 20)
administrator = Administrator.find_user(username=username)
if not administrator:
return
if not administrator.test_password(password):
return
return administrator
def sort_servers_cache(cls):
servers_dict = {}
servers_sort = []
# Create temp uuid key to prevent multiple threads modifying same key
temp_sorted_key = 'servers_sorted_temp_' + uuid.uuid4().hex
try:
for server_id_type in cache_db.set_elements('servers'):
server_id, server_type = server_id_type.split('_', 1)
server = Server.get_server(id=server_id, type=server_type)
if not server:
continue
name_id = '%s_%s' % (server.name, server_id)
servers_dict[name_id] = server_id_type
servers_sort.append(name_id)
for name_id in sorted(servers_sort):
cache_db.list_rpush(temp_sorted_key, servers_dict[name_id])
cache_db.rename(temp_sorted_key, 'servers_sorted')
except:
cache_db.remove(temp_sorted_key)
raise
def check_auth(username, password, remote_addr=None):
if remote_addr:
cache_key = "ip_" + remote_addr
count = cache_db.list_length(cache_key)
if count and count > 10:
raise flask.abort(403)
key_exists = cache_db.exists(cache_key)
cache_db.list_rpush(cache_key, "")
if not key_exists:
cache_db.expire(cache_key, 20)
db_username = persist_db.dict_get("auth", "username") or DEFAULT_USERNAME
if username != db_username:
return False
db_password = persist_db.dict_get("auth", "password")
if not db_password:
if password == DEFAULT_PASSWORD:
return True
return False
return _test_password_hash(db_password, password)
def sort_orgs_cache(cls):
org_count = 0
orgs_dict = {}
orgs_sort = []
# Create temp uuid key to prevent multiple threads modifying same key
temp_orgs_sorted_key = 'orgs_sorted_temp_' + uuid.uuid4().hex
try:
for org_id in cache_db.set_elements('orgs'):
org = Organization.get_org(id=org_id)
if not org:
continue
name_id = '%s_%s' % (org.name, org_id)
org_count += 1
orgs_dict[name_id] = org_id
orgs_sort.append(name_id)
cache_db.set('org_count', str(org_count))
for name_id in sorted(orgs_sort):
cache_db.list_rpush(temp_orgs_sorted_key, orgs_dict[name_id])
cache_db.rename(temp_orgs_sorted_key, 'orgs_sorted')
except:
cache_db.remove(temp_orgs_sorted_key)
raise
def push_output(self, output):
cache_db.list_rpush(self.get_cache_key('output'), output.rstrip('\n'))
self._event_delay(type=SERVER_OUTPUT_UPDATED, resource_id=self.id)