def processor_macro_block_body_write(self, content):
try:
macro_block_body = MacroBlockBody.unpack(content)
except Exception:
_ = send_handler(MsgType.TYPE_RESPONSE_ERROR,
b'macro_block_body unpack error')
else:
result = self.server.macro_chain.add_macro_block_body(
macro_block_body)
if result:
if macro_block_body in self.server.cached_macro_block_body:
self.server.cached_macro_block_body.remove(
macro_block_body)
_ = send_handler(MsgType.TYPE_RESPONSE_OK, b'')
else:
print('failed1', macro_block_body.hash)
if self.server.macro_chain.accepted_macro_block_bodies[
macro_block_body.hash] >= 1:
print('pass')
else:
self.server.cached_macro_block_body.append(
macro_block_body)
_ = send_handler(MsgType.TYPE_RESPONSE_ERROR, b'')
finally:
self.request.sendall(_)
def processor_macro_block_header_write(self, content):
try:
macro_block_header = MacroBlockHeader.unpack(content)
print('add macro block', macro_block_header.hash, macro_block_header.public_key_hash)
except Exception:
_ = send_handler(MsgType.TYPE_RESPONSE_ERROR, b'macro_block_header unpack error')
else:
result = self.server.macro_chain.add_macro_block_header(macro_block_header)
if self.server.macro_chain.accepted_macro_block_headers[macro_block_header.hash] == 1:
for i in self.server.cached_macro_block_body:
if i.hash == macro_block_header.hash:
self.parentless_macro_block_body_process(i)
if result:
for i in self.server.cached_macro_block_header:
if macro_block_header.hash in i.parent_hash:
self.parentless_macro_block_header_process()
_ = send_handler(MsgType.TYPE_RESPONSE_OK, b'')
else:
print('failed1', macro_block_header.hash)
if self.server.macro_chain.accepted_macro_block_headers[macro_block_header.hash] > 1:
print('pass')
else:
if macro_block_header not in self.server.cached_macro_block_header:
self.server.cached_macro_block_header.append(macro_block_header)
_ = send_handler(MsgType.TYPE_RESPONSE_ERROR, b'')
finally:
self.request.sendall(_)
def processor_trans_make(self, content):
i_ = 0
# add_from = random.randint(0, 1)
add_from = 0
if add_from > 2:
add_from = 0
add_to = 0
add_to_two = random.randint(0, 1)
_address = [add_from, add_to, add_to_two]
result = dict()
# print(_address)
fd = open('ad1.txt', 'r')
line = fd.readlines()
for i in _address:
line_ = line[i].rstrip()
pr, pu = line_.split('ENDDING')
temp = bytes(pu[2:-1], encoding='utf-8')
temp = temp.replace(b'\r\n', b'\n')
public_key = temp.replace(b'\\n', b'\n')
temp = bytes(pr[2:-1], encoding='utf-8')
temp = temp.replace(b'\r\n', b'\n')
private_key = temp.replace(b'\\n', b'\n')
sha = hashlib.sha256()
sha.update(public_key)
public_key_hash = sha.digest()
result[i] = [public_key, private_key, public_key_hash]
fd.close()
for utxo in self.server.blockchain.utxo.utxo.items():
if utxo[1]['to'] == result[_address[0]][2] and utxo[0] not in self.server.Used:
self.server.Used.append(utxo[0])
# print('1')
i_ = 1
private_key = serialization.load_pem_private_key(result[_address[0]][1], None,
backend=default_backend())
ipt = TransInput([utxo[0]], result[_address[0]][2])
opt = TransOutput([(utxo[1]['amount']/2, result[_address[1]][2]), (utxo[1]['amount']/2,
result[_address[2]][2])])
tran = Transaction(ipt, opt)
tran.ready(private_key)
content = trans_to_json(tran)
requests.post('http://127.0.0.1:23390/transaction_post', data=content)
requests.post('http://127.0.0.1:23391/transaction_post', data=content)
if result[_address[0]][2] in self.server.Address.keys():
self.server.Address[result[_address[0]][2]][0] -= len(tran.b) \
* self.server.throughput / (1000 * 2 * 4)
self.server.Address[result[_address[0]][2]][1] = time.time()
else:
self.server.Address[result[_address[0]][2]] = [100, time.time()]
_ = send_handler(MsgType.TYPE_RESPONSE_OK, tran.b)
self.request.sendall(_)
break
if i_ == 0:
# print('0')
_ = send_handler(MsgType.TYPE_RESPONSE_ERROR, b'')
self.request.sendall(_)
else:
pass
def processor_micro_block_write(self, content):
try:
micro_block = MicroBlock.unpack(content)
except Exception:
_ = send_handler(MsgType.TYPE_RESPONSE_ERROR,
b'micro_block unpack error')
else:
result = self.server.macro_chain.add_micro_block(micro_block)
if result:
# c = 0
# for i in self.server.macro_chain.micro_block_pool:
# c += sys.getsizeof(i.b)
for i_ in self.server.cached_macro_block_body:
if micro_block.hash in i_.ref_hash:
self.parentless_macro_block_body_process(i_)
for i in micro_block.data.trans:
if i.txid not in self.server.transpool.used:
self.server.transpool.used.append(i.txid)
_ = send_handler(MsgType.TYPE_RESPONSE_OK, b'')
else:
# print('failed1', micro_block.hash)
if self.server.macro_chain.accepted_micro_blocks[
micro_block.hash] >= 1:
# print('pass')
pass
else:
pass
_ = send_handler(MsgType.TYPE_RESPONSE_ERROR, b'')
finally:
self.request.sendall(_)
def processor_micro_block_write(self, content):
try:
micro_block = MicroBlock.unpack(content)
except Exception:
_ = send_handler(MsgType.TYPE_RESPONSE_ERROR,
b'micro_block unpack error')
else:
result = self.server.macro_chain.add_micro_block(micro_block)
if result:
c = 0
for i in self.server.macro_chain.micro_block_pool:
c += sys.getsizeof(i.b)
for i_ in self.server.cached_macro_block_body:
if micro_block.hash in i_.ref_hash:
self.parentless_macro_block_body_process(i_)
print("chain length1 = ",
self.server.macro_chain.micro_block_num + 1)
print('real length = ',
len(self.server.macro_chain.micro_block_pool))
_ = send_handler(MsgType.TYPE_RESPONSE_OK, b'')
else:
print('failed1', micro_block.hash)
if self.server.macro_chain.accepted_micro_blocks[
micro_block.hash] >= 1:
print('pass')
else:
pass
_ = send_handler(MsgType.TYPE_RESPONSE_ERROR, b'')
finally:
self.request.sendall(_)
def processor_block_write(self, content):
with self.server.mutex:
a = time.time()
try:
block = Block.unpack(content)
except Exception:
_ = send_handler(MsgType.TYPE_RESPONSE_ERROR, b'block unpack error')
else:
print('receive block', block.hash, block.data.attachment.content, a)
result = self.server.blockchain.add_block(block)
# self.server.Trans_num += len(block.data.trans)
# for trans in block.data.trans:
# self.server.Trans_size += sys.getsizeof(trans.txid)
# print('trans_num = ', self.server.Trans_num)
# print('trans_size = ', self.server.Trans_size)
# c = 0
# for block in self.server.blockchain.chain.queue:
# c += sys.getsizeof(block.b)
# print(c)
# print(self.server.blockchain.size_)
# print('nnn')
print(result)
if result:
print("chain length1 = ", self.server.blockchain.length + 1)
print('real length = ', len(self.server.blockchain.chain.queue))
self.server.transpool.remove(block)
self.parentless_block_process()
_ = send_handler(MsgType.TYPE_RESPONSE_OK, b'')
else:
print('failed1', block.hash)
if block.hash in self.server.blockchain.accepted_blocks_hash or \
self.server.blockchain.accepted_blocks[block.hash] > 1:
print('pass')
print(block.hash)
print(self.server.blockchain.accepted_blocks[block.hash])
else:
print('\nin\n')
for i in self.server.ass_chain:
if block.previous_hash == i.hash:
flag = 1
self.server.ass_chain[block] = (flag, i)
self.longest_chain(block)
break
for i in self.server.blockchain.chain.queue:
if block.previous_hash == i.hash:
flag = 0
self.server.ass_chain[block] = (flag, i)
break
if block not in self.server.cache and block not in self.server.ass_chain.keys():
self.server.cache.append(block)
_ = send_handler(MsgType.TYPE_RESPONSE_ERROR, b'')
finally:
self.request.sendall(_)
print('all end', a)
def processor_trans_read(self, content):
result = self.server.transpool.read_serialized()
if len(result) > 0:
_ = send_handler(MsgType.TYPE_RESPONSE_OK, batch_handler(result))
else:
_ = send_handler(MsgType.TYPE_RESPONSE_ERROR, b'')
self.request.sendall(_)
def processor_trans_search_txid(self, content):
try:
trans = self.server.blockchain.search_transaction(content)
except TransNotInChain:
_ = send_handler(MsgType.TYPE_RESPONSE_ERROR, b'')
else:
_ = send_handler(MsgType.TYPE_RESPONSE_OK, trans.b)
finally:
self.request.sendall(_)
def processor_trans_make(self, content):
i_ = 0
add_from = 0
add_to = 2
add_to_two = random.randint(0, 1)
_address = [add_from, add_to, add_to_two]
result = dict()
# print(_address)
fd = open('ad1.txt', 'r')
line = fd.readlines()
for i in _address:
line_ = line[i].rstrip()
pr, pu = line_.split('ENDDING')
temp = bytes(pu[2:-1], encoding='utf-8')
temp = temp.replace(b'\r\n', b'\n')
public_key = temp.replace(b'\\n', b'\n')
temp = bytes(pr[2:-1], encoding='utf-8')
temp = temp.replace(b'\r\n', b'\n')
private_key = temp.replace(b'\\n', b'\n')
sha = hashlib.sha256()
sha.update(public_key)
public_key_hash = sha.digest()
result[i] = [public_key, private_key, public_key_hash]
fd.close()
for utxo in self.server.macro_chain.utxo.utxo.items():
if utxo[1]['to'] == result[_address[0]][2] and utxo[0] not in self.server.Used:
self.server.Used.append(utxo[0])
# print('utxo', utxo)
i_ = 1
private_key = serialization.load_pem_private_key(result[_address[0]][1], None,
backend=default_backend())
ipt = TransInput([utxo[0]], result[_address[0]][2])
opt = TransOutput([(utxo[1]['amount']/2, result[_address[1]][2]), (utxo[1]['amount']/2,
result[_address[2]][2])])
tran = Transaction(ipt, opt)
tran.ready(private_key)
content = trans_to_json(tran)
requests.post('http://129.211.110.239:8000/transaction_post', data=content)
requests.post('http://129.211.112.165:8000/transaction_post', data=content)
requests.post('http://129.211.108.22:8000/transaction_post', data=content)
requests.post('http://129.211.107.98:8000/transaction_post', data=content)
requests.post('http://129.211.112.210:8000/transaction_post', data=content)
requests.post('http://212.129.128.25:8000/transaction_post', data=content)
requests.post('http://129.211.112.110:8000/transaction_post', data=content)
requests.post('http://129.211.108.179:8000/transaction_post', data=content)
requests.post('http://129.211.112.247:8000/transaction_post', data=content)
requests.post('http://212.64.102.86:8000/transaction_post', data=content)
_ = send_handler(MsgType.TYPE_RESPONSE_OK, tran.b)
self.request.sendall(_)
break
if i_ == 0:
_ = send_handler(MsgType.TYPE_RESPONSE_ERROR, b'')
self.request.sendall(_)
else:
pass
def processor_trans_write(self, content):
result = self.server.transpool.add(content)
if result:
_ = send_handler(MsgType.TYPE_RESPONSE_OK, b'')
else:
print('false')
_ = send_handler(MsgType.TYPE_RESPONSE_ERROR, b'')
self.request.sendall(_)
def processor_macro_block_header_write(self, content) -> bool:
flag_ = False
try:
macro_block_header = MacroBlockHeader.unpack(content)
except Exception:
_ = send_handler(MsgType.TYPE_RESPONSE_ERROR,
b'macro_block_header unpack error')
else:
result = self.server.macro_chain.add_macro_block_header(
macro_block_header)
if self.server.macro_chain.accepted_macro_block_headers[
macro_block_header.hash] == 1:
for i in self.server.cached_macro_block_body:
if i.hash == macro_block_header.hash:
self.parentless_macro_block_body_process(i)
if result:
for i in self.server.cached_macro_block_header:
if macro_block_header.hash in i.parent_hash:
self.parentless_macro_block_header_process()
_ = send_handler(MsgType.TYPE_RESPONSE_OK, b'')
flag_ = True
else:
print('failed1', macro_block_header.hash)
if macro_block_header.hash in self.server.macro_chain.accepted_macro_block_header_hash or \
self.server.macro_chain.accepted_macro_block_headers[macro_block_header.hash] > 1:
print('pass')
else:
for i in self.server.ass_chain:
if macro_block_header.parent_hash[0] == i.hash:
flag = 1
self.server.ass_chain[macro_block_header] = (flag,
i)
self.longest_chain(macro_block_header)
flag_ = True
break
for i in self.server.macro_chain.chain_.queue:
if macro_block_header.parent_hash[0] == i.hash:
flag = 0
self.server.ass_chain[macro_block_header] = (flag,
i)
flag_ = True
break
if macro_block_header not in self.server.cached_macro_block_header and macro_block_header not in \
self.server.ass_chain.keys():
self.server.cached_macro_block_header.append(
macro_block_header)
_ = send_handler(MsgType.TYPE_RESPONSE_ERROR, b'')
finally:
self.request.sendall(_)
return flag_
def processor_trans_write(self, content):
result = self.server.transpool.add(content)
print(len(self.server.transpool.chain.chain.queue))
# tran = Transaction.unpack(content)
# print(tran.show_trans())
# print('ok3')
if result:
_ = send_handler(MsgType.TYPE_RESPONSE_OK, b'')
else:
_ = send_handler(MsgType.TYPE_RESPONSE_ERROR, b'')
self.request.sendall(_)
def create(self):
print('ok')
while True:
try:
# sleep for the remaining seconds of interval
print('ok')
with socket.socket(socket.AF_UNIX, socket.SOCK_STREAM) as s:
s.connect(self.chainbase_address)
s.sendall(send_handler(MsgType.TYPE_TRANS_MAKE, b''))
*_, msgtype, content = recv_parser(s)
print('content')
print(content)
if content == b'':
time.sleep(0.1)
else:
sha = hashlib.sha256()
sha.update(content[BLENGTH_TXID:])
print(content[:BLENGTH_TXID])
print('sha')
print(sha.digest())
time.sleep(0.01)
except Exception as e:
print('error')
time.sleep(0.1)
finally:
pass
def processor_trans_write(self, content):
result = self.server.transpool.add(content)
tran = Transaction.unpack(content)
# print(tran.show_trans())
# print('ok3')
if result:
a = Transaction.unpack(content)
_ = send_handler(MsgType.TYPE_RESPONSE_OK, b'')
# print('trans_received')
# print(a.timestamp)
# print(time.time())
# print(len(self.server.transpool.trans.queue))
else:
_ = send_handler(MsgType.TYPE_RESPONSE_ERROR, b'')
self.request.sendall(_)
def processor_get_parent_hash(self, content):
content = self.server.macro_chain.pivot_chain.queue[-1]
for i in self.server.macro_chain.tips:
if i != self.server.macro_chain.pivot_chain.queue[-1]:
content += i
self.request.sendall(send_handler(MsgType.TYPE_RESPONSE_OK, content))
def create(self):
print('ok')
while True:
try:
# sleep for the remaining seconds of interval
print('ok')
with socket.socket(socket.AF_UNIX, socket.SOCK_STREAM) as s:
s.connect(self.chainbase_address)
s.sendall(send_handler(MsgType.TYPE_TRANS_MAKE, b''))
*_, msgtype, content = recv_parser(s)
print('content')
print(content)
if content == b'':
time.sleep(0.001)
pass
else:
sha = hashlib.sha256()
sha.update(content[BLENGTH_TXID:])
print(content[:BLENGTH_TXID])
print('sha')
print(sha.digest())
# content = Transaction.unpack(content)
# content = trans_to_json(content)
# r = requests.post('http://127.0.0.1:23390/transaction_post', data=content)
# q = requests.post('http://127.0.0.1:23391/transaction_post', data=content)
# print(r.text)
# print(q.text)
time.sleep(0.01)
except Exception as e:
print('error')
time.sleep(0.01)
finally:
pass
def transaction():
if request.method == 'GET':
return r'<!DOCTYPE html><html><body><form action="/transaction" method=POST>' \
r'To:<br><input type="text" name="to" value=""><br>Amount:<br><input ' \
r'type="text" name="amount" value="" pattern="+[0-9]"><br>Private Key:<br><textarea rows="4" ' \
r'cols="20" name="prikey" value=""></textarea><br>Input(TxID,index;):<br><textarea rows="4" cols="20" ' \
r'name="input" value=""></textarea><br><input type="submit" value="Submit"></form> </body></html>'
else:
receiver = request.form['to']
amount = int(request.form['amount'])
prikey = request.form['prikey'].encode()
ipt = request.form['input']
ipt, index = ipt.split(',')
ipt = unhexlify(ipt)
index = int(index)
prikey = prikey.replace(b'\r\n', b'\n')
prikey = prikey.replace(b'\\n', b'\n')
private_key = load_pem_private_key(prikey, None, default_backend())
public_key = private_key.public_key()
serialized_public = public_key.public_bytes(
encoding=Encoding.PEM, format=PublicFormat.SubjectPublicKeyInfo)
sha = hashlib.sha256()
sha.update(serialized_public)
public_key_hash = sha.digest()
t_input = TransInput([(TXID(ipt), OUTPUT_INDEX(index))],
public_key_hash)
t_output = TransOutput([(ASSET(amount),
PUBLIC_KEY_HASH(unhexlify(receiver)))])
trans = Transaction(t_input, t_output)
trans.ready(private_key)
result = trans_to_json(trans)
fd = open('peer.txt', 'r')
for line in fd.readlines():
if line != '\n':
print('http://' + line.rstrip() + '/transaction_post')
r = requests.post('http://' + line.rstrip() +
'/transaction_post',
data=result)
print(r.text)
fd.close()
with socket.socket(
socket.AF_UNIX,
socket.SOCK_STREAM) as s: # submit the valid transaction
s.connect(chainbase_address)
s.sendall(send_handler(MsgType.TYPE_TRANS_WRITE, trans.b))
*_, msgtype, content = recv_parser(s)
if msgtype == MsgType.TYPE_RESPONSE_OK:
return 'ok'
else:
print(trans.show_trans())
return 'error'
def test_004_previous_hash(self):
with socket.socket(socket.AF_UNIX, socket.SOCK_STREAM) as s:
s.connect(self.address)
s.sendall(send_handler(MsgType.TYPE_BLOCK_PREVIOUS_HASH, b''))
header, length, msgtype, content = recv_parser(s)
self.assertEqual(msgtype, MsgType.TYPE_RESPONSE_OK)
self.assertEqual(len(content), 32)
print(content)
def init_prev_hash(self):
"""get previous hash from chainbase when initializing"""
with socket.socket(socket.AF_UNIX, socket.SOCK_STREAM) as s:
s.connect(self.chainbase_address)
s.sendall(send_handler(MsgType.TYPE_BLOCK_PREVIOUS_HASH, b''))
*_, msgtype, content = recv_parser(s)
self.prev_hash = content
print('prev_hash = ', content)
def processor_block_read(self, content):
start = bin2int(content[:4])
end = bin2int(content[4:8])
# do the search
result = []
for i in range(start, end):
# if start <= server.blockchain.chain.queue[i].index <= end:
result.append(self.server.blockchain.chain.queue[i].b)
# send back result
self.request.sendall(send_handler(MsgType.TYPE_RESPONSE_OK, batch_handler(result)))
def test_002_trans_read(self):
with socket.socket(socket.AF_UNIX, socket.SOCK_STREAM) as s:
s.connect(self.address)
s.sendall(send_handler(MsgType.TYPE_TRANS_READ, b''))
header, length, msgtype, content = recv_parser(s)
content = batch_parser(content)
for i in content:
Transaction.unpack(i)
self.assertEqual(msgtype, MsgType.TYPE_RESPONSE_OK)
self.assertEqual(len(content), 2)
def put_miner_use(self, usage, useful) -> List:
with socket.socket(socket.AF_UNIX, socket.SOCK_STREAM) as s:
s.connect(self.chainbase_address)
s.sendall(
send_handler(
MsgType.TYPE_MINER_USE,
batch_handler(
[struct.pack('=d', usage),
struct.pack('=d', useful)])))
*_, msgtype, content = recv_parser(s)
result = batch_parser(content)
return result
def add_block(self, block: Block) -> bool:
"""
add the block to the chainbase
:param block: binary block
:return: True | False
"""
with socket.socket(socket.AF_UNIX, socket.SOCK_STREAM) as s:
s.connect(self.chainbase_address)
s.sendall(send_handler(MsgType.TYPE_BLOCK_WRITE, block.b))
*_, msgtype, content = recv_parser(s)
return msgtype == MsgType.TYPE_RESPONSE_OK
def __get_trans(self) -> List[Transaction]:
# self.chainbase_address
with socket.socket(socket.AF_UNIX, socket.SOCK_STREAM) as s:
s.connect(self.chainbase_address)
s.sendall(send_handler(MsgType.TYPE_TRANS_READ, b''))
*_, msgtype, content = recv_parser(s)
trans = [] # todo: the first transaction should reward the miner,
# todo: the server may have a property named owner_address
if msgtype == MsgType.TYPE_RESPONSE_OK:
trans += batch_parser(content)
return [Transaction.unpack(t) for t in trans]
def block():
start = request.args.get('start', type=int)
end = request.args.get('end', type=int)
with socket.socket(socket.AF_UNIX, socket.SOCK_STREAM) as s:
s.connect(chainbase_address)
s.sendall(
send_handler(MsgType.TYPE_BLOCK_READ,
struct.pack('=i', start) + struct.pack('=i', end)))
*_, msgtype, content = recv_parser(s)
content = batch_parser(content)
block = [Block.unpack(i).show_block() for i in content]
return jsonify(block)
def add_macro_block_body(self, macro_block_body: MacroBlockBody) -> bool:
"""
add the macro_block_body to the chainbase
:param macro_block_body: binary macro_block_body
:return: True | False
"""
with socket.socket(socket.AF_UNIX, socket.SOCK_STREAM) as s:
s.connect(self.chainbase_address)
s.sendall(
send_handler(MsgType.TYPE_MACRO_BLOCK_BODY_WRITE,
macro_block_body.b))
*_, msgtype, content = recv_parser(s)
return msgtype == MsgType.TYPE_RESPONSE_OK
def get_parent_hash(self) -> list:
"""
get pivot chain macro_block_header and tips in local DAG
:return: a list of hash (the first hash refers to voting edge, others refer to reference edges)
"""
with socket.socket(socket.AF_UNIX, socket.SOCK_STREAM) as s:
s.connect(self.chainbase_address)
s.sendall(send_handler(MsgType.TYPE_GET_PARENT_HASH, None))
*_, msgtype, content = recv_parser(s)
result = list()
len_ = int(len(content) / 32)
for i in range(len_):
result.append(content[i * 32:(i + 1) * 32])
return result
def get_miner_credit(self, public_key_hash, num) -> List:
with socket.socket(socket.AF_UNIX, socket.SOCK_STREAM) as s:
s.connect(self.chainbase_address)
p = time.time() * 100000000
print(struct.pack('=d', p))
s.sendall(
send_handler(
MsgType.TYPE_MINER_CREDIT,
batch_handler([
public_key_hash,
struct.pack('=d', num),
struct.pack('=d', p)
])))
*_, msgtype, content = recv_parser(s)
result = batch_parser(content)
return result
def add_macro_block_header(self,
macro_block_header: MacroBlockHeader) -> bool:
"""
add the macro_block_header to the chainbase
:param macro_block_header: binary macro_block_header
:return: True | False
"""
print('in add macro')
with socket.socket(socket.AF_UNIX, socket.SOCK_STREAM) as s:
s.connect(self.chainbase_address)
s.sendall(
send_handler(MsgType.TYPE_MACRO_BLOCK_HEADER_WRITE,
macro_block_header.b))
*_, msgtype, content = recv_parser(s)
return msgtype == MsgType.TYPE_RESPONSE_OK
def transaction_post():
temp = str(request.get_data(), encoding='utf-8')
trans = json_to_trans(temp)
with socket.socket(
socket.AF_UNIX,
socket.SOCK_STREAM) as s: # submit the valid transaction
s.connect(chainbase_address)
s.sendall(send_handler(MsgType.TYPE_TRANS_WRITE, trans.b))
*_, msgtype, content = recv_parser(s)
# print('end.....')
# print(content)
if msgtype == MsgType.TYPE_RESPONSE_OK:
return 'ok'
else:
return 'error'
