def choice_server():
message = "From {0}".format(choice_server.__qualname__)
print_fun(message)
log_file(message, server=1)
max_f_p = -1
server_k = 0
# get server with max free processes
for elem in servers_info.keys():
if not servers_info[elem][2]:
continue # not authorized
if servers_info[elem][1] > max_f_p:
max_f_p = servers_info[elem][1]
server_k = elem
message = "From {0}: max_f_p = {1}; server_k = {2}".format(
choice_server.__qualname__, max_f_p, server_k)
print_fun(message)
log_file(message, server=1)
if max_f_p == -1:
return -1 # there is not connected servers
elif max_f_p <= 0:
return -2 # there is not free processes
else:
return server_k
def get_nocode(msg):
message = "From {0}: msg = {1}".format(get_nocode.__qualname__, msg)
print_fun(message)
log_file(message, server=1)
if msg == "NOCODE":
return 'NOCODE'
try:
msg = msg.split(',')
if len(msg) != 3:
return 0
nc, city, count = msg
if nc != 'NOCODE':
return 0
else:
city = city.lstrip('\n ').rstrip('\n ')
count = count.lstrip('\n ').rstrip('\n ')
value = city + ',' + count
return value
except:
return 0
def pickit(file_name,hash):
import pickle
try:
fil_pic=open(file_name+'dump.pickle','r')
except(IOError,EOFError):
data={'file_name':'secret.txt','hash':hash}
fil_pic=open(file_name+'dump.pickle','w')
pickle.dump(data,fil_pic)
import log
log.log_file('Starting Hash',hash,file_name)
fil_pic.close()
fil_pic=open(file_name+'dump.pickle','r')
data=pickle.load(fil_pic)
if(data['hash']==hash):
print 'Hash Not Changed'
else:
data={'file_name':'secret.txt','hash':hash}
print 'Hash Has Been Changed'
fil_pic=open(file_name+'dump.pickle','w')
pickle.dump(data,fil_pic)
import log
log.log_file("Hash Has Been changed",hash,file_name)
fil_pic.close()
def transform_value(val):
message = "From {0}: val = {1}".format(transform_value.__qualname__, val)
print_fun(message)
log_file(message, server=1)
l = val.split(',')
d = {l[0]: l[1]}
return d
def name_gen():
message = "From {0}".format(name_gen.__qualname__)
print_fun(message)
log_file(message)
random.seed(datetime.datetime.now()) # somewhere needs it, somewhere not
name = random.choice(names)
return name
def set_profile_path(new_path):
message = "From {0}: new path = {1}".format(set_profile_path.__qualname__,
new_path)
print_fun(message)
log_file(message)
global profile_path
profile_path = new_path
def phone_gen():
message = "From {0}".format(phone_gen.__qualname__)
print_fun(message)
log_file(message)
random.seed(datetime.datetime.now()) # somewhere needs it, somewhere not
number = random.choice(operators)
number += str(random.randint(1000000, 9999999))
return number
def set_next_time_order(self, period=1): # 1 day
message = "From %s" % User.set_next_time_order.__qualname__
print_fun(message, self.id)
log_file(message, self.id)
ret = self.last_time_order + timedelta(days=0) # change later =period
message = "Returned next order %s from %s" % (
str(ret), User.set_next_time_order.__qualname__)
print_fun(message, self.id)
log_file(message, self.id)
return ret
def delete_email(key):
message = "From {0}: key = {1}".format(delete_email.__qualname__, key)
print_fun(message)
log_file(message)
url = 'https://post-shift.ru/api.php?action=delete&key=' + key
requests.get(url)
message = "From {0}: Email deleted".format(delete_email.__qualname__)
print_fun(message)
log_file(message)
def get_message_id(key): # may rewrite in 2 messages
message = "From {0}: key = {1}".format(get_message_id.__qualname__, key)
print_fun(message)
log_file(message)
url = 'https://post-shift.ru/api.php?action=getlist&key=' + key + '&type=json'
response = requests.get(url) # in version 2 must be alone ???
data = response.text
d_resp = json.loads(data)
if 'error' in d_resp: # work with list or dict ?
message = "From {0}: {1}".format(get_message_id.__qualname__,
RET_VALUES['TMERROR'])
print_fun(message)
log_file(message)
return 'TMERROR'
if len(d_resp) < 2:
message = "From {0}: {1}".format(get_message_id.__qualname__,
RET_VALUES['LTN'])
print_fun(message)
log_file(message)
return 'LTN'
msg = '30'
for d_msg in d_resp: # get promocode message
try:
msg_subj_str = d_msg['subject']
except:
message = "From {0}: {1}".format(get_message_id.__qualname__,
RET_VALUES['MISERROR'])
print_fun(message)
log_file(message)
return 'MISERROR'
if msg not in msg_subj_str:
continue
# when we found a promocode message
try:
id = d_msg['id']
except:
message = "From {0}: {1}".format(get_message_id.__qualname__,
RET_VALUES['MISERROR'])
print_fun(message)
log_file(message)
return 'MISERROR'
return id # will return id of message
def set_path_cities(cities):
message = "From {0}".format(set_path_cities.__qualname__)
print_fun(message)
log_file(message, server=1)
pwd = os.getcwd()
for x in cities.keys():
path = pwd + '/codes/' + cities[x][2]
cities[x][2] = path
path = pwd + '/codes/' + cities[x][8]
cities[x][8] = path
def email_gen():
message = "From {0}".format(email_gen.__qualname__)
print_fun(message)
log_file(message)
email = ''
for x in range(10):
random.seed(
datetime.datetime.now()) # somewhere needs it, somewhere not
email += random.choice(email_string)
return email
def add_to_file(file_name, code):
message = "From {0}: file name = {1}, code = {2}".format(
add_to_file.__qualname__, file_name, code)
print_fun(message)
log_file(message)
try:
with open(file_name, 'r+') as file:
for _ in file: # need to add to the end of file
pass
dump_msg = code + '\n'
file.write(dump_msg)
message = "From {0}: Dumped code ({1}) to file ({2})".format(
add_to_file.__qualname__, code, file_name)
print_fun(message)
log_file(message)
except:
message = "From {0}: File {1} doesn't exist -> create new file {2}".format(
add_to_file.__qualname__, file_name, file_name)
print_fun(message)
log_file(message)
with open(file_name, 'w') as file:
dump_msg = str(city) + '\n' + str(code) + '\n'
file.write(dump_msg)
message = "From {0}: Dumped code ({1})".format(
add_to_file.__qualname__, code)
print_fun(message)
log_file(message)
def check_msg(data):
message = "From {0}".format(check_msg.__qualname__)
print_fun(message)
log_file(message)
data = data.decode('utf-8')
data = data.split(',')
try:
city = data[0]
flag = data[1].lstrip('\n ').rstrip('\n ')
if flag == 'STOP':
message = "From {0}: It's STOP message from M-server -> ({1}, {2})".format(
check_msg.__qualname__, city, flag)
print_fun(message)
log_file(message)
return city, flag
else:
count = int(data[1].lstrip('\n ').rstrip('\n '))
message = "From {0}: It's WORK message from M-server -> ({1}, {2})".format(
check_msg.__qualname__, city, count)
print_fun(message)
log_file(message)
return city, count
except: # it is just a message from M-server, not a work for S-server
message = "From {0}: It's just message from M-server --> {1}".format(
check_msg.__qualname__, data)
print_fun(message)
log_file(message)
return -1
def add_to_afile(city, count, codes):
message = "From {0}: city = {1}, count = {2}, codes = {3}".format(
add_to_afile.__qualname__, city, count, codes)
print_fun(message)
log_file(message, server=1)
lock.acquire()
check_th()
afile = cities[city][8]
message = "From {0}: add file = {1}".format(add_to_afile.__qualname__,
afile)
print_fun(message)
log_file(message, server=1)
file = open(afile, 'a')
for code in codes:
msg = code + '\n'
file.write(msg)
file.close()
cities[city][5] += count
message = "From {0}: new add count = {1}".format(add_to_afile.__qualname__,
cities[city][5])
print_fun(message)
log_file(message, server=1)
check_th(2)
lock.release()
message = "From {0}: To the file {1} were written {2} code(s)".format(
add_to_afile.__qualname__, afile, count)
print_fun(message)
log_file(message, server=1)
def analyze_server(hmp):
# hmp max value equal 5 -> need to change function if this constant will changed
message = "From {0}: hmp = {1}".format(analyze_server.__qualname__, hmp)
print_fun(message)
log_file(message, server=1)
if hmp >= 3:
message = "From {0}: {1}".format(analyze_server.__qualname__,
HANDLE['FUSEPF'])
print_fun(message)
log_file(message, server=1)
return 'FUSEPF' # send both work (1 & 5 4.e.)
if hmp >= 1:
message = "From {0}: {1}".format(analyze_server.__qualname__,
HANDLE['FUSNEFP'])
print_fun(message)
log_file(message, server=1)
return 'FUSNEFP' # send only biggest work (5 4.e.)
message = "From {0}: {1}".format(analyze_server.__qualname__,
HANDLE['FUSNFP'])
print_fun(message)
log_file(message, server=1)
return 'FUSNFP' # can't send something
def GUI():
"""
the main comm punc. connect to the server and do handshake
"""
name = 'adi'
sender = '*****@*****.**'
global log
log = log_file("client.log", '%(levelname)s:%(message)s')
client_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
try:
client_socket.connect((SERVER_IP, SERVER_PORT))
# send the message
#TODO: add the pop3 here. if he press on the send email go on
if not handshake(client_socket, sender):
print "unvalid handshake" #FIXME: and GUI interfase
if not vaild_sender(client_socket, sender):
print "unvalid email adress" #FIXME: and GUI interfase
email = "From:" + ' "' + name + '" ' + "<" + sender + ">" + "\r\n"
email += send_email(client_socket)
client_socket.sendall("DATA\r\n")
data = receive(client_socket, lambda data: "\r\n" not in data)
if not data[:3] == "354":
print 'server error' #FIXME: and GUI interfase
client_socket.sendall(email)
data = receive(client_socket, lambda data: "\r\n" not in data)
if not data[:3] == "250":
print 'unvalid email' #FIXME: and GUI interfase
print 'send'
except socket.error as msg:
print 'error in communication with server - ' + str(msg)
finally:
time.sleep(1)
client_socket.close()
def globals():
"""
set the globals for the program.
set the log config and the database
"""
global log
log = log_file("smtp.log", '%(thread)d %(levelname)s:%(message)s')
global database
database = file("data.txt")
def thread_client():
"""
prrove thet the server treading works
"""
global log
log = log_file("client.log", '%(levelname)s:%(message)s')
from threading import Thread
for send in range(1, 10, 1):
thread = Thread(target=send_email, args=("*****@*****.**", 'adib', "*****@*****.**", "text", "my first client"+ str(send)))
thread.start()
def __init__(self,
id,
order_count=0,
next_time_order=0,
city=False,
restore=0):
self.id = id
self.order_count = order_count
self.next_time_order = next_time_order
self.last_time_order = 0
self.rest_time = False
self.city = city
self.lock = threading.RLock()
if restore:
# restore flag is used to restore data from file data.txt
return
message = 'Call %s' % save_data.__qualname__
print_fun(message)
log_file(message)
ret = save_data(self)
message = 'Returned from %s: ret = %s' % (save_data.__qualname__, ret)
print_fun(message, self.id)
log_file(message, self.id)
if ret == 'DATA_CHANGED' or ret == 'DATA_ADDED':
message = "%s: %s" % (STATE_TG[ret], 'data.txt')
else:
message = "%s: %s" % (STATE_TG[ret], "user_class_dict")
print_fun(message)
log_file(message, id=self.id)
def delete_all_us(l, city):
# This function will delete from list all values equals this city.
# Need to call it before sending urgent stop to S-server
message = "From {0}: list = {1}, city = {2}".format(
delete_all_us.__qualname__, l, city)
print_fun(message)
log_file(message, server=1)
count = 0
for x in l:
if city in x.keys():
count += 1
message = "From {0}: count = {1}".format(delete_all_us.__qualname__, count)
print_fun(message)
log_file(message, server=1)
i = 0
while count > 0:
if i >= 10: # need it to avoid looped cycle
break
for x in l:
if city in x.keys():
l.remove(x)
count -= 1
break
i += 1
message = "From {0}: i = {1}; new count = {2}; new list = {3}".format(
delete_all_us.__qualname__, i, count, l)
print_fun(message)
log_file(message, server=1)
def send_us(city, server):
message = "From {0}: city = {1}, server = {2}".format(
send_us.__qualname__, city, server)
print_fun(message)
log_file(message, server=1)
sock = servers_info[server][0]
city = str(city)
flag = 'STOP'
msg = (city + ',' + flag).encode('utf-8')
try:
sock.send(msg)
except:
message = "From {0}: Can't send US for S-server".format(
send_us.__qualname__)
print_fun(message)
log_file(message, server=1)
try:
message = "From {0}: Remove from dict {1}".format(
send_us.__qualname__, server)
print_fun(message)
log_file(message, server=1)
del servers_info[server]
except:
message = "From {0}: Can't delete server from dict".format(
send_us.__qualname__)
print_fun(message)
log_file(message, server=1)
sock.close()
readsocks.remove(sock)
return
message = "From {0}: Sent US({1}) for server {2}".format(
send_us.__qualname__, msg.decode('utf-8'), server)
print_fun(message)
log_file(message, server=1)
def get_codes(data):
message = "From {0}: data = {1}".format(get_codes.__qualname__, data)
print_fun(message)
log_file(message, server=1)
codes = []
try:
data = data.split('|')
for code in data:
if code == '':
break
else:
codes.append(code)
city = codes[0]
codes.remove(codes[0])
except:
message = "From {0}: Error occurred while trying to get codes".format(
get_codes.__qualname__)
print_fun(message)
log_file(message, server=1)
return 0, # it is error
return city, codes
def change_city(self, city):
self.lock.acquire()
message = "From %s" % User.change_city.__qualname__
print_fun(message, self.id)
log_file(message, self.id)
self.city = city
message = 'City changed'
print_fun(message, self.id)
log_file(message, self.id)
message = 'Call %s' % save_data.__qualname__
print_fun(message)
log_file(message)
ret = save_data(self)
message = 'Returned from %s: ret = %s' % (save_data.__qualname__, ret)
print_fun(message, self.id)
log_file(message, self.id)
if ret == 'DATA_CHANGED' or ret == 'DATA_ADDED':
message = "%s: %s" % (STATE_TG[ret], 'data.txt')
else:
message = "%s: %s" % (STATE_TG[ret], "user_class_dict")
print_fun(message)
log_file(message, id=self.id)
self.lock.release()
def add_value(l, val):
message = "From {0}: list = {1}, val = {2}".format(add_value.__qualname__,
l, val)
print_fun(message)
log_file(message, server=1)
message = "Call %s" % transform_value.__qualname__
print_fun(message)
log_file(message, server=1)
val = transform_value(val)
message = 'Returned from {0}: ret = {1}'.format(
transform_value.__qualname__, val)
print_fun(message)
log_file(message, server=1)
l.append(val)
message = "From {0}: new list = {1}".format(add_value.__qualname__, l)
print_fun(message)
log_file(message, server=1)
def compare_time(self, current_time):
message = "From %s" % User.compare_time.__qualname__
print_fun(message, self.id)
log_file(message, self.id)
ret = str(self.next_time_order - current_time)
if ret[0] == '-' or ret == "0:00:00":
message = "Returned false from %s" % User.compare_time.__qualname__
print_fun(message, self.id)
log_file(message, self.id)
return False
else:
message = "Returned rest time from %s" % User.compare_time.__qualname__
print_fun(message, self.id)
log_file(message, self.id)
ret = ret.split('.')
return ret[0]
def create_email(name, pid_f):
message = "From {0}: name = {1}, pid_f = {2}".format(
create_email.__qualname__, name, pid_f)
print_fun(message)
log_file(message)
global pid
pid = pid_f
url = 'https://post-shift.ru/api.php?action=new&name=' + name + '&type=json'
response = requests.get(url) # in version 2 must be alone ???
data = response.text
d_resp = json.loads(data)
if 'error' in d_resp: # there was a error on site
message = "From {0}: {1}".format(create_email.__qualname__,
RET_VALUES['TMERROR'])
print_fun(message)
log_file(message)
return 'TMERROR'
try:
email = d_resp['email']
key = d_resp['key']
except:
message = "From {0}: {1}".format(create_email.__qualname__,
RET_VALUES['MISERROR'])
print_fun(message)
log_file(message)
return 'MISERROR'
message = "From {0}: Email created".format(create_email.__qualname__)
print_fun(message)
log_file(message)
return email, key
def hm_work(l, city):
message = "From {0}: list = {1}, city = {2}".format(
hm_work.__qualname__, l, city)
print_fun(message)
log_file(message, server=1)
count = 0
hmw = 0 # how much work
for x in l:
if city not in x.keys():
continue
hmw += 1 # how much work
count += int(x[city]) # how much codes for crafting
message = "From {0}: hmw = {1}; count = {2}".format(
hm_work.__qualname__, hmw, count)
print_fun(message)
log_file(message, server=1)
# start analyzing
if hmw <= 1: # there is one/no work for this city on S-server
message = "From {0}: {1}".format(hm_work.__qualname__,
HANDLE['FHMWCS'])
print_fun(message)
log_file(message, server=1)
return 'FHMWCS'
else: # 2 & more processes craft codes -> don't need send work
message = "From {0}: {1}".format(hm_work.__qualname__,
HANDLE['FHMWCNS'])
print_fun(message)
log_file(message, server=1)
return 'FHMWCNS'
def delete_value(l, val):
message = "From {0}: list = {1}, val = {2}".format(
delete_value.__qualname__, l, val)
print_fun(message)
log_file(message, server=1)
message = "Call %s" % transform_value.__qualname__
print_fun(message)
log_file(message, server=1)
val = transform_value(val)
message = 'Returned from {0}: ret = {1}'.format(
transform_value.__qualname__, val)
print_fun(message)
log_file(message, server=1)
for x in l:
if x == val:
l.remove(x)
break
message = "From {0}: new list = {1}".format(delete_value.__qualname__, l)
print_fun(message)
log_file(message, server=1)
def new_user(user_id, user_dict): # user_id has type 'str' here
try:
with open(account_file, 'r+') as file:
for _ in file: # go to the end of file
pass
file.write(user_id + '\n')
user_dict[user_id] = User(user_id)
message = "Added new user to file %s" % account_file
print_fun(message, user_id)
log_file(message, user_id)
except:
message = "File doesn't exist. Create new file: %s" % account_file
print_fun(message)
log_file(message)
with open(account_file, 'w') as file:
file.write(user_id + '\n')
user_dict[user_id] = User(user_id)
message = "Added new user to file %s" % account_file
print_fun(message, user_id)
log_file(message, user_id)
def _log(self, s, que=None):
name = 'que'
if que:
name += '.' + str(que)
log_file(self, name, str(s))
