def switch_to():
log.write("/method/backup.make: API method does not work, W.I.P.")
return json.dumps({
"bad_response":{
"error": "API method W.I.P."
}
})
def show_transaction_list():
from app import transaction, log
import logging
tx_list = transaction.get_transactions()
if len(tx_list) == 0:
print("No Transaction\n")
main_menu()
else:
for t in tx_list:
log.write(t.message, logging.DEBUG)
main_menu()
def generate_key():
# 공개키, 개인키 생성
pri_key = SigningKey.generate(curve=NIST256p)
pub_key = pri_key.get_verifying_key()
# 생성된 공인키, 개인키를 파일로 생성
open(KEY_PATH + "/private.pem", "w",
encoding='utf-8').write(pri_key.to_pem().decode('utf-8'))
open(KEY_PATH + "/public.pem", "w",
encoding='utf-8').write(pub_key.to_pem().decode('utf-8'))
log.write("New Keys are generated")
def list_all_transaction(): for t in transaction.get_transactions(): time_stamp = datetime.datetime.__str__(t.time_stamp) log.write( "\n++++++++++ Transaction ID: "+ t.tx_id +" ++++++++++" "\nData: "+ t.message + "\n거래시각: "+ time_stamp + "\n공개키: "+ t.pub_key + "\n서명: "+ t.signature + "\n유형: "+ t.type + "\n+++++++++++++++++++++++++++++++++++++++++++++++++++++", logging.DEBUG)
def list_all_block(): for b in block.get_all_block(): time_stamp = datetime.datetime.__str__(b.time_stamp) log.write( "\n======================= Block =======================" "\nBlock Hash: "+ b.block_hash + "\n이전 Block Hash: "+ b.prev_block_hash + "\nBlock 생성시각: "+ time_stamp + "\nNonce: "+ b.nonce + "\n유형: "+ b.type + "\n=====================================================", logging.DEBUG)
def start_communicator(port):
import threading
global port_number
port_number = port
set_my_node(False)
node.key.generate_key()
log.write("Start node")
global listen_thread
listen_thread = threading.Thread(
target=receiver.start,
args=("Listener_Thread",
communicator.my_ip_address.get_ip_address('en0'), port_number))
listen_thread.start()
def exec_command():
if "secret" not in request.args:
log.write("/method/rcon.exec_command: access denied, expected secret")
return json.dumps({
"bad_response":{
"error": "access denied, expected secret"
}
})
if not check_secret(request.args["secret"]):
log.write("/method/rcon.exec_command: access denied, wrong secret value: \"" + request.args["secret"] + "\"")
return json.dumps({
"bad_response":{
"error": "access denied, wrong secret value: \"" + request.args["secret"] + "\""
}
})
if "command" not in request.args or request.args["command"] == "":
log.write("/method/rcon.exec_command: expected command")
return json.dumps({
"bad_response":{
"error": "expected command"
}
})
command = request.args["command"]
# FIXME
# Temporary part to allow web-developer do his job:
console_response = "Unrecognized command \"" + command.split()[0] + "\".\n"
try:
console_history = open("temp_console_history.json", "r")
history = json.load(console_history)
console_history.close()
except IOError:
history = {"msg":[]}
except:
raise
history["msg"].append({
"type":"command",
"timestamp": time.time(),
"command":command,
"console_response":console_response
})
try:
console_history = open("temp_console_history.json", "w")
json.dump(history, console_history, indent=4)
console_history.close()
except:
raise
# End of temporary part
log.write("/method/rcon.exec_command: successful request, successful command execution")
return json.dumps({
"response":{
"command": command,
"console_response": console_response
}
})
def find_node_thread():
# UDP 소켓 생성
sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM,
socket.IPPROTO_UDP)
# 소켓에 브로드캐스트 옵션 설정
sock.setsockopt(socket.SOL_SOCKET, socket.SO_BROADCAST, 1)
# 포트 번호와 로컬 주소에 바인딩
sock.bind(('', PING_PORT_NUMBER))
# zmq라이브러리를 이용해 UDP 소켓을 폴링
poller = zmq.Poller()
poller.register(sock, zmq.POLLIN)
# 실행 시 ping 전송
ping_at = time.time()
while is_running:
# 타이머 설정
timeout = ping_at - time.time()
if timeout < 0:
timeout = 0
try:
events = dict(poller.poll(1000 * timeout))
except KeyboardInterrupt:
log.write("interrupted")
break
# ping 으로부터 응답이 오는 경우 노드 추가
if sock.fileno() in events:
msg, addrinfo = sock.recvfrom(PING_MSG_SIZE)
ip = addrinfo[0]
n = node.Node(ip)
node.add_node(n)
# 일정 주기 마다 브로드캐스트로 ping
if time.time() >= ping_at:
sock.sendto(b'!', 0, ("255.255.255.255", PING_PORT_NUMBER))
ping_at = time.time() + PING_INTERVAL
def get_history():
if "secret" not in request.args:
log.write("/method/rcon.get_history: access denied, expected secret")
return json.dumps({
"bad_response":{
"error": "access denied, expected secret"
}
})
if not check_secret(request.args["secret"]):
log.write("/method/rcon.get_history: access denied, wrong secret value: \"" + request.args["secret"] + "\"")
return json.dumps({
"bad_response":{
"error": "access denied, wrong secret value: \"" + request.args["secret"] + "\""
}
})
# FIXME
# Temporary part to allow web-developer do his job:
try:
console_history = open("temp_console_history.json", "r")
history = json.load(console_history)["msg"]
console_history.close()
except IOError:
history = {"msg":[]}
except:
raise
# End of temporary part
history.sort(key=lambda x: x["timestamp"])
log.write("/method/rcon.get_history: successful request")
return json.dumps({
"response":{
"history": history
}
})
def find_node_thread():
sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM,
socket.IPPROTO_UDP)
sock.setsockopt(socket.SOL_SOCKET, socket.SO_BROADCAST, 1)
sock.bind(('', PING_PORT_NUMBER))
t = threading.Thread(target=find_node_thread)
poller = zmq.Poller()
poller.register(sock, zmq.POLLIN)
ping_at = time.time()
# is_running
while True:
timeout = ping_at - time.time()
if timeout < 0:
timeout = 0
try:
events = dict(poller.poll(1000 * timeout))
except KeyboardInterrupt:
print("interrupted")
break
if sock.fileno() in events:
msg, addrinfo = sock.recvfrom(PING_MSG_SIZE)
ip = addrinfo[0]
n = node.Node(ip)
if node.add_node(n):
# print('Find ' + ip)
log.write('Find ' + ip)
if time.time() >= ping_at:
print('Finding a node...')
sock.sendto(b'!', 0, ("255.255.255.255", PING_PORT_NUMBER))
ping_at = time.time() + PING_INTERVAL
t.start()
def get_cpu_usage():
if "secret" not in request.args:
log.write("/method/stats.get_cpu_usage: access denied, expected secret")
return json.dumps({
"bad_response":{
"error": "access denied, expected secret"
}
})
if not check_secret(request.args["secret"]):
log.write("/method/stats.get_cpu_usage: access denied, wrong secret value: \"" + request.args["secret"] + "\"")
return json.dumps({
"bad_response":{
"error": "access denied, wrong secret value: \"" + request.args["secret"] + "\""
}
})
if "format" not in request.args:
format = "fraction"
elif request.args["format"] not in ["percent", "fraction"]:
log.write("/method/stats.get_cpu_usage: wrong format value")
return json.dumps({
"bad_response":{
"error": "wrong format value, expected \"percent\" or \"fraction\""
}
})
else:
format = request.args["format"]
# FIXME
result = 56.3
log.write("/method/stats.get_cpu_usage: successful request, cpu usage equal to " + result + "%")
if format == "fraction":
result /= 100
return json.dumps({
"response":{
"ram_usage": result,
"format": format
}
})
def start(thread_name, ip_address, port):
import json
addr = (ip_address, port)
buf_size = 1024
# 소켓 생성 및 바인딩
tcp_socket = socket(AF_INET, SOCK_STREAM)
tcp_socket.bind(addr)
tcp_socket.listen(5)
while is_running:
# 요청이 있을 경우 소켓과 송신자의 ip 주소 저장
receive_socket, sender_ip = tcp_socket.accept()
while is_running:
log.write("Receiving")
# 소켓으로부터 버퍼 사이즈씩 데이터 수신
data = receive_socket.recv(buf_size)
try:
# 수신된 데이터가 없는 경우
if len(data) == 0:
break
# json 형태의 데이터를 dict 타입으로 변경 dict = {'key': 'value'}
data_json_obj = json.loads(data)
# Transaction을 받은 경우
if data_json_obj['type'] == 'T':
log.write("Receiving a transaction")
# todo
# 블록을 수신한 경우
elif data_json_obj['type'] == 'B':
log.write("Receiving a block")
# todo
except:
traceback.print_exc()
break
tcp_socket.close()
receive_socket.close()
def test_method():
if "secret" not in request.args:
log.write("/method/test: access denied, expected secret")
return json.dumps({
"bad_response": {
"error": "access denied, expected secret"
}
})
if not check_secret(request.args["secret"]):
log.write("/method/test: access denied, wrong secret value: \"" + request.args["secret"] + "\"")
return json.dumps({
"bad_response": {
"error": "access denied, wrong secret value: \"" + request.args["secret"] + "\""
}
})
log.write("/method/test: is working fine")
return json.dumps({
"response":{
"message": "working fine, {}".format(api_cpp.stats.get_ram_usage())
}
})
def list_all_node(): for n in node.get_all(): log.write(n, logging.DEBUG)
def initiate_node(*args):
set_my_node()
log.write("Start node")
start_node()
def set_my_node():
my_node = Node(util.get_ip_address('en0'))
key.generate_key()
log.write("Set my node")
node.add_node(my_node)
def list_all_transaction():
import logging
for t in transaction.get_transactions():
log.write(t, logging.DEBUG)
def list_all_block():
import logging
for b in block.get_all_block():
log.write(b, logging.DEBUG)
def start(thread_name, ip_address, port):
import json
addr = (ip_address, port)
buf_size = 1024
# 소켓 생성 및 바인딩
tcp_socket = socket(AF_INET, SOCK_STREAM)
tcp_socket.bind(addr)
tcp_socket.listen(5)
while is_running:
# 요청이 있을 경우 소켓과 송신자의 ip 주소 저장
receive_socket, sender_ip = tcp_socket.accept()
while is_running:
log.write("Receiving")
# 소켓으로부터 버퍼 사이즈씩 데이터 수신
data = receive_socket.recv(buf_size)
try:
# 수신된 데이터가 없는 경우
if len(data) == 0:
break
# json 형태의 데이터를 dict 타입으로 변경
data_json_obj = json.loads(data)
# Transaction을 받은 경우
if data_json_obj['type'] == 'T':
log.write("Receiving a transaction")
verify_msg = data_json_obj['time_stamp'] + data_json_obj[
'message']
if key.verify_signature(data_json_obj['pub_key'],
data_json_obj['signature'],
verify_msg) is True:
log.write("Transaction is valid")
tx = Transaction().from_json(data_json_obj)
transaction.add_transaction(tx)
else:
log.write("Transaction is invalid")
# 블록을 수신한 경우
elif data_json_obj['type'] == 'B':
# 기존의 트랜잭션 삭제
transaction.remove_all()
# 블록 생성
received_block = Block().from_json(data_json_obj)
# 블록 저장
create_block(received_block)
except:
traceback.print_exc()
break
tcp_socket.close()
receive_socket.close()
def start(thread_name, ip_address, port):
import json
addr = (ip_address, port)
buf_size = 1024
tcp_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
# tcp_socket.bind(addr)
tcp_socket.listen(5)
while True:
receive_socket, sender_ip = tcp_socket.accept()
while True:
log.write("Receiving")
data = receive_socket.recv(buf_size)
try:
if len(data) == 0:
break
data_json_obj = json.loads(data)
if data_json_obj['type'] == 'T':
log.write("Receiving a transaction")
verify_msg = data_json_obj['time_stamp'] + data_json_obj[
'message']
verification = key.verify_signature(
data_json_obj['pub_key'], data_json_obj['signature'],
verify_msg)
if verification is True:
log.write("Transaction is valid")
tx = Transaction().from_json(data_json_obj)
transaction.add_transaction(tx)
elif data_json_obj['type'] == 'N':
from node import node_controller
log.write("Receiving Node")
node_list = node.get_all()
received_ip = data_json_obj['ip_address']
sync_flag = False
for outer_list in node_list:
outer_list = str(outer_list)
if outer_list == received_ip:
sync_flag = True
if sync_flag is False:
node_controller.add_new_node(data_json_obj)
# # When received block, add to file database
# elif data_json_obj['type'] == 'B':
# transaction.remove_all()
# create_block(data_json_obj['block_id'], data)
except:
traceback.print_exc()
break
tcp_socket.close()
receive_socket.close()
def admin_required(f):
log.write('admin_required','admin_required')
return permission_required(Permission.ADMINISTER)(f)
def set_my_node(set_my_node=True):
if set_my_node:
my_node = Node(my_ip_address.get_ip_address('en0'))
node.add_node(my_node)
log.write("Set my node")
def show_node_list():
from app import node, log
import logging
for n in node.get_all():
log.write(n, logging.DEBUG)
main_menu()
def handle_sent():
lines = []
# Process current entries in file
try:
with open(files['outfile'], 'r') as f:
log.write(log.NOTICE, 'outfile', 'Opening file')
for line in f:
parse = smsfile.parseline(line)
# Handle message based on status
if 'STATE' in parse and parse['STATE'] in states:
if parse['STATE'] == 'DONE':
try:
SentSMS.update_state(parse['ID'], 2)
log.write(log.NOTICE, 'outfile', 'Updating and ' \
'removing message (id: %s; status: 2)' %
parse['ID'])
except:
lines.append(line)
log.write(log.NOTICE, 'outfile', 'Failed to ' \
'update status and remove message ' \
'(id: %s; status: 2)' % parse['ID'])
if parse['STATE'] == 'ERROR':
try:
SentSMS.update_state(parse['ID'], 3)
log.write(log.NOTICE, 'outfile', 'Updating ' \
'status and removing message (id: %s; ' \
'status: 3)' % parse['ID'])
except:
lines.append(line)
log.write(log.NOTICE, 'outfile', 'Failed to ' \
'update status and remove message ' \
'(id: %s; status: 3)' % parse['ID'])
else:
# State unexistant or unknown - simply write the line back
lines.append(line)
except Exception as e:
log.write(log.FAIL, 'outfile', 'Could not process file: %s' % (e))
else:
# Append new entries
try:
usms = SentSMS.get_unprocessed()
log.write(log.NOTICE, 'outfile', 'Fetched %d messages' %
len(usms))
except:
log.write(log.FAIL, 'outfile', 'Could not fetch unprocessed ' \
'messages from database')
else:
for sms in usms:
sms.state = 1
lines.append(smsfile.add(sms.phone, sms.text, sms.id))
log.write(log.NOTICE, 'outfile', 'Adding message (phone: ' \
'%s; text: %s; id: %s)' %
(sms.phone, sms.text, sms.id))
try:
with open(files['outfile'], 'w') as f:
f.write(''.join(lines))
log.write(log.NOTICE, 'outfile', 'Writing %d messages back to ' \
'file' % (len(lines)))
session.commit()
log.write(log.NOTICE, 'outfile', 'Comitting database changes')
except:
session.rollback()
log.write(log.FAIL, 'outfile', 'Could not commit changes to ' \
'database')
else:
log.write(log.OK, 'outfile', 'Processed file')
def handle_recv():
lines = []
try:
with open(files['infile'], 'r') as f:
log.write(log.NOTICE, 'infile', 'Opening file')
for line in f:
data = smsfile.parseline(line)
try:
sms = ReceivedSMS(data['PHONE'],
data['TEXT'], data['TIME'])
session.add(sms)
log.write(log.NOTICE, 'infile', 'Adding message by %s ' \
'with text %s (timestamp: %s)' %
(data['PHONE'], data['TEXT'], data['TIME']))
except:
lines.append(line)
log.write(log.FAIL, 'infile', 'Could not add ' \
'message(%s, %s, %s) to database' %
(data['PHONE'], data['TEXT'], data['TIME']))
except Exception as e:
log.write(log.FAIL, 'infile', 'Could not process file: %s' % (e))
else:
try:
with open(files['infile'], 'w') as f:
f.write(''.join(lines))
log.write(log.NOTICE, 'infile', 'Writing %s messages back to ' \
'file' % (len(lines)))
session.commit()
log.write(log.NOTICE, 'infile', 'Comitting database changes')
except:
session.rollback()
log.write(log.FAIL, 'infile', 'Could not commit changes to ' \
'database')
else:
log.write(log.OK, 'infile', 'Processed file')
