def test():
pylog.debug('debug test 测试')
pylog.info('info test 测试')
pylog.warning('warning test 测试')
pylog.error('error test 测试')
pylog.critical('critical test 测试')
print(datetime.datetime.now().strftime('%Y-%m-%d'))
def load_scenario(self, plat="windows"):
'''
加载想定
plat 服务器是Windows版还是Linux版
'''
scenario_file = self.scenario_name
if plat == "windows":
ret = self.scenEditLoadScenario(scenario_file, "false")
else:
ret = self.loadScenario(scenario_file, "Play")
load_success = False
for i in range(30):
value = self.getScenarioIsLoad()
if str(value) == "'Yes'":
pylog.info("scenario load sucess")
load_success = True
break
pylog.info("sleep a second")
time.sleep(1)
if not load_success:
pylog.error("can not load scenario:%s" % scenario_file)
return None
scenario = CScenario(self)
return scenario
def show_side_info(self, item):
'''
show side info
'''
count = 0
for key in item:
pylog.info("count:%s %s:%s" % (count, key, item[key]))
count += 1
def parse(self, label, opcode, operands):
try:
info(
7, "parse: label='%s' opcode='%s' operands=%s" %
(label, opcode, operands))
# TODO: parse operation here.
except Exception:
critical("Exception processing line:")
raise
def get_current_time(self):
'''
得到当前时间
param :
return : 时间毫秒值
'''
lua = "ReturnObj(ScenEdit_CurrentTime())"
ret_time = self.mozi_task.sendAndRecv(lua)
pylog.info("%s\n" % ret_time)
return ret_time
def assemble(self, srcfile):
info("Assembling %s" % srcfile)
self._srcfile = srcfile
self._linenum = 0
with open(srcfile, 'r') as f:
lines = f.readlines()
debug("assemble: file %s, lines %d" % (srcfile, len(lines)))
for line in lines:
# Parse lines.
pass
def update_proxy_list(check_url):
lt = filter_proxy_list(check_url)
if not lt:
pylog.error("do not get any proxy")
print "do not get any proxy"
return False
proxy_list = extend_proxy_list(lt)
pylog.info("now proxy count is %s" % len(proxy_list))
save_proxy_list(proxy_list)
return proxy_list
def taishi_reset(self):
'''
态势重置函数
'''
self._reset()
time.sleep(3)
step_interval = 30
pylog.info("Hs_OneTimeStop:%d" % step_interval)
self.sendAndRecv("Hs_OneTimeStop('Stop', %d)" % step_interval)
self.run_simulate()
self.create_get_situation_process()
self.step()
def run(train_step, start_epoch, trainer, ram, env):
loss_num_sum = 0
destroy_num_sum = 0
for _ep in range(int(start_epoch), etc.MAX_EPISODES):
if not env.connect_server():
pylog.info("can not connect to server")
return False
observation = env.reset()
sum_reward = 0
for step in range(etc.MAX_STEPS):
#pylog.info("step:%s" % step)
state = np.float32(observation)
if _ep % 5 == 0:
action = trainer.get_exploitation_action(state)
else:
action = trainer.get_exploration_action(state)
new_observation, reward, done, info = env.step(action)
sum_reward += reward
show_str = "EPISODE:%s step:%s observation:%s action:%s new_observation:%s reward:%s sum_reward:%s" % (
_ep, step, observation, action, new_observation, reward,
sum_reward)
#pylog.info(show_str)
if done:
new_state = None
else:
new_state = np.float32(new_observation)
ram.add(state, action, reward, new_state)
if info:
pylog.info(info)
observation = new_observation
trainer.optimize(train_step)
train_step += 1
write_file(train_step, "%s/step.txt" % etc.OUTPUT_PATH)
if done:
pylog.info("done from reward")
break
loss_num = len(env.red_unit_list) - env.last_red_aircraft_num
loss_num_sum += loss_num
destroy_num = len(env.blue_unit_list) - env.last_blue_aircraft_num
destroy_num_sum += destroy_num
write_learning_file("%s,%s" % (loss_num, destroy_num))
pylog.info("loss_num_sum:%s destroy_num_sum:%s" %
(loss_num_sum, destroy_num_sum))
write_final_reward(sum_reward, _ep)
gc.collect()
if _ep % 5 == 0:
trainer.save_model(_ep, etc.MODELS_PATH)
write_file(_ep)
def resolve(self, maxPasses=10):
"Resolve a symbol."
startTime = time.time()
# self.context.symtab.resolve(maxPasses)
endTime = time.time()
delta = endTime - startTime
debug("Symbol resolution: %3.2f seconds" % delta)
startTime = time.time()
numRecords = len(self.context.records)
debug("Updating %d parser records..." % (numRecords))
nUndefs = nPrevUndefs = 0
for i in range(maxPasses):
self._passnum = i + 1
# self.reset()
nPrevUndefs = nUndefs
nUndefs = 0
undefRecords = []
for j in range(numRecords):
record = self._records[j]
if record.isParseable():
self._currentRecord = record
self._previousRecord = self.context.records[j - 1]
# self.load(record)
debug("resolve: %s" % (record.srcline))
# self.parse(record.label, record.opcode, record.operands)
self._records[j] = self.context.currentRecord
if not record.isComplete():
nUndefs += 1
undefRecords.append(record)
info("%d incomplete parser records" % (nUndefs))
if nUndefs == 0:
info("All parser records complete")
break
if nUndefs == nPrevUndefs:
for urec in undefRecords:
urec.error("undefined symbol")
self._errors += 1
self.context.error("no progress resolving parser records, "
"%d undefined records" % nUndefs,
source=False,
count=False)
break
if self._verbose:
endTime = time.time()
delta = endTime - startTime
print("Pass 2: %3.2f seconds" % delta)
def __init__(self, state_dim, action_dim, action_lim):
super(Actor, self).__init__()
self.state_dim = state_dim
self.action_dim = action_dim
self.action_lim = action_lim
self.fc1 = nn.Linear(state_dim, 256)
pylog.info(self.fc1.weight.data.size())
self.fc1.weight.data = fanin_init(self.fc1.weight.data.size())
self.fc2 = nn.Linear(256, 128)
self.fc2.weight.data = fanin_init(self.fc2.weight.data.size())
self.fc3 = nn.Linear(128, 64)
self.fc3.weight.data = fanin_init(self.fc3.weight.data.size())
self.fc4 = nn.Linear(64, action_dim)
self.fc4.weight.data.uniform_(-EPS, EPS)
def check_proxy_list_count(check_url=get_check_url()):
count = get_proxy_list_min_count()
proxy_list = read_proxy_list()
if proxy_list:
pylog.info("now proxy count is %s" % len(proxy_list))
else:
pylog.info("now proxy count is 0")
proxy_list_count = 0
if proxy_list:
proxy_list_count = len(proxy_list)
if proxy_list_count < count:
while proxy_list_count < count:
update_proxy_list(check_url)
proxy_list = read_proxy_list()
if proxy_list:
proxy_list_count = len(proxy_list)
def get_weapon_remain_dic(side_guid, all_info_dict):
units_dic = get_care_class_units_from_side(side_guid, all_info_dict)
#pylog.info(len(units_dic))
weapon_dic = {}
for key in units_dic:
item = units_dic[key]
#show_item_info(item)
#mozi_unit.show_mozi_unit(item)
mount_lt = get_unit_mounts_lt(item)
for guid in mount_lt:
mount_item = all_info_dict[guid]
weapon_dic[guid] = mount_item
loadout_item = get_unit_loadout(item, all_info_dict)
if loadout_item:
weapon_dic[loadout_item["strGuid"]] = loadout_item
weapon_remain_dic = create_weapon_remain_dic(weapon_dic)
pylog.info(weapon_remain_dic)
raise
def run_primary(train_step, start_epoch, trainer, ram, env):
loss_num_sum = 0
destroy_num_sum = 0
for _ep in range(int(start_epoch), etc.MAX_EPISODES):
if not env.connect_server():
pylog.info("can not connect to server")
return False
observation = env.reset()
for step in range(etc.MAX_STEPS):
new_observation, reward, done, info = env.step(None)
if done:
pylog.info("done from reward")
break
loss_num = len(env.red_unit_list) - env.last_red_aircraft_num
loss_num_sum += loss_num
destroy_num = len(env.blue_unit_list) - env.last_blue_aircraft_num
destroy_num_sum += destroy_num
write_primary_file("%s,%s" % (loss_num, destroy_num))
pylog.info("loss_num_sum:%s destroy_num_sum:%s" %
(loss_num_sum, destroy_num_sum))
def paser_interface_test(all_info_dict):
side_dic = get_all_sides_dic(all_info_dict)
for side_guid in side_dic:
# pylog.info(side_guid)
a_side_dic = get_all_units_from_side(side_guid, all_info_dict)
a_side_class_dic = get_class_dic(a_side_dic)
# show_class_info(a_side_class_dic)
aircraft_list = get_units_from_side(side_guid, "CAircraft", all_info_dict)
if aircraft_list:
pylog.info("aircraft:%s" % len(aircraft_list))
facility_list = get_units_from_side(side_guid, "CFacility", all_info_dict)
if facility_list:
pylog.info("facility:%s" % len(facility_list))
contacts_dic = get_contacts_from_side(side_guid, all_info_dict)
if contacts_dic:
pylog.info("contacts:%s" % len(contacts_dic))
for guid in contacts_dic:
# pylog.info("contact guid:%s" % guid)
actual_unit = get_contact_actual_unit_dic(guid, all_info_dict)
# pylog.info(actual_unit["strName"])
# pylog.info("dLatitude:%s" % actual_unit["dLatitude"])
# pylog.info("dLongitude:%s" % actual_unit["dLongitude"])
# pylog.info("m_Side:%s" % actual_unit["m_Side"])
side_name = get_unit_side_name(actual_unit, all_info_dict)
def do_eval(a_actor):
etc.RENDER = True
etc.CLOCK_FREQUENCY = 200
winstyle = 0
start_time = time.time()
count = 100
while count:
a_game_dic = init_the_game(winstyle)
a_game_dic["state"] = "eval"
model_dic = {}
model_dic["actor"] = a_actor
a_game_dic["model_dic"] = model_dic
run_the_game(a_game_dic)
a_actor.update_reward()
pg.quit()
count -= 1
a_actor.write_observation_dic()
end_time = time.time()
pylog.info("spend time:%.2f " % (end_time - start_time))
def train(a_actor):
winstyle = 0
count = 1000
start_time = time.time()
while count:
pylog.info("train ep:%s" % count)
a_game_dic = init_the_game(winstyle)
a_game_dic["state"] = "train"
model_dic = {}
model_dic["actor"] = a_actor
a_game_dic["model_dic"] = model_dic
run_the_game(a_game_dic)
a_actor.update_reward()
pg.quit()
count -= 1
a_actor.write_observation_dic()
end_time = time.time()
pylog.info("spend time:%.2f " % (end_time - start_time))
def inference(self, a_observation):
a_state_dic = self.a_critic.query_a_observation(a_observation)
a_action = 0
if a_state_dic:
pylog.info("state:%s a_state_dic:%s" %
(a_observation, a_state_dic))
max_value = None
select_key = None
for key in a_state_dic:
a_value = a_state_dic[key]["avg_reward"]
if max_value == None:
max_value = a_value
select_key = key
else:
if a_value > max_value:
max_value = a_value
select_key = key
a_action = select_key
#else:
# a_action = bernoulli(0.005)
return a_action
def connect_mozi_server(self, websocket_server, websocket_port):
"""
连接墨子服务器
param ：
websocket_server 要连接的服务器的ip
websocket_port 要连接的服务器的端口
:return:
"""
pylog.info("connect_mozi_server")
if self.connect_mode == 1:
self.mozi_task = MoZiPython.MoZi(self.server_ip, self.server_port)
#
self.ai_server = self.server_ip
self.ai_port = self.server_port
return True
#
#server_address = r"ws://%s:%d/websocket" % ('60.205.207.206', 9998)
server_address = r"ws://%s:%d/websocket" % (websocket_server,
websocket_port)
pylog.info(server_address)
for i in range(10):
try:
self.websocket_connect = create_connection(server_address)
break
except:
pylog.info("can not connect to %s." % server_address)
time.sleep(2)
self.websocket_connect = None
#
if self.websocket_connect is None:
pylog.warning("Interrupted, can not connect to %s." %
server_address)
return False
#
self.websocket_connect.send("{\"RequestType\":\"StartServer\"}")
result = self.websocket_connect.recv()
print("connect server result:%s" % result)
jsons = json.loads(result)
self.ai_server = jsons['IP']
self.ai_port = jsons['AIPort']
self.mozi_task = MoZiPython.MoZi(self.ai_server, self.ai_port)
#
#if platform.system() != 'Darwin':
## 修改客户端配置文件
#inipath = self.client_path_init
#conf = configparser.ConfigParser()
#conf.read(inipath)
#conf.set('ConnectServer', "ip", jsons['IP'])
#conf.write(open(inipath, "r+"))
#conf.set('ConnectServer', "port", str(jsons['Port']))
#conf.write(open(inipath, "r+"))
#conf.set('ConnectServer', "name", str(jsons['Federate']))
#conf.write(open(inipath, "r+"))
#
return True
def run(train_step, start_epoch, trainer, ram, env):
for _ep in range(int(start_epoch), etc.MAX_EPISODES):
if not env.connect_server():
pylog.info("can not connect to server")
return False
observation = env.reset()
sum_reward = 0
for step in range(etc.MAX_STEPS):
state = np.float32(observation)
if _ep % 5 == 0:
action = trainer.get_exploitation_action(state)
else:
action = trainer.get_exploration_action(state)
new_observation, reward, done, info = env.step(action)
sum_reward += reward
show_str = "EPISODE:%s step:%s observation:%s action:%s new_observation:%s reward:%s sum_reward:%s" % (
_ep, step, observation, action, new_observation, reward,
sum_reward)
pylog.info(show_str)
if done:
new_state = None
else:
new_state = np.float32(new_observation)
ram.add(state, action, reward, new_state)
if info:
pylog.info(info)
observation = new_observation
trainer.optimize(train_step)
train_step += 1
write_file(train_step, "%s/step.txt" % etc.OUTPUT_PATH)
if done:
break
write_final_reward(sum_reward, _ep)
gc.collect()
if _ep % 5 == 0:
trainer.save_model(_ep, etc.MODELS_PATH)
write_file(_ep)
def connect_mozi_server(self, websocket_Ip, websocket_port):
"""
连接墨子服务器
param ：
websocket_server 要连接的服务器的ip
websocket_port 要连接的服务器的端口
:return:
"""
pylog.info("connect_mozi_server")
if self.connect_mode == 1:
self.mozi_server = MoziService(self.server_ip ,self.aiPort,self.scenario_name)
return True
# server_address = r"ws://%s:%d/websocket" % ('60.205.207.206', 9998)
server_address = r"ws://%s:%d/websocket" % (websocket_Ip, websocket_port)
pylog.info(server_address)
for i in range(10):
try:
self.websocket_connect = create_connection(server_address)
break
except:
pylog.info("can not connect to %s." % server_address)
time.sleep(2)
self.websocket_connect = None
#
if self.websocket_connect is None:
pylog.warning("Interrupted, can not connect to %s." % server_address)
return False
#
self.websocket_connect.send("{\"RequestType\":\"StartServer\"}")
result = self.websocket_connect.recv()
print("connect server result:%s" % result)
jsons = json.loads(result)
self.ai_server = jsons['IP']
self.ai_port = jsons['AIPort']
self.mozi_task = MoziService(self.server_ip ,self.aiPort,self.scenario_name)
return True
def show_class_info(dic):
for key in dic:
pylog.info("%s:%s" % (key, len(dic[key])))
def show_mozi_unit(item):
pylog.info("strGuid:%s" % item["strGuid"])
pylog.info("ClassName:%s" % item["ClassName"])
pylog.info("strUnitClass:%s" % item["strUnitClass"])
pylog.info("strName:%s" % item["strName"])
pylog.info("strDamageState:%s" % item["strDamageState"])
pylog.info("m_Bearing:%s" % item["m_Bearing"])
pylog.info("dLongitude:%s" % item["dLongitude"])
pylog.info("dLatitude:%s" % item["dLatitude"])
pylog.info("fCurrentAlt:%s" % item["fCurrentAlt"])
pylog.info("fPitch:%s" % item["fPitch"])
pylog.info("fCurrentHeading:%s" % item["fCurrentHeading"])
pylog.info("fCurrentSpeed:%s" % item["fCurrentSpeed"])
pylog.info("m_LoadoutGuid:%s" % item.get("m_LoadoutGuid", ""))
pylog.info("m_Mounts:%s" % item.get("m_Mounts", ""))
pylog.info("iDBID:%s" % item["iDBID"])
pylog.info("iFuelRecsMaxQuantity:%s" %
item.get("iFuelRecsMaxQuantity", ""))
pylog.info("fFuelConsumptionCruise:%s" %
item.get("fFuelConsumptionCruise", ""))
pylog.info("dFuelPercentage:%s" % item.get("dFuelPercentage", ""))
pylog.info("strActiveUnitStatus:%s" % item["strActiveUnitStatus"])
import pylog
from Iraq_learn import etc
from Iraq_learn.env import MoziEnv
from MoziService.paser_core import get_all_sides_dic
env = MoziEnv(etc.SERVER_IP, etc.SERVER_PORT, etc.SCENARIO_NAME, etc.simulate_compression)
if not env.connect_server():
pylog.info("can not connect to server")
else:
# ret = env.mozi_service.suspend_simulate()
# env.mozi_service.all_info_dict = {}
# env.scenario = env.mozi_service.load_scenario(plat=env.SERVER_PLAT)
# env._set_duration_interval()
#
# env.mozi_service.set_run_mode()
# env.mozi_service.set_simulate_compression(env.simulate_compression)
# env.mozi_service.set_compression_mode(False)
# env._run_simulate()
all_info_dic = env.reset()
print(all_info_dic)
def createSymbolTable(self, srcfile):
info("Processing %s" % srcfile)
self._symtab, errcount = buildSymbolTable(srcfile,
self._symtab,
verbose=self._verbose)
def show_item_info(dic):
for key in dic:
pylog.info("%s:%s" % (key, dic[key]))
def warnnig(self):
file = open('logs/%s.wrapper' % (datetime.datetime.now().date()),'a+',encoding='utf-8')
file.writelines('### %s |warn| %s\n' % (datetime.datetime.now(),str(self)))
file.close()
def error(self):
file = open('logs/%s.wrapper' % (datetime.datetime.now().date()),'a+',encoding='utf-8')
file.writelines('### %s |erro| %s\n' % (datetime.datetime.now(),str(self)))
file.close()
'''
file_pwd = 'D:/software/apache-tomcat-7.0.85_64/webapps/sysinfo'
#路径是否存在
if os.path.isdir(file_pwd):
print('path %s exist!' % (file_pwd))
pylog.info(file_pwd, 'exist')
else:
os.makedirs(file_pwd)
#文件是否存在
if os.path.exists(file_pwd + 'index.html'):
pass
else:
try:
os.system('type nul > %s/index.html' % (file_pwd))
print('index')
pylog.info('index')
except Exception as e:
print('error!', e)
pylog.error(e)
process_mysql = os.popen('tasklist | findstr mysql').readlines()
