def cancel(self, request, info):
from p2p import p2p_service
if not contactsdb.is_customer(request.OwnerID):
lg.warn(
"got packet from %s, but he is not a customer" %
request.OwnerID)
return p2p_service.SendFail(request, 'not a customer')
if accounting.check_create_customers_quotas():
lg.out(6, 'service_supplier.cancel created a new space file')
space_dict = accounting.read_customers_quotas()
if request.OwnerID not in space_dict.keys():
lg.warn(
"got packet from %s, but not found him in space dictionary" %
request.OwnerID)
return p2p_service.SendFail(request, 'not a customer')
try:
free_bytes = int(space_dict['free'])
space_dict['free'] = free_bytes + int(space_dict[request.OwnerID])
except:
lg.exc()
return p2p_service.SendFail(request, 'broken space file')
new_customers = list(contactsdb.customers())
new_customers.remove(request.OwnerID)
contactsdb.update_customers(new_customers)
contactsdb.save_customers()
space_dict.pop(request.OwnerID)
accounting.write_customers_quotas(space_dict)
from supplier import local_tester
reactor.callLater(0, local_tester.TestUpdateCustomers)
return p2p_service.SendAck(request, 'accepted')
def cancel(self, json_payload, newpacket, info):
from twisted.internet import reactor # @UnresolvedImport
from logs import lg
from main import events
from p2p import p2p_service
from contacts import contactsdb
from storage import accounting
customer_idurl = newpacket.OwnerID
if not contactsdb.is_customer(customer_idurl):
lg.warn("got packet from %s, but he is not a customer" % customer_idurl)
return p2p_service.SendFail(newpacket, 'not a customer')
if accounting.check_create_customers_quotas():
lg.out(6, 'service_supplier.cancel created a new space file')
space_dict = accounting.read_customers_quotas()
if customer_idurl not in list(space_dict.keys()):
lg.warn("got packet from %s, but not found him in space dictionary" % customer_idurl)
return p2p_service.SendFail(newpacket, 'not a customer')
try:
free_bytes = int(space_dict[b'free'])
space_dict[b'free'] = free_bytes + int(space_dict[customer_idurl])
except:
lg.exc()
return p2p_service.SendFail(newpacket, 'broken space file')
new_customers = list(contactsdb.customers())
new_customers.remove(customer_idurl)
contactsdb.update_customers(new_customers)
contactsdb.remove_customer_meta_info(customer_idurl)
contactsdb.save_customers()
space_dict.pop(customer_idurl)
accounting.write_customers_quotas(space_dict)
from supplier import local_tester
reactor.callLater(0, local_tester.TestUpdateCustomers) # @UndefinedVariable
lg.out(8, " OLD CUSTOMER: TERMINATED !!!!!!!!!!!!!!")
events.send('existing-customer-terminated', dict(idurl=customer_idurl))
return p2p_service.SendAck(newpacket, 'accepted')
def cancel(self, request, info):
from main import events
from p2p import p2p_service
if not contactsdb.is_customer(request.OwnerID):
lg.warn(
"got packet from %s, but he is not a customer" %
request.OwnerID)
return p2p_service.SendFail(request, 'not a customer')
if accounting.check_create_customers_quotas():
lg.out(6, 'service_supplier.cancel created a new space file')
space_dict = accounting.read_customers_quotas()
if request.OwnerID not in space_dict.keys():
lg.warn(
"got packet from %s, but not found him in space dictionary" %
request.OwnerID)
return p2p_service.SendFail(request, 'not a customer')
try:
free_bytes = int(space_dict['free'])
space_dict['free'] = free_bytes + int(space_dict[request.OwnerID])
except:
lg.exc()
return p2p_service.SendFail(request, 'broken space file')
new_customers = list(contactsdb.customers())
new_customers.remove(request.OwnerID)
contactsdb.update_customers(new_customers)
contactsdb.save_customers()
space_dict.pop(request.OwnerID)
accounting.write_customers_quotas(space_dict)
from supplier import local_tester
reactor.callLater(0, local_tester.TestUpdateCustomers)
lg.out(8, " OLD CUSTOMER: TERMINATED !!!!!!!!!!!!!!")
events.send('existing-customer-terminated', dict(idurl=request.OwnerID))
return p2p_service.SendAck(request, 'accepted')
def request(self, request, info):
from p2p import p2p_service
words = request.Payload.split(' ')
try:
bytes_for_customer = int(words[1])
except:
lg.exc()
bytes_for_customer = None
if not bytes_for_customer or bytes_for_customer < 0:
lg.warn("wrong storage value : %s" % request.Payload)
return p2p_service.SendFail(request, 'wrong storage value')
current_customers = contactsdb.customers()
if accounting.check_create_customers_quotas():
lg.out(6, 'service_supplier.request created a new space file')
space_dict = accounting.read_customers_quotas()
try:
free_bytes = int(space_dict['free'])
except:
lg.exc()
return p2p_service.SendFail(request, 'broken space file')
if (request.OwnerID not in current_customers and request.OwnerID in space_dict.keys()):
lg.warn("broken space file")
return p2p_service.SendFail(request, 'broken space file')
if (request.OwnerID in current_customers and request.OwnerID not in space_dict.keys()):
lg.warn("broken customers file")
return p2p_service.SendFail(request, 'broken customers file')
if request.OwnerID in current_customers:
free_bytes += int(space_dict[request.OwnerID])
space_dict['free'] = free_bytes
current_customers.remove(request.OwnerID)
space_dict.pop(request.OwnerID)
new_customer = False
else:
new_customer = True
from supplier import local_tester
if free_bytes <= bytes_for_customer:
contactsdb.update_customers(current_customers)
contactsdb.save_customers()
accounting.write_customers_quotas(space_dict)
reactor.callLater(0, local_tester.TestUpdateCustomers)
if new_customer:
lg.out(
8, " NEW CUSTOMER - DENIED !!!!!!!!!!! not enough space")
else:
lg.out(
8, " OLD CUSTOMER - DENIED !!!!!!!!!!! not enough space")
return p2p_service.SendAck(request, 'deny')
space_dict['free'] = free_bytes - bytes_for_customer
current_customers.append(request.OwnerID)
space_dict[request.OwnerID] = bytes_for_customer
contactsdb.update_customers(current_customers)
contactsdb.save_customers()
accounting.write_customers_quotas(space_dict)
reactor.callLater(0, local_tester.TestUpdateCustomers)
if new_customer:
lg.out(8, " NEW CUSTOMER ACCEPTED !!!!!!!!!!!!!!")
else:
lg.out(8, " OLD CUSTOMER ACCEPTED !!!!!!!!!!!!!!")
return p2p_service.SendAck(request, 'accepted')
def doRemoveCustomers(self, arg):
"""
Action method.
"""
space_dict, spent_bytes, current_customers, removed_customers = arg
contactsdb.update_customers(current_customers)
contactsdb.save_customers()
accounting.write_customers_quotas(space_dict)
def doRemoveCustomers(self, arg):
"""
Action method.
"""
space_dict, spent_bytes, current_customers, removed_customers = arg
contactsdb.update_customers(current_customers)
contactsdb.save_customers()
accounting.write_customers_quotas(space_dict)
def doRemoveCustomers(self, *args, **kwargs):
"""
Action method.
"""
space_dict, spent_bytes, current_customers, removed_customers = args[0]
contactsdb.update_customers(current_customers)
for customer_idurl in removed_customers:
contactsdb.remove_customer_meta_info(customer_idurl)
contactsdb.save_customers()
accounting.write_customers_quotas(space_dict)
def cancel(self, json_payload, newpacket, info):
from twisted.internet import reactor # @UnresolvedImport
from logs import lg
from main import events
from p2p import p2p_service
from contacts import contactsdb
from storage import accounting
from crypt import my_keys
customer_idurl = newpacket.OwnerID
try:
customer_public_key = json_payload['customer_public_key']
customer_public_key_id = customer_public_key['key_id']
except:
customer_public_key = None
customer_public_key_id = None
customer_ecc_map = json_payload.get('ecc_map')
if not contactsdb.is_customer(customer_idurl):
lg.warn("got packet from %s, but he is not a customer" %
customer_idurl)
return p2p_service.SendFail(newpacket, 'not a customer')
if accounting.check_create_customers_quotas():
lg.info('created a new space file')
space_dict, free_space = accounting.read_customers_quotas()
if customer_idurl.to_bin() not in list(space_dict.keys()):
lg.warn(
"got packet from %s, but not found him in space dictionary" %
customer_idurl)
return p2p_service.SendFail(newpacket, 'not a customer')
try:
free_bytes = int(free_space)
free_space = free_bytes + int(space_dict[customer_idurl.to_bin()])
except:
lg.exc()
return p2p_service.SendFail(newpacket, 'broken space file')
new_customers = list(contactsdb.customers())
new_customers.remove(customer_idurl)
space_dict.pop(customer_idurl.to_bin())
accounting.write_customers_quotas(space_dict, free_space)
contactsdb.remove_customer_meta_info(customer_idurl)
contactsdb.update_customers(new_customers)
contactsdb.save_customers()
if customer_public_key_id:
my_keys.erase_key(customer_public_key_id)
# TODO: erase customer's groups keys also
from supplier import local_tester
reactor.callLater(
0, local_tester.TestUpdateCustomers) # @UndefinedVariable
lg.info("OLD CUSTOMER TERMINATED %r" % customer_idurl)
events.send('existing-customer-terminated',
data=dict(idurl=customer_idurl, ecc_map=customer_ecc_map))
return p2p_service.SendAck(newpacket, 'accepted')
def on_identity_url_changed(evt):
old_idurl = id_url.field(evt.data['old_idurl'])
# update customer idurl in "space" file
contacts_changed = False
for customer_idurl in contactsdb.customers():
if old_idurl == customer_idurl:
customer_idurl.refresh()
contacts_changed = True
lg.info('found customer idurl rotated : %r -> %r' % (
evt.data['old_idurl'],
evt.data['new_idurl'],
))
if contacts_changed:
contactsdb.save_customers()
# update meta info for that customer
meta_info_changed = False
all_meta_info = contactsdb.read_customers_meta_info_all()
for customer_idurl_bin in list(all_meta_info.keys()):
if id_url.is_cached(old_idurl) and id_url.is_cached(
customer_idurl_bin):
if old_idurl == id_url.field(customer_idurl_bin):
latest_customer_idurl_bin = id_url.field(
customer_idurl_bin).to_bin()
if latest_customer_idurl_bin != customer_idurl_bin:
all_meta_info[
latest_customer_idurl_bin] = all_meta_info.pop(
customer_idurl_bin)
meta_info_changed = True
lg.info(
'found customer idurl rotated in customers meta info : %r -> %r'
% (
latest_customer_idurl_bin,
customer_idurl_bin,
))
if meta_info_changed:
contactsdb.write_customers_meta_info_all(all_meta_info)
# update customer idurl in "space" file
space_dict, free_space = accounting.read_customers_quotas()
space_changed = False
for customer_idurl_bin in list(space_dict.keys()):
if id_url.is_cached(old_idurl) and id_url.is_cached(
customer_idurl_bin):
if id_url.field(customer_idurl_bin) == old_idurl:
latest_customer_idurl_bin = id_url.field(
customer_idurl_bin).to_bin()
if latest_customer_idurl_bin != customer_idurl_bin:
space_dict[latest_customer_idurl_bin] = space_dict.pop(
customer_idurl_bin)
space_changed = True
lg.info(
'found customer idurl rotated in customer quotas dictionary : %r -> %r'
% (
latest_customer_idurl_bin,
customer_idurl_bin,
))
if space_changed:
accounting.write_customers_quotas(space_dict, free_space)
# rename customer folder where I store all his files
old_customer_dirname = str(global_id.UrlToGlobalID(evt.data['old_idurl']))
new_customer_dirname = str(global_id.UrlToGlobalID(evt.data['new_idurl']))
customers_dir = settings.getCustomersFilesDir()
old_owner_dir = os.path.join(customers_dir, old_customer_dirname)
new_owner_dir = os.path.join(customers_dir, new_customer_dirname)
if os.path.isdir(old_owner_dir):
try:
bpio.move_dir_recursive(old_owner_dir, new_owner_dir)
lg.info('copied %r into %r' % (
old_owner_dir,
new_owner_dir,
))
if os.path.exists(old_owner_dir):
bpio._dir_remove(old_owner_dir)
lg.warn('removed %r' % old_owner_dir)
except:
lg.exc()
# update customer idurl in "spaceused" file
local_tester.TestSpaceTime()
return True
def request(self, json_payload, newpacket, info):
from twisted.internet import reactor # @UnresolvedImport
from logs import lg
from main import events
from crypt import my_keys
from p2p import p2p_service
from contacts import contactsdb
from storage import accounting
from userid import global_id
customer_idurl = newpacket.OwnerID
customer_id = global_id.UrlToGlobalID(customer_idurl)
bytes_for_customer = 0
try:
bytes_for_customer = int(json_payload['needed_bytes'])
except:
lg.warn("wrong payload" % newpacket.Payload)
return p2p_service.SendFail(newpacket, 'wrong payload')
try:
customer_public_key = json_payload['customer_public_key']
customer_public_key_id = customer_public_key['key_id']
except:
customer_public_key = None
customer_public_key_id = None
data_owner_idurl = None
target_customer_idurl = None
family_position = json_payload.get('position')
ecc_map = json_payload.get('ecc_map')
family_snapshot = json_payload.get('family_snapshot')
key_id = json_payload.get('key_id')
target_customer_id = json_payload.get('customer_id')
if key_id:
# this is a request from external user to access shared data stored by one of my customers
# this is "second" customer requesting data from "first" customer
if not key_id or not my_keys.is_valid_key_id(key_id):
lg.warn('missed or invalid key id')
return p2p_service.SendFail(newpacket, 'invalid key id')
target_customer_idurl = global_id.GlobalUserToIDURL(
target_customer_id)
if not contactsdb.is_customer(target_customer_idurl):
lg.warn("target user %s is not a customer" %
target_customer_id)
return p2p_service.SendFail(newpacket, 'not a customer')
if target_customer_idurl == customer_idurl:
lg.warn('customer %s requesting shared access to own files' %
customer_idurl)
return p2p_service.SendFail(newpacket, 'invalid case')
if not my_keys.is_key_registered(key_id):
lg.warn('key not registered: %s' % key_id)
p2p_service.SendFail(newpacket, 'key not registered')
return False
data_owner_idurl = my_keys.split_key_id(key_id)[1]
if data_owner_idurl != target_customer_idurl and data_owner_idurl != customer_idurl:
# pretty complex scenario:
# external customer requesting access to data which belongs not to that customer
# this is "third" customer accessing data belongs to "second" customer
# TODO: for now just stop it
lg.warn(
'under construction, key_id=%s customer_idurl=%s target_customer_idurl=%s'
% (
key_id,
customer_idurl,
target_customer_idurl,
))
p2p_service.SendFail(newpacket, 'under construction')
return False
# do not create connection with that customer, only accept the request
lg.info(
'external customer %s requested access to shared data at %s' %
(
customer_id,
key_id,
))
return p2p_service.SendAck(newpacket, 'accepted')
# key_id is not present in the request:
# this is a request to connect new customer (or reconnect existing one) to that supplier
if not bytes_for_customer or bytes_for_customer < 0:
lg.warn("wrong payload : %s" % newpacket.Payload)
return p2p_service.SendFail(newpacket, 'wrong storage value')
current_customers = contactsdb.customers()
if accounting.check_create_customers_quotas():
lg.out(6, 'service_supplier.request created a new space file')
space_dict = accounting.read_customers_quotas()
try:
free_bytes = int(space_dict[b'free'])
except:
lg.exc()
return p2p_service.SendFail(newpacket, 'broken space file')
if (customer_idurl not in current_customers
and customer_idurl in list(space_dict.keys())):
lg.warn("broken space file")
return p2p_service.SendFail(newpacket, 'broken space file')
if (customer_idurl in current_customers
and customer_idurl not in list(space_dict.keys())):
lg.warn("broken customers file")
return p2p_service.SendFail(newpacket, 'broken customers file')
if customer_idurl in current_customers:
free_bytes += int(space_dict.get(customer_idurl, 0))
space_dict[b'free'] = free_bytes
current_customers.remove(customer_idurl)
space_dict.pop(customer_idurl)
new_customer = False
else:
new_customer = True
lg.out(
8, ' new_customer=%s current_allocated_bytes=%s' % (
new_customer,
space_dict.get(customer_idurl),
))
from supplier import local_tester
if free_bytes <= bytes_for_customer:
contactsdb.update_customers(current_customers)
contactsdb.remove_customer_meta_info(customer_idurl)
contactsdb.save_customers()
accounting.write_customers_quotas(space_dict)
if customer_public_key_id:
my_keys.erase_key(customer_public_key_id)
reactor.callLater(
0, local_tester.TestUpdateCustomers) # @UndefinedVariable
if new_customer:
lg.out(
8,
" NEW CUSTOMER: DENIED !!!!!!!!!!! not enough space available"
)
events.send('new-customer-denied', dict(idurl=customer_idurl))
else:
lg.out(
8,
" OLD CUSTOMER: DENIED !!!!!!!!!!! not enough space available"
)
events.send('existing-customer-denied',
dict(idurl=customer_idurl))
return p2p_service.SendAck(newpacket, 'deny')
space_dict[b'free'] = free_bytes - bytes_for_customer
current_customers.append(customer_idurl)
space_dict[customer_idurl] = bytes_for_customer
contactsdb.update_customers(current_customers)
contactsdb.save_customers()
contactsdb.add_customer_meta_info(
customer_idurl, {
'ecc_map': ecc_map,
'position': family_position,
'family_snapshot': family_snapshot,
})
accounting.write_customers_quotas(space_dict)
if customer_public_key_id:
my_keys.erase_key(customer_public_key_id)
try:
if not my_keys.is_key_registered(customer_public_key_id):
key_id, key_object = my_keys.read_key_info(
customer_public_key)
if not my_keys.register_key(key_id, key_object):
lg.err('failed to register customer public key')
except:
lg.exc()
else:
lg.warn('customer public key was not provided in the request')
reactor.callLater(
0, local_tester.TestUpdateCustomers) # @UndefinedVariable
if new_customer:
lg.out(
8,
" NEW CUSTOMER: ACCEPTED %s family_position=%s ecc_map=%s allocated_bytes=%s"
%
(customer_idurl, family_position, ecc_map, bytes_for_customer))
lg.out(
8,
" family_snapshot=%r !!!!!!!!!!!!!!" % family_snapshot,
)
events.send(
'new-customer-accepted',
dict(
idurl=customer_idurl,
allocated_bytes=bytes_for_customer,
ecc_map=ecc_map,
position=family_position,
family_snapshot=family_snapshot,
key_id=customer_public_key_id,
))
else:
lg.out(
8,
" OLD CUSTOMER: ACCEPTED %s family_position=%s ecc_map=%s allocated_bytes=%s"
%
(customer_idurl, family_position, ecc_map, bytes_for_customer))
lg.out(
8,
" family_snapshot=%r !!!!!!!!!!!!!!" % family_snapshot)
events.send(
'existing-customer-accepted',
dict(
idurl=customer_idurl,
allocated_bytes=bytes_for_customer,
ecc_map=ecc_map,
position=family_position,
key_id=customer_public_key_id,
family_snapshot=family_snapshot,
))
return p2p_service.SendAck(newpacket, 'accepted')
def request(self, json_payload, newpacket, info):
from twisted.internet import reactor
from logs import lg
from main import events
from crypt import my_keys
from p2p import p2p_service
from contacts import contactsdb
from storage import accounting
bytes_for_customer = None
try:
bytes_for_customer = json_payload['needed_bytes']
except:
lg.warn("wrong payload" % newpacket.Payload)
return p2p_service.SendFail(newpacket, 'wrong payload')
try:
customer_public_key = json_payload['customer_public_key']
customer_public_key_id = customer_public_key['key_id']
except:
customer_public_key = None
customer_public_key_id = None
if not bytes_for_customer or bytes_for_customer < 0:
lg.warn("wrong payload : %s" % newpacket.Payload)
return p2p_service.SendFail(newpacket, 'wrong storage value')
current_customers = contactsdb.customers()
if accounting.check_create_customers_quotas():
lg.out(6, 'service_supplier.request created a new space file')
space_dict = accounting.read_customers_quotas()
try:
free_bytes = int(space_dict['free'])
except:
lg.exc()
return p2p_service.SendFail(newpacket, 'broken space file')
if (newpacket.OwnerID not in current_customers
and newpacket.OwnerID in space_dict.keys()):
lg.warn("broken space file")
return p2p_service.SendFail(newpacket, 'broken space file')
if (newpacket.OwnerID in current_customers
and newpacket.OwnerID not in space_dict.keys()):
lg.warn("broken customers file")
return p2p_service.SendFail(newpacket, 'broken customers file')
if newpacket.OwnerID in current_customers:
free_bytes += int(space_dict[newpacket.OwnerID])
space_dict['free'] = free_bytes
current_customers.remove(newpacket.OwnerID)
space_dict.pop(newpacket.OwnerID)
new_customer = False
else:
new_customer = True
from supplier import local_tester
if free_bytes <= bytes_for_customer:
contactsdb.update_customers(current_customers)
contactsdb.save_customers()
accounting.write_customers_quotas(space_dict)
if customer_public_key_id:
my_keys.erase_key(customer_public_key_id)
reactor.callLater(0, local_tester.TestUpdateCustomers)
if new_customer:
lg.out(
8,
" NEW CUSTOMER: DENIED !!!!!!!!!!! not enough space available"
)
events.send('new-customer-denied',
dict(idurl=newpacket.OwnerID))
else:
lg.out(
8,
" OLD CUSTOMER: DENIED !!!!!!!!!!! not enough space available"
)
events.send('existing-customer-denied',
dict(idurl=newpacket.OwnerID))
return p2p_service.SendAck(newpacket, 'deny')
space_dict['free'] = free_bytes - bytes_for_customer
current_customers.append(newpacket.OwnerID)
space_dict[newpacket.OwnerID] = bytes_for_customer
contactsdb.update_customers(current_customers)
contactsdb.save_customers()
accounting.write_customers_quotas(space_dict)
if customer_public_key_id:
my_keys.erase_key(customer_public_key_id)
try:
if not my_keys.is_key_registered(customer_public_key_id):
key_id, key_object = my_keys.read_key_info(
customer_public_key)
if not my_keys.register_key(key_id, key_object):
lg.warn('failed to register customer public key')
except:
lg.exc()
else:
lg.warn('customer public key was not provided in the request')
reactor.callLater(0, local_tester.TestUpdateCustomers)
if new_customer:
lg.out(8, " NEW CUSTOMER: ACCEPTED !!!!!!!!!!!!!!")
events.send('new-customer-accepted', dict(idurl=newpacket.OwnerID))
else:
lg.out(8, " OLD CUSTOMER: ACCEPTED !!!!!!!!!!!!!!")
events.send('existing-customer-accepted',
dict(idurl=newpacket.OwnerID))
return p2p_service.SendAck(newpacket, 'accepted')
def request(self, request, info):
from main import events
from p2p import p2p_service
words = request.Payload.split(' ')
try:
bytes_for_customer = int(words[1])
except:
lg.exc()
bytes_for_customer = None
if not bytes_for_customer or bytes_for_customer < 0:
lg.warn("wrong storage value : %s" % request.Payload)
return p2p_service.SendFail(request, 'wrong storage value')
current_customers = contactsdb.customers()
if accounting.check_create_customers_quotas():
lg.out(6, 'service_supplier.request created a new space file')
space_dict = accounting.read_customers_quotas()
try:
free_bytes = int(space_dict['free'])
except:
lg.exc()
return p2p_service.SendFail(request, 'broken space file')
if (request.OwnerID not in current_customers and request.OwnerID in space_dict.keys()):
lg.warn("broken space file")
return p2p_service.SendFail(request, 'broken space file')
if (request.OwnerID in current_customers and request.OwnerID not in space_dict.keys()):
lg.warn("broken customers file")
return p2p_service.SendFail(request, 'broken customers file')
if request.OwnerID in current_customers:
free_bytes += int(space_dict[request.OwnerID])
space_dict['free'] = free_bytes
current_customers.remove(request.OwnerID)
space_dict.pop(request.OwnerID)
new_customer = False
else:
new_customer = True
from supplier import local_tester
if free_bytes <= bytes_for_customer:
contactsdb.update_customers(current_customers)
contactsdb.save_customers()
accounting.write_customers_quotas(space_dict)
reactor.callLater(0, local_tester.TestUpdateCustomers)
if new_customer:
lg.out(8, " NEW CUSTOMER: DENIED !!!!!!!!!!! not enough space available")
events.send('new-customer-denied', dict(idurl=request.OwnerID))
else:
lg.out(8, " OLD CUSTOMER: DENIED !!!!!!!!!!! not enough space available")
events.send('existing-customer-denied', dict(idurl=request.OwnerID))
return p2p_service.SendAck(request, 'deny')
space_dict['free'] = free_bytes - bytes_for_customer
current_customers.append(request.OwnerID)
space_dict[request.OwnerID] = bytes_for_customer
contactsdb.update_customers(current_customers)
contactsdb.save_customers()
accounting.write_customers_quotas(space_dict)
reactor.callLater(0, local_tester.TestUpdateCustomers)
if new_customer:
lg.out(8, " NEW CUSTOMER: ACCEPTED !!!!!!!!!!!!!!")
events.send('new-customer-accepted', dict(idurl=request.OwnerID))
else:
lg.out(8, " OLD CUSTOMER: ACCEPTED !!!!!!!!!!!!!!")
events.send('existing-customer-accepted', dict(idurl=request.OwnerID))
return p2p_service.SendAck(request, 'accepted')