def create_group(self, user_id, session_id, node_name, group_id,
post_access, read_access, delete_access,
posting_key_hash, reading_key_hash, delete_key_hash,
quota_allocated, when_space_exhausted,
max_post_size,
public_key_hash, passphrase=None):
method = 'POST'
path = '/proxy/group'
body = uc.encode(
{'node_name' : node_name,
'group_id' : group_id,
'post_access' : post_access,
'read_access' : read_access,
'delete_access' : delete_access,
'posting_key_hash' : posting_key_hash,
'reading_key_hash' : reading_key_hash,
'delete_key_hash' : delete_key_hash,
'quota_allocated' : quota_allocated,
'when_space_exhausted' : when_space_exhausted,
'max_post_size' : max_post_size,
'public_key_hash' : public_key_hash,
'passphrase' : passphrase})
cookies = co.SimpleCookie({'user_id' : user_id, 'session_id' : session_id})
return self.send_and_getter.send_and_get(self.conn, method, path, body=body, cookies=cookies)[0]
def read_version(self, node_name):
method = 'GET'
url = '/version?' + uc.encode(
{'node_name' : node_name})
return self.send_and_getter.send_and_get(self.conn, method, url)
def create_group(
self,
timestamp, node_name, group_id, owner_id,
post_access, read_access, delete_access,
posting_key_type, posting_pub_key,
reading_key_type, reading_pub_key,
delete_key_type, delete_pub_key,
quota_allocated, when_space_exhausted,
max_post_size,
public_key_hash, signature):
method = 'POST'
url = '/group'
body = uc.encode(
{'timestamp' : timestamp,
'node_name' : node_name,
'group_id' : group_id,
'owner_id' : owner_id,
'post_access' : post_access,
'read_access' : read_access,
'delete_access' : delete_access,
'posting_key_type' : posting_key_type,
'posting_pub_key' : posting_pub_key,
'reading_key_type' : reading_key_type,
'reading_pub_key' : reading_pub_key,
'delete_key_type' : delete_key_type,
'delete_pub_key' : delete_pub_key,
'quota_allocated' : quota_allocated,
'when_space_exhausted' : when_space_exhausted,
'max_post_size' : max_post_size,
'public_key_hash' : public_key_hash,
'signature' : signature})
return self.send_and_getter.send_and_get(self.conn, method, url, body)
def create_user(self, node_name, user_id,
key_type, public_key, public_key_hash, revoke_date,
default_message_access, when_mail_exhausted,
quota_size, mail_quota_size,
max_message_size,
user_class, auth_token):
method = 'POST'
url = '/user'
body = uc.encode(
{'node_name' : node_name,
'user_id' : user_id,
'key_type' : key_type,
'public_key' : public_key,
'public_key_hash' : public_key_hash,
'revoke_date' : revoke_date,
'default_message_access' : default_message_access,
'when_mail_exhausted' : when_mail_exhausted,
'quota_size' : quota_size,
'mail_quota_size' : mail_quota_size,
'max_message_size' : max_message_size,
'user_class' : user_class,
'auth_token' : auth_token})
return self.send_and_getter.send_and_get(self.conn, method, url, body)
def query_user(self, node_name, user_id):
method = 'GET'
url = '/query-user?' + uc.encode(
{'node_name' : node_name,
'user_id' : user_id})
return self.send_and_getter.send_and_get(self.conn, method, url)
def read_node_addr(self, user_id, session_id, node_name):
method = 'GET'
path = '/local/node-addr?' + uc.encode(
{'node_name' : node_name})
cookies = co.SimpleCookie({'user_id' : user_id, 'session_id' : session_id})
return self.send_and_getter.send_and_get(self.conn, method, path, body=None, cookies=cookies)[0]
def read_quota_available(self, node_name, user_class):
method = 'GET'
url = '/quota-available?' + uc.encode(
{'node_name' : node_name,
'user_class' : user_class})
return self.send_and_getter.send_and_get(self.conn, method, url)
def list_user_keys(self, user_id, session_id, node_name=None):
method = 'GET'
path = '/local/list-user-keys?' + uc.encode(
{'node_name' : node_name})
cookies = co.SimpleCookie({'user_id' : user_id, 'session_id' : session_id})
return self.send_and_getter.send_and_get(self.conn, method, path, body=None, cookies=cookies)[0]
def read_public_key(self, user_id, session_id, public_key_hash):
method = 'GET'
path = '/local/public-key?' + uc.encode(
{'public_key_hash' : public_key_hash})
cookies = co.SimpleCookie({'user_id' : user_id, 'session_id' : session_id})
return self.send_and_getter.send_and_get(self.conn, method, path, body=None, cookies=cookies)[0]
def delete_node_addr(self, user_id, session_id, node_name):
method = 'DELETE'
path = '/local/node-addr'
body = uc.encode(
{'node_name' : node_name})
cookies = co.SimpleCookie({'user_id' : user_id, 'session_id' : session_id})
return self.send_and_getter.send_and_get(self.conn, method, path, body=body, cookies=cookies)[0]
def query_user(self, user_id, session_id, node_name, other_user_id):
method = 'GET'
path = '/proxy/query-user?' + uc.encode(
{'node_name' : node_name,
'other_user_id' : other_user_id})
cookies = co.SimpleCookie({'user_id' : user_id, 'session_id' : session_id})
return self.send_and_getter.send_and_get(self.conn, method, path, body=None, cookies=cookies)[0]
def delete_public_key(self, user_id, session_id, public_key_hash):
method = 'DELETE'
path = '/local/public-key'
body = uc.encode(
{'public_key_hash' : public_key_hash})
cookies = co.SimpleCookie({'user_id' : user_id, 'session_id' : session_id})
return self.send_and_getter.send_and_get(self.conn, method, path, body=body, cookies=cookies)[0]
def create_local_user(self, user_id, password):
method = 'POST'
path = '/local/user'
body = uc.encode(
{'user_id' : user_id,
'password' : password})
return self.send_and_getter.send_and_get(self.conn, method, path, body=body, cookies=None)
def read_quota_available(self, user_id, session_id, node_name, user_class):
method = 'GET'
path = '/proxy/quota-available?' + uc.encode(
{'node_name' : node_name,
'user_class' : user_class})
cookies = co.SimpleCookie({'user_id' : user_id, 'session_id' : session_id})
return self.send_and_getter.send_and_get(self.conn, method, path, body=None, cookies=cookies)[0]
def read_private_key(self, user_id, session_id, public_key_hash, only_public_part=None, allow_private_user_key=None):
method = 'GET'
path = '/local/private-key?' + uc.encode(
{'public_key_hash' : public_key_hash,
'only_public_part' : only_public_part,
'allow_private_user_key' : allow_private_user_key})
cookies = co.SimpleCookie({'user_id' : user_id, 'session_id' : session_id})
return self.send_and_getter.send_and_get(self.conn, method, path, body=None, cookies=cookies)[0]
def encrypt(self, user_id, session_id, public_key_hash, plaintext):
method = 'POST'
path = '/local/crypt/encrypt'
body = uc.encode(
{'public_key_hash' : public_key_hash,
'plaintext' : plaintext})
cookies = co.SimpleCookie({'user_id' : user_id, 'session_id' : session_id})
return self.send_and_getter.send_and_get(self.conn, method, path, body, cookies)[0]
def read_message_quota(self, user_id, session_id, node_name, public_key_hash, passphrase=None):
method = 'GET'
path = '/proxy/message-quota?' + uc.encode(
{'node_name' : node_name,
'public_key_hash' : public_key_hash,
'passphrase' : passphrase})
cookies = co.SimpleCookie({'user_id' : user_id, 'session_id' : session_id})
return self.send_and_getter.send_and_get(self.conn, method, path, body=None, cookies=cookies)[0]
def assign_user_key(self, user_id, session_id, node_name, public_key_hash):
method = 'POST'
path = '/local/user-key'
body = uc.encode(
{'node_name' : node_name,
'public_key_hash' : public_key_hash})
cookies = co.SimpleCookie({'user_id' : user_id, 'session_id' : session_id})
return self.send_and_getter.send_and_get(self.conn, method, path, body=body, cookies=cookies)[0]
def read_max_post_size(self, timestamp, node_name, group_id, owner_id, post_signature):
method = 'GET'
url = '/max-post-size?' + uc.encode(
{'timestamp' : timestamp,
'node_name' : node_name,
'group_id' : group_id,
'owner_id' : owner_id,
'post_signature' : post_signature})
return self.send_and_getter.send_and_get(self.conn, method, url)
def read_local_message_access(self, user_id, session_id, to_user, node_name, from_user_key_hash):
method = 'GET'
path = '/local/message-access?' + uc.encode(
{'to_user' : to_user,
'node_name' : node_name,
'from_user_key_hash' : from_user_key_hash})
cookies = co.SimpleCookie({'user_id' : user_id, 'session_id' : session_id})
return self.send_and_getter.send_and_get(self.conn, method, path, body=None, cookies=cookies)[0]
def cache_passphrase(self, user_id, session_id, public_key_hash, passphrase, expire_time=None):
method = 'POST'
path = '/local/passphrase'
body = uc.encode(
{'public_key_hash' : public_key_hash,
'passphrase' : passphrase,
'expire_time' : expire_time})
cookies = co.SimpleCookie({'user_id' : user_id, 'session_id' : session_id})
return self.send_and_getter.send_and_get(self.conn, method, path, body=body, cookies=cookies)[0]
def read_user_quota(self, timestamp, node_name, user_id, public_key_hash, signature):
method = 'GET'
url = '/user-quota?' + uc.encode(
{'timestamp' : timestamp,
'node_name' : node_name,
'user_id' : user_id,
'public_key_hash' : public_key_hash,
'signature' : signature})
return self.send_and_getter.send_and_get(self.conn, method, url)
def read_local_group_access(self, user_id, session_id, group_id, owner_id, node_name, use):
method = 'GET'
path = '/local/group-access?' + uc.encode(
{'owner_id' : owner_id,
'group_id' : group_id,
'node_name' : node_name,
'use' : use})
cookies = co.SimpleCookie({'user_id' : user_id, 'session_id' : session_id})
return self.send_and_getter.send_and_get(self.conn, method, path, body=None, cookies=cookies)[0]
def verify_signature(self, user_id, session_id, public_key_hash, data, signature):
method = 'POST'
path = '/local/crypt/verify-signature'
body = uc.encode(
{'public_key_hash' : public_key_hash,
'data' : data,
'signature' : signature})
cookies = co.SimpleCookie({'user_id' : user_id, 'session_id' : session_id})
return self.send_and_getter.send_and_get(self.conn, method, path, body, cookies)[0]
def read_last_message_time(self, timestamp, node_name, user_id, public_key_hash, signature):
method = 'GET'
url = '/last-message-time?' + uc.encode(
{'timestamp' : timestamp,
'node_name' : node_name,
'user_id' : user_id,
'public_key_hash' : public_key_hash,
'signature' : signature})
return self.send_and_getter.send_and_get(self.conn, method, url)
def import_public_key(self, user_id, session_id, key_type, public_key, revoke_date):
method = 'POST'
path = '/local/public-key'
body = uc.encode(
{'key_type' : key_type,
'public_key' : public_key,
'revoke_date' : revoke_date})
cookies = co.SimpleCookie({'user_id' : user_id, 'session_id' : session_id})
return self.send_and_getter.send_and_get(self.conn, method, path, body=body, cookies=cookies)[0]
def set_password(self, user_id, session_id, method, password=None, public_key_hash=None):
method = 'POST'
path = '/local/password'
body = uc.encode(
{'method' : method,
'password' : password,
'public_key_hash' : public_key_hash})
cookies = co.SimpleCookie({'user_id' : user_id, 'session_id' : session_id})
return self.send_and_getter.send_and_get(self.conn, method, path, body=body, cookies=cookies)[0]
def sign(self, user_id, session_id, public_key_hash, data, passphrase):
method = 'POST'
path = '/local/crypt/sign'
body = uc.encode(
{'public_key_hash' : public_key_hash,
'data' : data,
'passphrase' : passphrase})
cookies = co.SimpleCookie({'user_id' : user_id, 'session_id' : session_id})
return self.send_and_getter.send_and_get(self.conn, method, path, body, cookies)[0]
def read_max_post_size(self, user_id, session_id, node_name, group_id, owner_id, passphrase):
method = 'GET'
path = '/proxy/max-post-size?' + uc.encode(
{'node_name' : node_name,
'group_id' : group_id,
'owner_id' : owner_id,
'passphrase' : passphrase})
cookies = co.SimpleCookie({'user_id' : user_id, 'session_id' : session_id})
return self.send_and_getter.send_and_get(self.conn, method, path, body=None, cookies=cookies)[0]
def read_max_message_size(self, user_id, session_id, node_name, to_user, from_user_key_hash, passphrase):
method = 'GET'
path = '/proxy/max-message-size?' + uc.encode(
{'node_name' : node_name,
'to_user' : to_user,
'from_user_key_hash' : from_user_key_hash,
'passphrase' : passphrase})
cookies = co.SimpleCookie({'user_id' : user_id, 'session_id' : session_id})
return self.send_and_getter.send_and_get(self.conn, method, path, body=None, cookies=cookies)[0]
