def main():
for r in range(1, 10):
for p in range(1, 10):
print Scenario.countscenarios(r, p, 1),
print pascal(cn(r, 1) + p - 1, p),
print
print
def __init__(self, f, cash=0):
self.family = f # ?
self.cash = cash # ?
self.ritems = []
self.S = Scenario(f)
self.inflation = 1.03
# Make our Summary 'columns'
RSummary("Inc")
RSummary("Exp")
RSummary("Inv")
def create_scenarios(self):
for pathId in range(0, len(self.pathList)):
scenario = Scenario(pathId + 1, '', [], self.control_words)
for edge in self.pathList[pathId]:
scenario.add_step(edge.label,
self.get_node_label(edge.destinationNode))
self.scenariosList.append(scenario)
def run(self):
filename = sys.argv[1].decode("utf-8") if len(sys.argv) > 1 else None
if not filename:
filename = os.path.join(
os.path.dirname(sys.argv[0].decode("utf-8")), "config.yaml")
with open(filename, "r") as f:
config = yaml.safe_load(f)
root_path = os.path.dirname(filename.encode("utf-8"))
(w, h) = (config.get("screen").get("size")[0],
config.get("screen").get("size")[1])
(x, y) = (w / 2, h / 2)
Media.Music.init()
pygame.init()
# pygame.display.set_mode((w, h),pygame.FULLSCREEN,32)
pygame.display.set_mode((w, h), pygame.DOUBLEBUF, 32)
screen = pygame.display.get_surface()
pygame.display.set_caption(
os.path.basename(os.path.dirname(filename.encode("utf-8"))))
pygame.display.update()
image_cache = Media.ImageCache(screen)
while True:
scenario = Scenario.Scenario(root_path, config)
self.title(scenario, screen, image_cache)
self.execute_scenario(scenario, screen, image_cache)
def createScenarioFromSpirentFile(SVNum,CNO=38,Quantize=False):
Jerk = 100
dT = 0.001
satelliteDict = Scenario.readSimulatorMotionFile()
motionList = []
Time,losX,losY,losZ = satelliteDict[SVNum]
Time/=1000
pseudorange = np.sqrt(losX**2+losY**2+losZ**2)
velocity = np.diff(pseudorange)
velocity-=velocity[0]
acceleration = np.diff(velocity)
pseudorange = pseudorange[:-2]
velocity = velocity[:-1]
T = Time[:-2]
for i in range(0,acceleration.size):
time = Time[i]
targetAcceleration = acceleration[i]
motionList.append(motion(time,targetAcceleration,Jerk))
TMin = Time[0]
TMax = Time[-1]
initialState = [0, 0, acceleration[0]]
T,stateHistory = GenerateTrajectory(TMin, TMax, initialState, motionList,dT)
if Quantize==True:
stateHistory = quantizeSpirentStateHistory(T,stateHistory)
SignalIn = GenerateSignal(T,stateHistory,CNO)
return(T,SignalIn,stateHistory)
def GetConfig(path):
cfg = configparser.ConfigParser()
cfg.read(path)
name = cfg.get('Project', 'name')
setup = cfg.get('Project', 'setup')
scenario_count = cfg.get('Project', 'scenario_count')
scenarios = []
for i in range(int(scenario_count)):
scen = Scenario.Scenario('scenario_' + str(i))
scen.SetScenario(cfg)
scenarios.append(scen)
with open(join(info_dir,setup), 'r') as setup:
setup_file = setup.read()
config = {
'name' : name,
'setup' : setup_file,
'scenario_count' : scenario_count,
'scenarios' : scenarios
}
return config
def test_scenario_getSteps(self):
control_words = ControllWords.ControlWords(Output.Output())
steps = [Step.Step(7, "abc\n\code: ghi", "def\n\code:jkl", control_words)]
scenario = Scenario.Scenario(3, "scn", steps, control_words)
self.assertEqual(scenario.get_steps(), [scenario.steps[0]])
def test_scenario_init(self):
control_words = ControllWords.ControlWords(Output.Output())
steps = [Step.Step(7, "abc\n\code: ghi", "def\n\code:jkl", control_words)]
scenario = Scenario.Scenario(3, "scn", steps, control_words)
self.assertEqual(scenario.id, 3)
self.assertEqual(scenario.name, "scn")
self.assertEqual(scenario.steps, steps)
def test_scenario_addStep(self):
control_words = ControllWords.ControlWords(Output.Output())
steps = [Step.Step(7, "abc\n\code: ghi", "def\n\code:jkl", control_words)]
scenario = Scenario.Scenario(3, "scn", steps, control_words)
scenario.add_step("act", "nod")
self.assertEqual(scenario.steps[1].action.description, ["act"])
self.assertEqual(scenario.steps[1].node.description, ["nod"])
def verify(p,c,maxproc=2,timeout=None):
for m in p.models:
t = None
comment = "MaxProc%i" % maxproc
if m == "Traces":
t = Test.Test(p.name,c,p.toolname,m,timeout=timeout,comment=comment)
elif m == "MaxProc":
t = Test.Test(p.name,c,p.toolname,m,maxproc,timeout=timeout,comment=comment)
elif m == "Scen":
agents = getAgents(c)
sl = Scenario.ScenarioSet(p.roleCount(),maxproc,fill=True,agentcount=agents).list
t = Test.Test(p.name,c,p.toolname,m,sl,timeout=timeout,comment=comment)
elif m == "RepScen":
agents = getAgents(c)
ss = Scenario.ScenarioSet(p.roleCount(),1,fill=True,agentcount=agents)
ss.cover()
sl = ss.list
t = Test.Test(p.name,c,p.toolname,m,sl,timeout=timeout,comment=comment)
if t:
Report.report(t)
def compareRecievers():
channelDict = Scenario.readNMEAFile()
satelliteDict = Scenario.readSimulatorMotionFile()
startTime = 406800 #second of week
CNO = 48
PLLBW = 2
FLLBW = 10
for SVNum in [1,3,6,11,16,18,19,22,31]:
T,SignalIn,stateHistory = \
GenSignal.createScenarioFromSpirentFile(SVNum,CNO)
coherentIntegrationTime = 4
numOutputSamples = T.size/coherentIntegrationTime
print('Running Reciever')
Z,DcoFreqArray,LockStateValues,PhaseError = \
runReceiver(T,SignalIn,18,FLLBW)
PolarisFreq = DcoFreqArray[500:1000]
plt.plot(PolarisFreq,'r')
plt.ylabel('Doppler Shift (Hz)')
plt.xlabel('Time (s)')
plt.ylim(-4,4)
plt.title('Bn=18Hz')
plt.savefig(str(SVNum)+'18Polaris.eps',format='eps', dpi=1000)
plt.close()
Z,DcoFreqArray,LockStateValues,PhaseError = \
runReceiver(T,SignalIn,32,FLLBW)
PolarisFreq = DcoFreqArray[500:1000]
plt.plot(PolarisFreq,'r')
plt.ylim(-4,4)
plt.ylabel('Doppler Shift (Hz)')
plt.xlabel('Time (s)')
plt.title('Bn=32Hz')
plt.savefig(str(SVNum)+'32Polaris.eps',format='eps', dpi=1000)
plt.close()
def test_scenario_get_id(self):
control_words = ControllWords.ControlWords(Output.Output())
steps = [Step.Step(7, "abc\n\code: ghi", "def\n\code:jkl", control_words)]
scenario1 = Scenario.Scenario(1, "scn", steps, control_words)
scenario9 = Scenario.Scenario(9, "scn", steps, control_words)
scenario10 = Scenario.Scenario(10, "scn", steps, control_words)
scenario99 = Scenario.Scenario(99, "scn", steps, control_words)
scenario100 = Scenario.Scenario(100, "scn", steps, control_words)
scenario999 = Scenario.Scenario(999, "scn", steps, control_words)
scenario1000 = Scenario.Scenario(1000, "scn", steps, control_words)
scenario9999 = Scenario.Scenario(9999, "scn", steps, control_words)
self.assertEqual(scenario1.get_id_str(), '0001')
self.assertEqual(scenario9.get_id_str(), '0009')
self.assertEqual(scenario10.get_id_str(), '0010')
self.assertEqual(scenario99.get_id_str(), '0099')
self.assertEqual(scenario100.get_id_str(), '0100')
self.assertEqual(scenario999.get_id_str(), '0999')
self.assertEqual(scenario1000.get_id_str(), '1000')
self.assertEqual(scenario9999.get_id_str(), '9999')
def solve(self):
""" Run storageVET
Returns: the Results class
"""
starts = time.time()
if Params.storagevet_requirement_check():
for key, value in self.case_dict.items():
run = Scenario.Scenario(value)
run.add_technology()
run.add_services()
run.init_financials(value.Finance)
run.add_control_constraints()
run.optimize_problem_loop()
Result.add_instance(
key, run) # cost benefit analysis is in the Result class
Result.sensitivity_summary()
ends = time.time()
print("Full runtime: " + str(ends - starts)) if self.verbose else None
return Result
config = yaml.safe_load(f)
root_path = os.path.dirname(filename.encode("utf-8"))
(w, h) = (config.get("screen").get("size")[0],
config.get("screen").get("size")[1])
(x, y) = (w / 2, h / 2)
Media.Music.init()
pygame.init()
# pygame.display.set_mode((w, h),pygame.FULLSCREEN,32)
pygame.display.set_mode((w, h), pygame.DOUBLEBUF, 32)
screen = pygame.display.get_surface()
pygame.display.set_caption(
os.path.basename(os.path.dirname(filename.encode("utf-8"))))
pygame.display.update()
image_cache = Media.ImageCache(screen)
while True:
scenario = Scenario.Scenario(root_path, config)
self.title(scenario, screen, image_cache)
self.execute_scenario(scenario, screen, image_cache)
if 0:
scenario = Scenario.Scenario()
for f in scenario.run():
print(f)
else:
gui = GUI()
gui.run()
else:
raise Exception, ("Don't know claim %s" % claim)
prot += """
end goal
environment()
"""
return (prot, "")
def registerall():
Protocol.register(eke_hlpsl("ofmc", ["Scen"]))
Protocol.register(eke_hlpsl("satmc", ["Scen"]))
Protocol.register(eke_hlpsl("cl-atse", ["Scen"]))
Protocol.register(eke_hlpsl("ta4sp", ["RepScen"]))
registerall()
if __name__ == "__main__":
import Scenario
sl = Scenario.genall(2, 2, 1)
x = eke_hlpsl("ofmc", ["Scen"])
(prot, args) = x.generate("Scen", "sAk", sl[1])
print prot
print args
def __init__(self, log_flag):
self.logger = Logger(log_flag, LOG_FILE);
self.logger.info('Started Domoleaf Master Daemon');
self.d3config = {};
self.aes_slave_keys = {};
self.aes_master_key = None
self.connected_clients = {};
self.sql = MasterSql();
self._parser = DaemonConfigParser(MASTER_CONF_FILE);
self.db_username = self._parser.getValueFromSection(MASTER_CONF_MYSQL_SECTION, MASTER_CONF_MYSQL_USER_ENTRY);
self.db_passwd = self._parser.getValueFromSection(MASTER_CONF_MYSQL_SECTION, MASTER_CONF_MYSQL_PASSWORD_ENTRY);
self.db_dbname = self._parser.getValueFromSection(MASTER_CONF_MYSQL_SECTION, MASTER_CONF_MYSQL_DB_NAME_ENTRY);
self.get_aes_slave_keys(0);
self.reload_camera(None, None, 0);
self._scanner = Scanner();
self.hostlist = [];
self.hostlist.append(Host('', '127.0.0.1', socket.gethostname().upper()));
self.knx_manager = KNXManager(self.aes_slave_keys);
self.enocean_manager = EnOceanManager(self.aes_slave_keys);
self.reload_d3config(None, None, 0);
self.trigger = Trigger(self);
self.scenario = Scenario(self);
self.schedule = Schedule(self);
self.calcLogs = CalcLogs(self);
self.functions = {
1 : self.knx_manager.send_knx_write_short_to_slave,
2 : self.knx_manager.send_knx_write_long_to_slave,
3 : self.knx_manager.send_knx_write_speed_fan,
4 : self.knx_manager.send_knx_write_temp,
5 : IP_IRManager().send_to_gc,
6 : self.knx_manager.send_on,
7 : self.knx_manager.send_to_thermostat,
8 : self.knx_manager.send_clim_mode,
9 : HttpReq().http_action,
10 : self.upnp_audio,
11 : self.knx_manager.send_knx_write_percent,
12 : self.knx_manager.send_off,
13 : self.knx_manager.send_knx_write_short_to_slave_r,
};
self.data_function = {
DATA_MONITOR_KNX : self.monitor_knx,
DATA_MONITOR_IP : self.monitor_ip,
DATA_MONITOR_ENOCEAN : self.monitor_enocean,
DATA_MONITOR_BLUETOOTH : self.monitor_bluetooth,
DATA_KNX_READ : self.knx_read,
DATA_KNX_WRITE_S : self.knx_write_short,
DATA_KNX_WRITE_L : self.knx_write_long,
DATA_SEND_TO_DEVICE : self.send_to_device,
DATA_CRON_UPNP : self.cron_upnp,
DATA_SEND_MAIL : self.send_mail,
DATA_MODIF_DATETIME : self.modif_datetime,
DATA_CHECK_SLAVE : self.check_slave,
DATA_RELOAD_CAMERA : self.reload_camera,
DATA_RELOAD_D3CONFIG : self.reload_d3config,
DATA_BACKUP_DB_CREATE_LOCAL : self.backup_db_create_local,
DATA_BACKUP_DB_REMOVE_LOCAL : self.backup_db_remove_local,
DATA_BACKUP_DB_LIST_LOCAL : self.backup_db_list_local,
DATA_BACKUP_DB_RESTORE_LOCAL : self.backup_db_restore_local,
DATA_CHECK_USB : self.check_usb,
DATA_BACKUP_DB_CREATE_USB : self.backup_db_create_usb,
DATA_BACKUP_DB_REMOVE_USB : self.backup_db_remove_usb,
DATA_BACKUP_DB_LIST_USB : self.backup_db_list_usb,
DATA_BACKUP_DB_RESTORE_USB : self.backup_db_restore_usb,
DATA_SMARTCMD_LAUNCH : self.smartcmd_launch,
DATA_TRIGGERS_LIST_UPDATE : self.triggers_list_update,
DATA_SCHEDULES_LIST_UPDATE : self.schedules_list_update,
DATA_SCENARIOS_LIST_UPDATE : self.scenarios_list_update,
DATA_CHECK_ALL_SCHEDULES : self.check_schedules,
DATA_CALC_LOGS : self.launch_calc_logs,
DATA_CHECK_UPDATES : self.check_updates,
DATA_UPDATE : self.update,
DATA_SEND_ALIVE : self.send_request,
DATA_SEND_TECH : self.send_tech,
DATA_SEND_INTERFACES : self.send_interfaces,
DATA_SHUTDOWN_D3 : self.shutdown_d3,
DATA_REBOOT_D3 : self.reboot_d3,
DATA_WIFI_UPDATE : self.wifi_update,
DATA_REMOTE_SQL : self.remote_sql
};
#!/usr/bin/env python
import Scenario
import Perso
import utils as u
if __name__ == "__main__":
u.clear()
u.splash()
c = input("o-]===> ")
u.clear()
if c == "1":
print("Mode non disponible")
elif c == "3":
pass
else:
u.game_init()
Scenario.Scenario(Perso.Perso(), 0)
#Equivalences
forall AA, BB : Agent . P(AA,BB) = P(BB,AA)
#System
%s
INITIATOR(Alice, K1, K2, Na)
RESPONDER(Alice, R, Nb)
#Intruder Information
Intruder = Mallory
IntruderKnowledge = {A, B, Mallory, Nm, Km1, Km2, Rm, P(Alice, Mallory), P(Bob,Mallory)}
""" % (narrstr, pubkeydef, seckeydef, invkeydef, scenstr)
return (prot, "")
Protocol.register(eke_spl("casperfdr", ["Scen"]))
if __name__ == "__main__":
import Scenario
sl = Scenario.genall(2, 5, 1)
x = eke_spl("casperfdr", ["Scen"])
(prot, args) = x.generate("Scen", "sBk", sl[7])
print prot
print args
class Portfolio: # or should just be a global
def __init__(self, f, cash=0):
self.family = f # ?
self.cash = cash # ?
self.ritems = []
self.S = Scenario(f)
self.inflation = 1.03
# Make our Summary 'columns'
RSummary("Inc")
RSummary("Exp")
RSummary("Inv")
# TODO: Take out Portfolio ritems ; now all ritems are stored only in Summary columns
def ritemsAppend(self,r):
#self.ritems.append(r)
pass
def cash(self):
return self.cash;
def netWorth(self):
#print("cash:${} Inc:${} Inv:${} Exp:${}".format( self.cash, RSummary.value("Inc") , RSummary.value("Inv") , RSummary.value("Exp") ))
return self.cash + RSummary.value("Inc") + RSummary.value("Inv") - RSummary.value("Exp")
def summaryString(self):
return "c= ${} ${} e= ${} i=${:.0f} ==> ${:.0f}".format(self.cash, RSummary.value("Inc"), RSummary.value("Exp"), RSummary.value("Inv"), self.netWorth())
def run(self,startYear,endYear):
logging.debug("INIT: {}".format(self.summaryString()))
for y in range(startYear, endYear+1):
self.S.addYear(y)
logging.debug("Starting: {}".format(y))
for sname in RSummary._sumItems:
for r in RSummary._sumItems[sname].ritems:
#logging.debug("...doing item: {}".format(r.name))
# each "event" is a value ?? or a transfer and a value??
r.reset()
r.currentYear = y # used for various Ritems, e.g. expenseInflation
for e in r.events:
if (e.year == y):
#logging.debug ("... run event: {}".format(e.name))
e.func(r)
# after all the events are done
self.S.addColVal(r.name, y,r.value)
#r.sumToSummary()
self.S.addColVal(sname,y,RSummary.value(sname))
logging.debug("{}: {}".format(y, self.summaryString()))
# TODO: somehow make NetW and Cash columns like RSummary, so no special adding here
self.S.addColVal('NetW',y,self.netWorth())
self.cash += RSummary.value("Inc") - RSummary.value("Exp");
self.S.addColVal('Cash',y,self.cash)
# hack
self.S.ritemLists( RSummary._sumItems["Inc"].ritems, RSummary._sumItems["Exp"].ritems, RSummary._sumItems["Inv"].ritems )
def runTilEnd(self,startYear):
self.run(startYear,self.family.lastYear())
from Tools import *
from Scenario import *
from NSGA import *
from Evolution import *
import matplotlib.pyplot as plt
tool_box = Tools()
flow_data = tool_box.read_flow_data_from_txt()
loc_data = tool_box.read_loc_data_from_txt()
time_data = tool_box.read_slot_data_from_txt()
scenario = Scenario(flow_data, loc_data, time_data)
# scenario.generate_initial_solution()
print 'scenario generated'
problem = NSGA_problem(scenario)
evolve = Evolution(problem, 50, 100)
selected_individuals = evolve.evolve()
f = open('gene.txt', 'w')
for i in selected_individuals:
s = ''
for g in i.features:
s = s + ',' + str(g)
f.write(s + '\n')
f.close()
x = [problem.f1(i) for i in selected_individuals]
y = [problem.f2(i) for i in selected_individuals]
print x, y
plt.plot(x, y, 'ro')
plt.show()
class MasterDaemon:
"""
Main class of the master daemon
It provides communication between master and slave boxes and a part of the database management
"""
def __init__(self, log_flag):
self.logger = Logger(log_flag, LOG_FILE);
self.logger.info('Started Domoleaf Master Daemon');
self.d3config = {};
self.aes_slave_keys = {};
self.aes_master_key = None
self.connected_clients = {};
self.sql = MasterSql();
self._parser = DaemonConfigParser(MASTER_CONF_FILE);
self.db_username = self._parser.getValueFromSection(MASTER_CONF_MYSQL_SECTION, MASTER_CONF_MYSQL_USER_ENTRY);
self.db_passwd = self._parser.getValueFromSection(MASTER_CONF_MYSQL_SECTION, MASTER_CONF_MYSQL_PASSWORD_ENTRY);
self.db_dbname = self._parser.getValueFromSection(MASTER_CONF_MYSQL_SECTION, MASTER_CONF_MYSQL_DB_NAME_ENTRY);
self.get_aes_slave_keys(0);
self.reload_camera(None, None, 0);
self._scanner = Scanner();
self.hostlist = [];
self.hostlist.append(Host('', '127.0.0.1', socket.gethostname().upper()));
self.knx_manager = KNXManager(self.aes_slave_keys);
self.enocean_manager = EnOceanManager(self.aes_slave_keys);
self.reload_d3config(None, None, 0);
self.trigger = Trigger(self);
self.scenario = Scenario(self);
self.schedule = Schedule(self);
self.calcLogs = CalcLogs(self);
self.functions = {
1 : self.knx_manager.send_knx_write_short_to_slave,
2 : self.knx_manager.send_knx_write_long_to_slave,
3 : self.knx_manager.send_knx_write_speed_fan,
4 : self.knx_manager.send_knx_write_temp,
5 : IP_IRManager().send_to_gc,
6 : self.knx_manager.send_on,
7 : self.knx_manager.send_to_thermostat,
8 : self.knx_manager.send_clim_mode,
9 : HttpReq().http_action,
10 : self.upnp_audio,
11 : self.knx_manager.send_knx_write_percent,
12 : self.knx_manager.send_off,
13 : self.knx_manager.send_knx_write_short_to_slave_r,
};
self.data_function = {
DATA_MONITOR_KNX : self.monitor_knx,
DATA_MONITOR_IP : self.monitor_ip,
DATA_MONITOR_ENOCEAN : self.monitor_enocean,
DATA_MONITOR_BLUETOOTH : self.monitor_bluetooth,
DATA_KNX_READ : self.knx_read,
DATA_KNX_WRITE_S : self.knx_write_short,
DATA_KNX_WRITE_L : self.knx_write_long,
DATA_SEND_TO_DEVICE : self.send_to_device,
DATA_CRON_UPNP : self.cron_upnp,
DATA_SEND_MAIL : self.send_mail,
DATA_MODIF_DATETIME : self.modif_datetime,
DATA_CHECK_SLAVE : self.check_slave,
DATA_RELOAD_CAMERA : self.reload_camera,
DATA_RELOAD_D3CONFIG : self.reload_d3config,
DATA_BACKUP_DB_CREATE_LOCAL : self.backup_db_create_local,
DATA_BACKUP_DB_REMOVE_LOCAL : self.backup_db_remove_local,
DATA_BACKUP_DB_LIST_LOCAL : self.backup_db_list_local,
DATA_BACKUP_DB_RESTORE_LOCAL : self.backup_db_restore_local,
DATA_CHECK_USB : self.check_usb,
DATA_BACKUP_DB_CREATE_USB : self.backup_db_create_usb,
DATA_BACKUP_DB_REMOVE_USB : self.backup_db_remove_usb,
DATA_BACKUP_DB_LIST_USB : self.backup_db_list_usb,
DATA_BACKUP_DB_RESTORE_USB : self.backup_db_restore_usb,
DATA_SMARTCMD_LAUNCH : self.smartcmd_launch,
DATA_TRIGGERS_LIST_UPDATE : self.triggers_list_update,
DATA_SCHEDULES_LIST_UPDATE : self.schedules_list_update,
DATA_SCENARIOS_LIST_UPDATE : self.scenarios_list_update,
DATA_CHECK_ALL_SCHEDULES : self.check_schedules,
DATA_CALC_LOGS : self.launch_calc_logs,
DATA_CHECK_UPDATES : self.check_updates,
DATA_UPDATE : self.update,
DATA_SEND_ALIVE : self.send_request,
DATA_SEND_TECH : self.send_tech,
DATA_SEND_INTERFACES : self.send_interfaces,
DATA_SHUTDOWN_D3 : self.shutdown_d3,
DATA_REBOOT_D3 : self.reboot_d3,
DATA_WIFI_UPDATE : self.wifi_update,
DATA_REMOTE_SQL : self.remote_sql
};
def get_aes_slave_keys(self, db):
"""
Get the secretkeys of each slave daemon stored in database
"""
query = "SELECT serial, secretkey FROM daemon";
res = self.sql.mysql_handler_personnal_query(query, db);
self_hostname = socket.gethostname();
for r in res:
if SLAVE_NAME_PREFIX in r[0] or 'MD3' in r[0]:
self.aes_slave_keys[r[0]] = r[1];
elif self_hostname == r[0]:
self.aes_slave_keys[r[0]] = r[1];
self.aes_master_key = r[1];
def stop(self):
"""
Stops the daemon and closes sockets
"""
flag = False;
while not flag:
flag = True;
for client in self.connected_clients.values():
flag = False;
client.close();
break;
self.slave_connection.close();
sys.exit(0);
def run(self):
"""
Initialization of the connections and accepting incomming communications
"""
self.slave_connection = socket.socket(socket.AF_INET, socket.SOCK_STREAM);
self.cmd_connection = socket.socket(socket.AF_INET, socket.SOCK_STREAM);
self.slave_connection.setsockopt(socket.IPPROTO_TCP, socket.TCP_NODELAY, 1);
self.cmd_connection.setsockopt(socket.IPPROTO_TCP, socket.TCP_NODELAY, 1);
self.slave_connection.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1);
self.cmd_connection.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1);
s_port = self._parser.getValueFromSection(MASTER_CONF_LISTEN_SECTION, MASTER_CONF_LISTEN_PORT_SLAVE_ENTRY);
c_port = self._parser.getValueFromSection(MASTER_CONF_LISTEN_SECTION, MASTER_CONF_LISTEN_PORT_CMD_ENTRY);
if not s_port:
frameinfo = getframeinfo(currentframe());
self.logger.error('in run: No slave listening port defined in '+MASTER_CONF_FILE);
sys.exit(1);
if not c_port:
frameinfo = getframeinfo(currentframe());
self.logger.error('in run: No command listening port defined in '+MASTER_CONF_FILE);
sys.exit(1);
self.slave_connection.bind(('', int(s_port)));
self.slave_connection.listen(MAX_SLAVES);
self.cmd_connection.bind(('', int(c_port)));
self.cmd_connection.listen(MAX_CMDS);
self.loop();
def loop(self):
"""
Main loop. Waits for new connections.
"""
self.run = True;
while self.run:
try:
rlist, wlist, elist = select.select([self.slave_connection], [], [], SELECT_TIMEOUT);
for connection in rlist:
self.accept_new_slave_connection(connection);
rlist, wlist, elist = select.select([self.cmd_connection], [], [], SELECT_TIMEOUT);
for connection in rlist:
self.accept_new_cmd_connection(connection);
except KeyboardInterrupt as e:
frameinfo = getframeinfo(currentframe());
self.logger.info('in loop: Keyboard interrupt: leaving program');
print("[ MASTER DAEMON ",frameinfo.filename,":",str(frameinfo.lineno)," ]: Keyboard Interrupt");
self.stop();
sys.exit(0);
except ValueError as e:
frameinfo = getframeinfo(currentframe());
self.logger.error('in loop: Value error: '+str(e));
print("[ MASTER DAEMON ",frameinfo.filename,":",str(frameinfo.lineno),"]: Value Error");
print(e);
pass;
def accept_new_cmd_connection(self, connection):
"""
Gets new domoleaf connections and threads the treatment.
"""
new_connection, addr = connection.accept();
r = CommandReceiver(new_connection, self);
r.start();
def accept_new_slave_connection(self, connection):
"""
Gets new slave connections and threads the treatment.
"""
new_connection, addr = connection.accept();
myname = socket.gethostname();
try:
name = socket.gethostbyaddr(addr[0])[0]
except socket.error as serr:
name = 'localhost'
if name == 'localhost':
name = myname
name = name.split('.')[0];
r = SlaveReceiver(new_connection, name, self);
r.start();
def parse_data(self, data, connection, daemon_id, db):
"""
Once data are received whether from domoleaf or slave, the function of the packet_type in data is called.
"""
json_obj = json.JSONDecoder().decode(data);
json_obj['daemon_id'] = daemon_id;
if json_obj['packet_type'] in self.data_function.keys():
self.data_function[json_obj['packet_type']](json_obj, connection, db);
else:
frameinfo = getframeinfo(currentframe());
def check_updates(self, json_obj, connection, db):
query = 'SELECT configuration_value FROM configuration WHERE configuration_id=4';
actual_version = self.sql.mysql_handler_personnal_query(query, db);
if not actual_version:
self.logger.error("CHECK_UPDATE : No Master Version");
return;
query = 'UPDATE configuration SET configuration_value="" WHERE configuration_id=13';
self.sql.mysql_handler_personnal_query(query, db);
p = call(['dpkg', '--configure', '-a'])
p = Popen(['apt-get', 'update'], stdin=PIPE, stdout=PIPE, stderr=PIPE, bufsize=-1);
output, error = p.communicate();
p = Popen(['apt-show-versions', '-u', 'domomaster'], stdin=PIPE, stdout=PIPE, stderr=PIPE, bufsize=-1);
output, error = p.communicate();
if not p.returncode:
tab = output.decode("utf-8").split(" ");
version = tab[-1].rsplit("\n")[0];
else:
version = actual_version[0][0];
query = ''.join(['UPDATE configuration SET configuration_value="', version, '" WHERE configuration_id=13']);
self.sql.mysql_handler_personnal_query(query, db);
def update(self, json_obj, connection, db):
call(['apt-get', 'update']);
p = Popen("DEBIAN_FRONTEND=noninteractive apt-get install domomaster domoslave -y ",
shell=True, stdin=None, stdout=False, stderr=False,executable="/bin/bash");
output, error = p.communicate();
hostname = socket.gethostname();
if '.' in hostname:
hostname = hostname.split('.')[0];
version = os.popen("dpkg-query -W -f='${Version}\n' domomaster").read().split('\n')[0];
query = ''.join(['UPDATmon SET version="', version, '" WHERE name="', hostname, '"' ]);
self.sql.mysql_handler_personnal_query(query, db);
query = ''.join(['UPDATE configuration SET configuration_value="', version, '" WHERE configuration_id=4']);
self.sql.mysql_handler_personnal_query(query, db);
json_obj['data'].append(hostname);
port = self._parser.getValueFromSection('connect', 'port');
for host in self.hostlist:
if (host._Hostname.startswith('MD3') or host._Hostname.startswith('SD3')) and host._Hostname not in json_obj['data']:
sock = socket.create_connection((host._IpAddr, port));
json_str = json.JSONEncoder().encode(json_obj);
sock.send(bytes(json_str, 'utf-8'));
data = sock.recv(4096);
decrypt_IV = data[:16].decode();
decode_obj = AES.new(self.aes_master_key, AES.MODE_CBC, decrypt_IV);
data2 = decode_obj.decrypt(data[16:]).decode();
version = data2['new_version'];
query = ''.join(['UPDATE daemon SET version="', version, '" WHERE name="', host._Hostname, '"']);
self.sql.mysql_handler_personnal_query(query, db);
sock.close();
def backup_db_create_local(self, json_obj, connection, db):
path = '/etc/domoleaf/sql/backup/';
filename = 'domoleaf_backup_';
t = str(time.time());
if '.' in t:
t = t.split('.')[0];
filename += t+'.sql';
os.system("mysqldump --defaults-file=/etc/mysql/debian.cnf domoleaf > "+path+filename);
os.system('cd '+path+' && tar -czf '+filename+'.tar.gz'+' '+filename);
os.system('rm '+path+filename);
def backup_db_remove_local(self, json_obj, connection, db):
filename = ''.join(['/etc/domoleaf/sql/backup/domoleaf_backup_', str(json_obj['data']), '.sql.tar.gz']);
if str(json_obj['data'][0]) == '.' or str(json_obj['data'][0]) == '/':
self.logger.error('The filename is corrupted. Aborting database file removing.')
return;
try:
os.stat(filename);
except Exception as e:
try:
filename = filename.split('.tar.gz')[0];
os.stat(filename);
except Exception as e:
self.logger.error("The database file to remove does not exists.")
self.logger.error(e)
return;
os.remove(filename);
def backup_db_list_local(self, json_obj, connection, db):
json_obj = [];
append = json_obj.append;
backup_list = os.listdir('/etc/domoleaf/sql/backup/')
for f in backup_list:
s = os.stat('/etc/domoleaf/sql/backup/'+f);
if '.sql' in f:
g = f.split('.sql')[0];
append({"name": g, "size": s.st_size});
json_sorted = sorted(json_obj, key=lambda json_obj: json_obj['name'], reverse=True);
json_str = json.JSONEncoder().encode(json_sorted);
connection.send(bytes(json_str, 'utf-8'));
def backup_db_restore_local(self, json_obj, connection, db):
path = '/etc/domoleaf/sql/backup/';
filename = ''.join(['domoleaf_backup_', str(json_obj['data']), '.sql.tar.gz']);
if json_obj['data'][0] == '.' or json_obj['data'][0] == '/':
self.logger.error('The filename is corrupted. Aborting database restoring.')
return;
try:
os.stat(path+filename);
os.system('cd '+path+' && tar -xzf '+filename);
os.system('mysql --defaults-file=/etc/mysql/debian.cnf domoleaf < '+path+filename.split('.tar.gz')[0]);
os.system('rm '+path+filename.split('.tar.gz')[0]);
return;
except Exception as e:
try:
filename = filename.split('.tar.gz')[0];
os.stat(path+filename);
except Exception as e:
self.logger.error("The database file to restore does not exists.");
self.logger.error(e);
return;
os.system('mysql --defaults-file=/etc/mysql/debian.cnf domoleaf < '+path+filename);
def check_usb(self, json_obj, connection, db):
try:
sdx1 = glob.glob('/dev/sd?1')[0];
except Exception as e:
return;
if not (os.path.exists(sdx1)):
json_obj = 0;
else:
json_obj = 1;
json_str = json.JSONEncoder().encode(json_obj);
connection.send(bytes(json_str, 'utf-8'));
def backup_db_list_usb(self, json_obj, connection, db):
json_obj = [];
append = json_obj.append
sdx1 = glob.glob('/dev/sd?1')[0];
if not (os.path.exists(sdx1)):
return;
os.system('mount '+sdx1+' /etc/domoleaf/mnt');
os.system('mkdir -p /etc/domoleaf/mnt/backup');
backup_list = os.listdir('/etc/domoleaf/mnt/backup/')
for f in backup_list:
s = os.stat('/etc/domoleaf/mnt/backup/'+f);
if '.sql' in f:
g = f.split('.sql')[0];
append({"name": g, "size": s.st_size});
os.system('umount /etc/domoleaf/mnt');
json_sorted = sorted(json_obj, key=lambda json_obj: json_obj['name'], reverse=True);
json_str = json.JSONEncoder().encode(json_sorted);
connection.send(bytes(json_str, 'utf-8'));
def backup_db_remove_usb(self, json_obj, connection, db):
filename = ''.join(['/etc/domoleaf/mnt/backup/domoleaf_backup_', str(json_obj['data']), '.sql.tar.gz']);
if str(json_obj['data'][0]) == '.' or str(json_obj['data'][0]) == '/':
self.logger.error('The filename is corrupted. Aborting database file removing.')
return;
sdx1 = glob.glob('/dev/sd?1')[0];
if not (os.path.exists(sdx1)):
return;
os.system('mount '+sdx1+' /etc/domoleaf/mnt');
path = '/etc/domoleaf/mnt/backup/';
try:
os.stat(filename);
except Exception as e:
try:
filename = filename.split('.tar.gz')[0];
os.stat(filename);
except Exception as e:
self.logger.error("The database file to remove does not exists.")
self.logger.error(e)
os.system('umount /etc/domoleaf/mnt');
return;
os.remove(filename);
os.system('umount /etc/domoleaf/mnt');
def backup_db_restore_usb(self, json_obj, connection, db):
path = '/etc/domoleaf/mnt/backup/';
filename = ''.join(['domoleaf_backup_', str(json_obj['data']), '.sql']);
if json_obj['data'][0] == '.' or json_obj['data'][0] == '/':
self.logger.error('The filename is corrupted. Aborting database restoring.')
return;
sdx1 = glob.glob('/dev/sd?1')[0];
if not (os.path.exists(sdx1)):
return;
os.system('mount '+sdx1+' /etc/domoleaf/mnt');
try:
os.stat(path+filename);
os.system('cp '+path+filename+' /tmp/ && umount /etc/domoleaf/mnt && cd /tmp/');
os.system('mysql --defaults-file=/etc/mysql/debian.cnf domoleaf < /tmp/'+filename);
os.remove('/tmp/'+filename);
return;
except Exception as e:
try:
filename += '.tar.gz';
os.stat(path+filename);
os.system('cp '+path+filename+' /tmp/ && umount /etc/domoleaf/mnt && cd /tmp/ && tar -xzf '+filename);
except Exception as e:
self.logger.error("The database file to restore does not exists.");
self.logger.error(e);
os.system('umount /etc/domoleaf/mnt');
return;
os.system('umount /etc/domoleaf/mnt');
os.system('mysql --defaults-file=/etc/mysql/debian.cnf domoleaf < /tmp/'+filename.split('.tar.gz')[0]);
os.remove('/tmp/'+filename);
os.remove('/tmp/'+filename.split('.tar.gz')[0]);
def backup_db_create_usb(self, json_obj, connection, db):
sdx1 = glob.glob('/dev/sd?1')[0];
if not (os.path.exists(sdx1)):
return;
os.system('mount '+sdx1+' /etc/domoleaf/mnt');
path = '/etc/domoleaf/mnt/backup/';
filename = 'domoleaf_backup_';
os.system('mkdir -p '+path);
t = str(time.time());
if '.' in t:
t = t.split('.')[0];
filename += t+'.sql';
os.system("mysqldump --defaults-file=/etc/mysql/debian.cnf domoleaf > "+path+filename);
os.system('cd '+path+' && tar -czf '+filename+'.tar.gz'+' '+filename);
os.system('rm '+path +filename);
os.system('umount /etc/domoleaf/mnt');
def monitor_knx(self, json_obj, connection, db):
"""
Callback called each time a monitor_knx packet is received.
Updates room_device_option values in the database and check scenarios.
"""
daemon_id = self.sql.update_knx_log(json_obj, db);
doList = self.knx_manager.update_room_device_option(daemon_id, json_obj, db);
if doList:
self.scenario.setValues(self.get_global_state(db), self.trigger, self.schedule, connection, doList);
self.scenario.start();
connection.close();
def knx_write_short(self, json_obj, connection, db):
"""
Callback called each time a knx_write_short packet is received.
Updates room_device_option values in the database.
"""
daemons = self.sql.get_daemons(db);
slave_name = self.get_slave_name(json_obj, daemons);
if slave_name is None:
connection.close();
return None;
dev = {}
dev["addr_dst"] = json_obj['data']['addr']
slave_name = slave_name.split('.')[0];
self.knx_manager.send_knx_write_short_to_slave(json_obj, dev, slave_name);
connection.close();
return None;
def knx_write_long(self, json_obj, connection, db):
"""
Callback called each time a knx_write_long packet is received.
Updates room_device_option values in the database.
"""
daemons = self.sql.get_daemons(db);
slave_name = self.get_slave_name(json_obj, daemons);
if slave_name is None:
connection.close();
return None;
dev = {}
dev["addr_dst"] = json_obj['data']['addr']
slave_name = slave_name.split('.')[0];
self.knx_manager.send_knx_write_long_to_slave(json_obj, dev, slave_name);
connection.close();
return None;
def knx_read(self, json_obj, connection, db):
"""
Callback called each time a knx_read packet is received.
"""
daemons = self.sql.get_daemons(db);
slave_name = self.get_slave_name(json_obj, daemons);
if slave_name is None:
return None;
slave_name = slave_name.split('.')[0];
self.knx_manager.send_knx_read_request_to_slave(slave_name, json_obj);
connection.close();
def monitor_ip(self, json_obj, connection, db):
"""
Callback called each time a monitor_ip packet is received.
A new local network scan is performed and the result stored in the database
"""
self.scanner.scan();
self.sql.insert_hostlist_in_db(self.scanner._HostList, db);
self.hostlist = self.scanner._HostList;
connection.close();
def monitor_bluetooth(self, json_obj, connection, db):
"""
TODO
"""
connection.close();
return None;
def monitor_enocean(self, json_obj, connection, db):
"""
Callback called each time a monitor_enocean packet is received.
Stores the data in enocean_log table.
"""
daemon_id = self.sql.update_enocean_log(json_obj, db);
doList = self.enocean_manager.update_room_device_option(daemon_id, json_obj, db);
connection.close();
if doList:
self.scenario.setValues(self.get_global_state(db), self.trigger, self.schedule, connection, doList);
self.scenario.start();
return None;
def send_to_device(self, json_obj, connection, db):
"""
Retrieves the good device in the database and builds the request to send.
"""
hostname = '';
dm = DeviceManager(int(json_obj['data']['room_device_id']), int(json_obj['data']['option_id']), DEBUG_MODE);
dev = dm.load_from_db(db);
if dev is None:
connection.close();
return ;
if 'daemon_name' in dev:
for host in self.hostlist:
if dev['daemon_name'] == host._Hostname:
hostname = host._Hostname;
break;
function_writing = int(dev['function_writing']);
if (function_writing > 0):
try:
self.functions[function_writing](json_obj, dev, hostname);
except Exception as e:
self.logger.error(e);
connection.close();
def upnp_audio(self, json_obj, dev, hostname):
cmd = UpnpAudio(dev['addr'], int(dev['plus1']));
cmd.action(json_obj);
def get_ip_ifname(self, ifname):
"""
Retrieves network interface name from IP address.
"""
s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM);
try:
res = socket.inet_ntoa(fcntl.ioctl(s.fileno(),
0x8915,
struct.pack('256s', bytes(ifname, 'utf-8')))[20:24]);
return res;
except Exception as e:
frameinfo = getframeinfo(currentframe());
self.logger.error('in get_ip_ifname: '+str(e));
return None;
def cron_upnp(self, json_obj, connection, db):
"""
Callback called each time a cron_upnp packet is received.
"""
local_ip = self.get_ip_ifname("eth0");
if local_ip is None:
connection.close();
return None;
query = "SELECT configuration_id, configuration_value FROM configuration";
res = self.sql.mysql_handler_personnal_query(query);
actions = json_obj['data'];
for act in actions:
if act['action'] == 'open':
for r in res:
if int(r[0]) == int(act['configuration_id']):
if int(r[0]) == 1:
call(["upnpc", "-a", local_ip, str(r[1]), "80", act['protocol']]);
elif int(r[0]) == 2:
call(["upnpc", "-a", local_ip, str(r[1]), "443", act['protocol']]);
elif act['action'] == 'close':
for r in res:
if int(r[0]) == int(act['configuration_id']):
call(["upnpc", "-d", str(r[1]), act['protocol']]);
def reload_camera(self, json_obj, connection, db):
"""
Generation of the file devices.conf located in /etc/domoleaf by default.
"""
camera_file = open(CAMERA_CONF_FILE, 'w');
query = "SELECT room_device_id, addr, plus1 FROM room_device WHERE protocol_id = 6";
res = self.sql.mysql_handler_personnal_query(query, db);
for r in res:
ip = str(r[1]);
if r[1] and utils.is_valid_ip(ip):
camera_file.write("location /device/"+str(r[0]));
camera_file.write("/ {\n")
camera_file.write("\tproxy_buffering off;\n")
camera_file.write("\tproxy_pass http://"+ip);
if str(r[2]).isdigit():
camera_file.write(":"+str(r[2])+"/;\n}\n\n");
else:
camera_file.write(":/;\n}\n\n");
camera_file.close();
call(["service", "nginx", "restart"]);
def reload_d3config(self, json_obj, connection, db):
"""
Loads port config. Reading in database and storing.
"""
query = "SELECT configuration_id, configuration_value FROM configuration";
res = self.sql.mysql_handler_personnal_query(query, db);
for r in res:
self.d3config[str(r[0])] = r[1];
def check_slave(self, json_obj, connection, db):
"""
Asks "check_slave" to the slave described in json_obj and waits for answer.
"""
query = ''.join(["SELECT serial, secretkey FROM daemon WHERE daemon_id=", str(json_obj['data']['daemon_id'])]);
res = self.sql.mysql_handler_personnal_query(query, db);
if res is None or not res:
self.logger.error('in check_slave: No daemon for id '+str(json_obj['data']['daemon_id']));
connection.close();
return ;
elif len(res) > 1:
self.logger.error('in check_slave: Too much daemons for id '+str(json_obj['data']['daemon_id']));
connection.close();
return ;
hostname = res[0][0];
self_hostname = socket.gethostname();
if hostname == self_hostname:
ip = '127.0.0.1';
else:
ip = '';
for h in self.hostlist:
if hostname in h._Hostname.upper():
ip = h._IpAddr;
if not ip:
self.logger.error('in check_slave: '+hostname+' not in hostlist. Try perform network scan again.');
connection.close();
return ;
port = self._parser.getValueFromSection('connect', 'port');
sock = socket.create_connection((ip, port));
if '.' in self_hostname:
self_hostname = self_hostname.split('.')[0];
aes_IV = AESManager.get_IV();
aes_key = self.get_secret_key(hostname);
obj_to_send = ''.join(['{"packet_type": "check_slave", "sender_name": "', self_hostname, '"}']);
encode_obj = AES.new(aes_key, AES.MODE_CBC, aes_IV);
spaces = 16 - len(obj_to_send) % 16;
sock.send(bytes(aes_IV, 'utf-8') + encode_obj.encrypt(obj_to_send + (spaces * ' ')));
rlist, wlist, elist = select.select([sock], [], [], SELECT_TIMEOUT * 10);
val = '0';
version = '';
interface_knx = '';
interface_enocean = '';
data = sock.recv(4096);
if data:
decrypt_IV = data[:16].decode();
decode_obj = AES.new(res[0][1], AES.MODE_CBC, decrypt_IV);
data2 = decode_obj.decrypt(data[16:]).decode();
resp = json.JSONDecoder().decode(data2);
if str(self.aes_slave_keys[hostname]) == str(resp['aes_pass']):
val = '1';
version = resp['version'];
interface_knx = resp['interface_knx'];
interface_enocean = resp['interface_enocean'];
connection.send(bytes(version, 'utf-8'));
connection.close();
query = ''.join(['UPDATE daemon SET validation=', val, ', version="', version, '" WHERE serial="', hostname, '"']);
self.sql.mysql_handler_personnal_query(query, db);
query = ''.join(['UPDATE daemon_protocol SET interface="', interface_knx, '" WHERE daemon_id="', str(json_obj['data']['daemon_id']), '" AND protocol_id="1"']);
self.sql.mysql_handler_personnal_query(query, db);
query = ''.join(['UPDATE daemon_protocol SET interface="', interface_enocean, '" WHERE daemon_id="', str(json_obj['data']['daemon_id']), '" AND protocol_id="2"']);
self.sql.mysql_handler_personnal_query(query, db);
sock.close();
def get_secret_key(self, hostname):
"""
Retrieves the secretkey of 'hostname' in the database.
"""
query = ''.join(['SELECT serial, secretkey FROM daemon WHERE serial = \'', hostname, '\'']);
res = self.sql.mysql_handler_personnal_query(query);
for r in res:
if r[0] == hostname:
return str(r[1]);
def send_mail(self, json_obj, connection, db):
"""
Callback called each time a send_mail packet is received.
The parameters are stored in 'json_obj'.
"""
try:
from_addr = formataddr((self.d3config['6'], self.d3config['5']));
host = self.d3config['7'];
secure = self.d3config['8']
port = self.d3config['9'];
username = self.d3config['10'];
password = self.d3config['11'];
msg = MIMEMultipart();
mdr = json_obj['data']['object'];
msg['Subject'] = json_obj['data']['object'];
msg['From'] = from_addr;
msg['To'] = json_obj['data']['destinator'];
msg.attach(MIMEText(json_obj['data']['message']));
server = smtplib.SMTP(host, port);
if (secure == 2):
server.ehlo();
server.starttls();
server.ehlo();
if not username and not password:
server.login(self.d3config['5'], username);
server.sendmail(from_addr, json_obj['data']['destinator'], msg.as_string());
server.quit();
connection.close();
except Exception as e:
self.logger.error('Error for sending mail');
self.logger.error(e);
connection.send(bytes('Error', 'utf-8'));
connection.close();
def modif_datetime(self, json_obj, connection, db):
os.system('date --set '+json_obj['data'][0]);
os.system('date --set '+json_obj['data'][1]);
def get_slave_name(self, json_obj, daemons):
"""
Retrieves the hostname of the daemon described by 'json_obj' in the 'daemons' list.
"""
daemon_found = False;
slave_name = '';
for d in daemons:
if int(json_obj['data']['daemon']) == int(d[0]):
daemon_found = True;
slave_name = str(d[2]);
break;
if daemon_found is False:
frameinfo = getframeinfo(currentframe());
self.logger.error('in get_slave_name: '+str(json_obj['data']['daemon']));
return None;
if str(json_obj['data']['addr']).count('/') != 2:
frameinfo = getframeinfo(currentframe());
self.logger.error('in get_slave_name: '+str(json_obj['data']['addr']));
return None;
return slave_name;
def reload_web_server(self):
"""
Call "service reload nginx"
"""
self.logger.debug('Reloading web server...');
call(["service", "nginx", "reload"]);
self.logger.debug('[ OK ] Done reloading web server.');
def smartcmd_launch(self, json_obj, connection, db):
s = Smartcommand(self, int(json_obj['data']))
s.setValues(connection);
s.start();
def triggers_list_update(self, json_obj, connection, db):
self.trigger.update_triggers_list(db);
def schedules_list_update(self, json_obj, connection, db):
self.schedule.update_schedules_list(db);
def scenarios_list_update(self, json_obj, connection, db):
self.scenario.update_scenarios_list(db);
def check_schedules(self, json_obj, connection, db):
self.schedule.check_all_schedules(connection);
def launch_calc_logs(self, json_obj, connection, db):
try:
self.calcLogs.sort_logs(connection, db);
except Exception as e:
self.logger.error(e);
def get_global_state(self, db):
query = 'SELECT room_device_id, option_id, opt_value FROM room_device_option';
res = self.sql.mysql_handler_personnal_query(query, db);
filtered = [];
append = filtered.append;
for elem in res:
if elem[2]:
append(elem);
global_state = [];
if filtered:
global_state = filtered;
else:
global_state = '';
return global_state;
def send_tech(self, json_obj, connection, db):
query = 'SELECT configuration_value FROM configuration WHERE configuration_id=1';
http = self.sql.mysql_handler_personnal_query(query, db);
query = 'SELECT configuration_value FROM configuration WHERE configuration_id=2';
ssl = self.sql.mysql_handler_personnal_query(query, db);
json_obj['info']['http'] = http[0][0];
json_obj['info']['ssl'] = ssl[0][0];
self.send_request(json_obj, connection, db)
def send_request(self, json_obj, connection, db):
if self._parser.getValueFromSection('greenleaf', 'commercial') == "1":
admin_addr = self._parser.getValueFromSection('greenleaf', 'admin_addr')
hostname = socket.gethostname()
GLManager.SendRequest(str(json_obj), admin_addr, self.get_secret_key(hostname))
def send_interfaces(self, json_obj, connection, db):
query = ''.join(["SELECT serial, secretkey FROM daemon WHERE daemon_id=", str(json_obj['data']['daemon_id'])]);
res = self.sql.mysql_handler_personnal_query(query, db);
if res is None or not res:
self.logger.error('in send_interfaces: No daemon for id '+str(json_obj['data']['daemon_id']));
connection.close();
return ;
elif len(res) > 1:
self.logger.error('in send_interfaces: Too much daemons for id '+str(json_obj['data']['daemon_id']));
connection.close();
return ;
hostname = res[0][0];
ip = '';
for h in self.hostlist:
if hostname in h._Hostname.upper():
ip = h._IpAddr;
if not ip:
self.logger.error('in send_interfaces: '+hostname+' not in hostlist. Try perform network scan again.');
connection.close();
return ;
port = self._parser.getValueFromSection('connect', 'port');
sock = socket.create_connection((ip, port));
self_hostname = socket.gethostname();
if '.' in self_hostname:
self_hostname = self_hostname.split('.')[0];
aes_IV = AESManager.get_IV();
aes_key = self.get_secret_key(hostname);
obj_to_send = json.JSONEncoder().encode(
{
"packet_type": "send_interfaces",
"sender_name": self_hostname,
"interface_knx": json_obj['data']['interface_knx'],
"interface_EnOcean": json_obj['data']['interface_EnOcean'],
"interface_arg_knx": json_obj['data']['interface_arg_knx'],
"interface_arg_EnOcean": json_obj['data']['interface_arg_EnOcean'],
"daemon_knx": json_obj['data']['daemon_knx']
}
);
encode_obj = AES.new(aes_key, AES.MODE_CBC, aes_IV);
spaces = 16 - len(obj_to_send) % 16;
sock.send(bytes(aes_IV, 'utf-8') + encode_obj.encrypt(obj_to_send + (spaces * ' ')));
rlist, wlist, elist = select.select([sock], [], [], SELECT_TIMEOUT * 300);
re = '';
data = sock.recv(4096);
if data:
decrypt_IV = data[:16].decode();
host = None;
for h in self.hostlist:
if h._IpAddr == ip:
host = h;
decode_obj = AES.new(res[0][1], AES.MODE_CBC, decrypt_IV);
data2 = decode_obj.decrypt(data[16:]).decode();
resp = json.JSONDecoder().decode(data2);
hostname = host._Hostname;
if '.' in host._Hostname:
hostname = host._Hostname.split('.')[0];
if str(self.aes_slave_keys[hostname]) == str(resp['aes_pass']):
re = '1';
connection.send(bytes(re, 'utf-8'));
connection.close();
sock.close();
def shutdown_d3(self, json_obj, connection, db):
"""
Asks "shutdown_d3" to the slave described in json_obj for shutdown daemon.
"""
query = ''.join(["SELECT serial, secretkey FROM daemon WHERE daemon_id=", str(json_obj['data']['daemon_id'])]);
res = self.sql.mysql_handler_personnal_query(query, db);
if res is None or not res:
self.logger.error('in shutdown_d3: No daemon for id '+str(json_obj['data']['daemon_id']));
connection.close();
return ;
elif len(res) > 1:
self.logger.error('in shutdown_d3: Too much daemons for id '+str(json_obj['data']['daemon_id']));
connection.close();
return ;
hostname = res[0][0];
ip = '';
for h in self.hostlist:
if hostname in h._Hostname.upper():
ip = h._IpAddr;
if not ip:
self.logger.error('in shutdown_d3: '+hostname+' not in hostlist. Try perform network scan again.');
connection.close();
return ;
port = self._parser.getValueFromSection('connect', 'port');
sock = socket.create_connection((ip, port));
self_hostname = socket.gethostname();
if '.' in self_hostname:
self_hostname = self_hostname.split('.')[0];
aes_IV = AESManager.get_IV();
aes_key = self.get_secret_key(hostname);
obj_to_send = ''.join(['{"packet_type": "shutdown_d3", "sender_name": "', self_hostname, '"}']);
encode_obj = AES.new(aes_key, AES.MODE_CBC, aes_IV);
spaces = 16 - len(obj_to_send) % 16;
sock.send(bytes(aes_IV, 'utf-8') + encode_obj.encrypt(obj_to_send + (spaces * ' ')));
connection.close();
sock.close();
def reboot_d3(self, json_obj, connection, db):
"""
Asks "reboot_d3" to the slave described in json_obj for reboot daemon.
"""
query = ''.join(["SELECT serial, secretkey FROM daemon WHERE daemon_id=", str(json_obj['data']['daemon_id'])]);
res = self.sql.mysql_handler_personnal_query(query, db);
if res is None or not res:
self.logger.error('in reboot_d3: No daemon for id '+str(json_obj['data']['daemon_id']));
connection.close();
return ;
elif len(res) > 1:
self.logger.error('in reboot_d3: Too much daemons for id '+str(json_obj['data']['daemon_id']));
connection.close();
return ;
hostname = res[0][0];
ip = '';
for h in self.hostlist:
if hostname in h._Hostname.upper():
ip = h._IpAddr;
if not ip:
self.logger.error('in reboot_d3: '+hostname+' not in hostlist. Try perform network scan again.');
connection.close();
return ;
port = self._parser.getValueFromSection('connect', 'port');
sock = socket.create_connection((ip, port));
self_hostname = socket.gethostname();
if '.' in self_hostname:
self_hostname = self_hostname.split('.')[0];
aes_IV = AESManager.get_IV();
aes_key = self.get_secret_key(hostname);
obj_to_send = ''.join(['{"packet_type": "reboot_d3", "sender_name": "', self_hostname, '"}']);
encode_obj = AES.new(aes_key, AES.MODE_CBC, aes_IV);
spaces = 16 - len(obj_to_send) % 16;
sock.send(bytes(aes_IV, 'utf-8') + encode_obj.encrypt(obj_to_send + (spaces * ' ')));
connection.close();
sock.close();
def wifi_update(self, json_obj, connection, db):
"""
Send "wifi_update" to the slave described in json_obj for update the wifi configuration.
"""
query = ''.join(["SELECT serial, secretkey FROM daemon WHERE daemon_id=", str(json_obj['data']['daemon_id'])]);
res = self.sql.mysql_handler_personnal_query(query, db);
if res is None or not res:
self.logger.error('in wifi_update: No daemon for id '+str(json_obj['data']['daemon_id']));
connection.close();
return ;
elif len(res) > 1:
self.logger.error('in wifi_update: Too much daemons for id '+str(json_obj['data']['daemon_id']));
connection.close();
return ;
hostname = res[0][0];
ip = '';
for h in self.hostlist:
if hostname in h._Hostname.upper():
ip = h._IpAddr;
if not ip:
self.logger.error('in wifi_update: '+hostname+' not in hostlist. Try perform network scan again.');
connection.close();
return ;
port = self._parser.getValueFromSection('connect', 'port');
sock = socket.create_connection((ip, port));
self_hostname = socket.gethostname();
if '.' in self_hostname:
self_hostname = self_hostname.split('.')[0];
aes_IV = AESManager.get_IV();
aes_key = self.get_secret_key(hostname);
obj_to_send = ''.join(['{"packet_type": "wifi_update", "sender_name": "', str(self_hostname),
'", "ssid": "', str(json_obj['data']['ssid']), '", "password": "******", "security": "', str(json_obj['data']['security']),
'", "mode": "', str(json_obj['data']['mode']), '"}']);
encode_obj = AES.new(aes_key, AES.MODE_CBC, aes_IV);
spaces = 16 - len(obj_to_send) % 16;
sock.send(bytes(aes_IV, 'utf-8') + encode_obj.encrypt(obj_to_send + (spaces * ' ')));
rlist, wlist, elist = select.select([sock], [], [], SELECT_TIMEOUT * 300);
re = '';
for s in rlist:
data = sock.recv(4096);
if not data:
continue;
decrypt_IV = data[:16].decode();
host = None;
for h in self.hostlist:
if h._IpAddr == ip:
host = h;
decode_obj = AES.new(res[0][1], AES.MODE_CBC, decrypt_IV);
data2 = decode_obj.decrypt(data[16:]).decode();
resp = json.JSONDecoder().decode(data2);
hostname = host._Hostname;
if '.' in host._Hostname:
hostname = host._Hostname.split('.')[0];
if str(self.aes_slave_keys[hostname]) == str(resp['aes_pass']):
re = '1';
connection.send(bytes(re, 'utf-8'));
connection.close();
sock.close();
def remote_sql(self, json_obj, connection):
"""
Execute sql command from configurator
"""
db = MasterSql();
req = json_obj['data'].split(';');
for item in req:
if item != '':
db.mysql_handler_personnal_query(item);
connection.close();
return;
num=45).astype(int)
# The number of possible budgets that can be allocated to each subcampaign
number_of_budgets = 11
time_horizon = 300
regret = []
for e in range(0, number_of_experiments):
print('\n')
print('Starting experiment', e + 1)
logging.info("\n" + "Starting experiment " + str(e + 1))
advertising_scenarios = [
Scenario(daily_budgets=daily_budgets, campaign=0, var=0),
Scenario(daily_budgets=daily_budgets, campaign=1, var=0),
Scenario(daily_budgets=daily_budgets, campaign=2, var=0)
]
advertising_learners = [
SW_GPTS_Learner(arms=daily_budgets[:number_of_budgets]),
SW_GPTS_Learner(arms=daily_budgets[:number_of_budgets]),
SW_GPTS_Learner(arms=daily_budgets[:number_of_budgets])
]
pricing_scenarios = [
CustomizablePricingScenario(sex=1, under_30=1),
CustomizablePricingScenario(sex=1, under_30=0),
CustomizablePricingScenario(sex=0)
]
daily_budgets = np.linspace(5000, budget_cap, endpoint=True,
num=45).astype(int)
# The number of possible budgets that can be allocated to each subcampaign
number_of_budgets = 11
time_horizon = 100
regret = []
for e in range(0, number_of_experiments):
print('\n')
print('Starting experiment', e + 1)
scenarios = [
Scenario(daily_budgets=daily_budgets, campaign=0),
Scenario(daily_budgets=daily_budgets, campaign=1),
Scenario(daily_budgets=daily_budgets, campaign=2)
]
subcampaigns = [
SW_GPTS_Learner(arms=daily_budgets[:number_of_budgets]),
SW_GPTS_Learner(arms=daily_budgets[:number_of_budgets]),
SW_GPTS_Learner(arms=daily_budgets[:number_of_budgets])
]
optimizer = Optimizer(daily_budgets, len(daily_budgets))
ideal_optimizer = Optimizer(daily_budgets, len(daily_budgets))
# The optimal and the ideal result obtained by playing the best possible combination of arms known
optimal_rewards_per_round = np.zeros(time_horizon)
def main(cm_file, cdis_file, output_dir):
#------------------------------ BEGIN LOADING ------------------------------#
print(">>>: Carregando cenário")
scenario = Scenario.Scenario()
scenario.read(cm_file, cdis_file)
scenario_name = os.path.splitext(os.path.basename(cm_file))[0]
cdis_info_name = os.path.splitext(os.path.basename(cdis_file))[0]
scenario_path = os.path.join(output_dir, scenario_name + cdis_info_name)
result_log_path = os.path.join(scenario_path, "result_log.csv")
result_fig_path = os.path.join(scenario_path, "figures")
result_res_path = os.path.join(scenario_path, "results")
if not os.path.exists(output_dir):
os.makedirs(output_dir)
if not os.path.exists(scenario_path):
os.makedirs(scenario_path)
else:
shutil.rmtree(scenario_path)
os.makedirs(scenario_path)
if not os.path.exists(result_fig_path):
os.makedirs(result_fig_path)
if not os.path.exists(result_res_path):
os.makedirs(result_res_path)
Visualization.visualize(scenario, scenario.cm.ceList, result_fig_path,
"00")
#------------------------------ END LOADING ------------------------------#
with open(result_log_path, "w+") as resultLogFile:
resultLogFile.write(
"Data_e_Hora;Nome_do_cenário;Caminho_do_arquivo_do_cenário;Nome_das_informações_do_CDIS;Caminho_do_arquivo_das_informações_do_cdis;Tempo_de_execução\n"
)
resultLogFile.write(datetime.now().strftime("%d/%m/%Y %H:%M:%S") +
";" + scenario_name + ";" + cm_file + ";" +
cdis_info_name + ";" + cdis_file)
startTime = time.time()
totalIteration = len(scenario.cdisList)
for iteration in range(0, totalIteration):
print("\n>>>: Resolvendo cenário com informações do CDIS=" +
str(iteration) + "/" + str(totalIteration))
scenario.updateChannels(scenario.cdisList[iteration].channelList)
#------------------------------ BEGIN PREPROCESSING ------------------------------#
print(">>>: Pré-processando entrada")
(allCEVarList, ceVarList, ceByChannelVarList,
interferenceList) = PreProcessing.process(scenario)
#------------------------------ END PREPROCESSING ------------------------------#
#------------------------------ BEGIN SOLVER ------------------------------#
print(">>>: Criando modelo")
model = gb.Model('cognitive-networks')
print(">>>: Adicionando variáveis ao modelo")
allCEModelVarList = []
for ceVar in allCEVarList:
allCEModelVarList.append(
model.addVar(name=ceVar.name, vtype=gb.GRB.BINARY))
ceByChannelModelVarList = []
for ceByChannelVar in ceByChannelVarList:
ceByChannelModelVarList.append(
model.addVar(name=ceByChannelVar.name))
model.update()
ceModelVarList = []
for ceVars in ceVarList:
modelVarList = []
for ceVar in ceVars:
modelVarList.append(model.getVarByName(ceVar.name))
ceModelVarList.append(modelVarList)
print(">>>: Adicionando restrições ao modelo")
ceId = 0
for ceModelVars in ceModelVarList:
model.addConstr(gb.quicksum(ceModelVars), gb.GRB.EQUAL, 1,
"Única_configuração_para_CE_" + str(ceId))
ceId += 1
interferenceModelVarList = []
for interference in interferenceList:
ceVar = interference[0]
ceTotalInterference = interference[1]
ceInterferenceList = interference[2]
if (ceTotalInterference > 0):
interferenceModelVar = model.addVar(
name="Interferência-devido-" + ceVar.name)
interferenceModelVarList.append(interferenceModelVar)
model.update()
ceInterferenceModelVarList = []
for ceInterference in ceInterferenceList:
ceInterferenceModelVarList.append(
ceInterference * model.getVarByName(ceVar.name))
model.addConstr(
gb.quicksum(ceInterferenceModelVarList), gb.GRB.EQUAL,
interferenceModelVar,
"Interferência_provocada_por_" + ceVar.name)
model.addConstr(
interferenceModelVar, gb.GRB.LESS_EQUAL,
args.max_interference,
"Máximo_de_interferência_tolerada_de_" + ceVar.name)
for ceByChannelModelVar in ceByChannelModelVarList:
ceByChannelVarNameSplit = ceByChannelModelVar.varName.split(
'_')
channel = int(ceByChannelVarNameSplit[3])
filtredCEModelVarList = PreProcessing.filterCEByChannelModelVar(
allCEModelVarList, channel)
model.addConstr(gb.quicksum(filtredCEModelVarList),
gb.GRB.EQUAL, ceByChannelModelVar,
"Qtd_de_CE_no_canal_" + str(channel))
model.addConstr(
ceByChannelModelVar, gb.GRB.LESS_EQUAL,
min(len(scenario.cm.ceList),
((len(scenario.cm.ceList) /
PreProcessing.countAvailableChannels(scenario)) +
1)), "Máximo_de_CEs_no_canal_" + str(channel))
ceId = 0
for ceModelVars in ceModelVarList:
potencyList = []
for ceModelVar in ceModelVars:
ceModelVarNameSplit = ceModelVar.varName.split("_")
cePotency = int(ceModelVarNameSplit[3])
potencyList.append(cePotency * ceModelVar)
model.addConstr(
gb.quicksum(potencyList), gb.GRB.GREATER_EQUAL,
args.min_potency,
"Mínimo_de_potência_para_máxima_cobertura_do_CE_" +
str(ceId))
ceId += 1
print(">>>: Definindo a função objetivo")
model.setObjective(gb.quicksum(interferenceModelVarList),
gb.GRB.MINIMIZE)
model.write(
os.path.join(result_res_path,
"model_it_" + str(iteration) + ".lp"))
print(">>>: Modelo salvo")
print(">>>: Otimizando modelo")
model.optimize()
resultCEVarList = []
with open(
os.path.join(result_res_path,
"it_" + str(iteration) + ".txt"),
"w") as resultFile:
if (model.status == gb.GRB.Status.OPTIMAL):
resultFile.write(">>>: Resultado ótimo:\n")
print(">>>: Resultado ótimo:")
for ceModelVar in allCEModelVarList:
if (ceModelVar.x == 1.0):
resultCEVarList.append(ceModelVar.varName)
resultFile.write("%s\n" % ceModelVar.varName)
print("%s" % ceModelVar.varName)
for interferenceModelVar in interferenceModelVarList:
ceModelVar = model.getVarByName(
interferenceModelVar.varName.split("-")[2])
if ((ceModelVar.x == 1.0)
and (interferenceModelVar.x > 0.0)):
resultFile.write("%s %s\n" %
(interferenceModelVar.varName,
interferenceModelVar.x))
print("%s %s" % (interferenceModelVar.varName,
interferenceModelVar.x))
for ceByChannelModelVar in ceByChannelModelVarList:
resultFile.write("%s %s\n" %
(ceByChannelModelVar.varName,
ceByChannelModelVar.x))
print("%s %s" % (ceByChannelModelVar.varName,
ceByChannelModelVar.x))
elif (model.status == gb.GRB.Status.INFEASIBLE):
resultFile.write(">>>: O modelo é inviável!\n")
print(">>>: O modelo é inviável!")
print(">>>: Computando IIS")
model.computeIIS()
resultFile.write(
"\n>>>: As restrições a seguir não foram satisfeitas:\n"
)
print(">>>: As restrições a seguir não foram satisfeitas:")
for c in model.getConstrs():
if c.IISConstr:
resultFile.write("%s\n" % c.constrName)
print("%s" % c.constrName)
print(">>>: Otimizando modelo relaxado")
model.feasRelaxS(0, False, False, True)
model.optimize()
if (model.status == gb.GRB.Status.OPTIMAL):
resultFile.write(
"\n>>>: Resultado ótimo do modelo relaxado:\n")
print(">>>: Resultado ótimo do modelo relaxado:")
for ceModelVar in allCEModelVarList:
if (ceModelVar.x == 1.0):
resultCEVarList.append(ceModelVar.varName)
resultFile.write("%s\n" % ceModelVar.varName)
print("%s" % ceModelVar.varName)
for interferenceModelVar in interferenceModelVarList:
ceModelVar = model.getVarByName(
interferenceModelVar.varName.split("-")[2])
if ((ceModelVar.x == 1.0)
and (interferenceModelVar.x > 0.0)):
resultFile.write("%s %s\n" %
(interferenceModelVar.varName,
interferenceModelVar.x))
print("%s %s" % (interferenceModelVar.varName,
interferenceModelVar.x))
for ceByChannelModelVar in ceByChannelModelVarList:
resultFile.write("%s %s\n" %
(ceByChannelModelVar.varName,
ceByChannelModelVar.x))
print("%s %s" % (ceByChannelModelVar.varName,
ceByChannelModelVar.x))
elif (model.status in (gb.GRB.Status.INF_OR_UNBD,
gb.GRB.Status.UNBOUNDED,
gb.GRB.Status.INFEASIBLE)):
print(
">>>: O modelo relaxado não pode ser resolvido porque é ilimitado ou inviável"
)
else:
resultFile.write(
">>>: A otimização parou com status: %d\n" %
model.status)
print(">>>: A otimização parou com status: %d" %
model.status)
elif (model.status == gb.GRB.Status.UNBOUNDED):
resultFile.write(
">>>: O modelo não pode ser resolvido porque é ilimitado\n"
)
print(
">>>: O modelo não pode ser resolvido porque é ilimitado"
)
else:
resultFile.write(
">>>: A otimização parou com status: %d\n" %
model.status)
print(">>>: A otimização parou com status: %d" %
model.status)
resultCEList = []
for resultCEVar in resultCEVarList:
ceVarNameSplit = resultCEVar.split('_')
ceId = int(ceVarNameSplit[1])
resultCEChannelNumber = int(ceVarNameSplit[2])
resultCEPotency = int(ceVarNameSplit[3])
ce = scenario.cm.ceList[ceId]
resultCEList.append(
DataStructures.CE(ceId, ce.antenna, resultCEChannelNumber,
ce.geoPoint, resultCEPotency,
ce.maxPotency, ce.clientList))
#------------------------------ END SOLVER ------------------------------#
#------------------------------ BEGIN VISUALIZATION ------------------------------#
if (len(resultCEVarList) > 0):
Visualization.visualize(scenario, resultCEList,
result_fig_path, str(iteration))
#------------------------------ END VISUALIZATION ------------------------------#
resultLogFile.write(";" + str((time.time() - startTime)))
from Scenario import *
from Unite import *
import time
hexagones = []
listetopo= [Topologie(1,"Clear",(136,66,29,0.50)),
Topologie(2,"Ridge",(91,60,17,0.50)),
Topologie(3,"Canal",(20,147,20,0.50)),
Topologie(4,"AccesSPUR",(22,184,78,0.50)),
Topologie(5,"Vapor pool",(255,255,255,0.50)),
Topologie(4,"Rise",(146,109,39,0.50)),
Topologie(7,"Cliffside",(255,206,154,0.50)),
Topologie(8,"Mesa-Top",(240,195,0,0.50)),
Topologie(9,"Crater",(0,0,0,0.50))]
Scenario=Scenario(DISPLAY)
UniteLegionnaire= [Legionnaire_Trouper(1)]
def evenr_offset_to_pixel(direction):
x = size * sqrt(3) * (direction.q - 0.5 * (direction.r&1))
y = size * 3/2 * direction.r
return Point(x, y)
for q in range(0,12):
for r in range(0,14):
hexagones.append(Hexagone(evenr_offset_to_pixel(Direction(q,r)),listetopo[random.randint(0,8)]))
grid = Grid(hexagones)
grid.display()
while True:
for event in pygame.event.get():
def exportSeries( scenario, ID ):
success = 0
outputDir = OutputWriter.getOutputDir( ID )
if not os.path.isifile('dir'):
os.mkdir(outputDir)
else:
print( 'WARNING! OutputWriter.exportSeries() is overwriting scenario ID %s\n' % int(ID))
# Load dynamic and static variables
cacheDir = PathFinder.getCacheDir(scenario)
with open(os.path.join(cacheDir, 'dynamics.pkl'), 'rb') as handle:
Dynamic = pickle.load(handle)
with open(os.path.join(cacheDir, 'market.pkl'), 'rb') as handle:
Market = pickle.load(handle)
if scenario.isCurrentPolicy() or scenario.postShock().isCurrentPolicy():
Static = Dynamic
StaticMarket = Market
else:
with open(os.path.join(cacheDir, 'statics.pkl'), 'rb') as handle:
Static = pickle.load(handle)
with open(os.path.join(PathFinder.getCacheDir(scenario.currentPolicy()), 'market.pkl' ), 'rb') as handle:
StaticMarket = pickle.load(handle)
# TEMP TEMP -- This is until Scenario.OpennessPath is not a
# dependence in ModelSolver.
# NOTE: This is not quite right for any openness <> baseline.
# Since the delta should be of constant 'baseline'
# behavior while the openness changes.
if scenario.OpennessPath != 'baseline':
print( 'WARNING! Changing policy delta -- Scenario.Openness=%s --> baseline.\n' % scenario.OpennessPath )
params = scenario.getParams()
params.OpennessPath = 'baseline'
bscenario = Scenario(params)
if( bscenario.isCurrentPolicy() or bscenario.postShock().isCurrentPolicy() ):
dynamicsFile = 'dynamics.pkl'
else:
dynamicsFile = 'statics.pkl'
with open(os.path.join(PathFinder.getCacheDir(bscenario), dynamicsFile), 'rb') as handle:
Static = pickle.load(handle)
with open(os.path.join(PathFinder.getCacheDir(bscenario.currentPolicy()), 'market.pkl' ), 'rb') as handle:
StaticMarket = pickle.load(handle)
# END TEMP
# Load Dynamics for Microsim baseline add factor fix-up
# NOTE: Fix-up factor is going to be Dynamic_base/Dynamic_open_base
try:
with open(os.path.join(PathFinder.getCacheDir(scenario.currentPolicy().open()), 'dynamics.pkl'), 'rb') as handle:
Dynamic_open_base = pickle.load(handle)
with open(os.path.join(PathFinder.getCacheDir(scenario.baseline()), 'dynamics.pkl')) as handle:
Dynamic_base = pickle.load(handle)
except:
raise Exception('WARNING! Cannot read files to make "Dynamic baseline". Skipping...\n' )
return success
## Write AGGREGATES.csv
##
# Build the source series.
# For static series, read from input interfaces
firstYear = scenario.TransitionFirstYear
lastYear = scenario.TransitionLastYear - 1
numYears = lastYear - firstYear + 1
pathFinder = PathFinder(scenario)
source_series = {}
projections_file = pathFinder.getProjectionsInputPath( 'Projections' )
source_series['projections'] = InputReader.read_series(projections_file, 'Year', firstYear, lastYear)
taxcalculator_file = pathFinder.getTaxCalculatorInputPath( 'Aggregates' )
source_series['taxcalculator'] = InputReader.read_series(taxcalculator_file, 'Year', firstYear, lastYear )
oasicalculator_file = pathFinder.getOASIcalculatorInputPath( 'aggregates' );
source_series['oasicalculator'] = InputReader.read_series(oasicalculator_file, 'Year', firstYear, lastYear );
source_series['Market'] = Market
# Add GDP deflator changes series
p_series = InputReader.read_series(projections_file, 'Year', firstYear-1, lastYear)
gdp_deflator = p_series['GDPDeflator']
inflation_rate = np.ones((1,numYears))
for i in range(numYears):
inflation_rate[i] = gdp_deflator[i+1]/gdp_deflator[i]
# Construct dynamic scaling series
## Helper function
@staticmethod
def makeDeltaSeries( Source1, Source2, var_name ):
if var_name == '_add_inflation_to_interestrate':
delta = inflation_rate
elif var_name == '_asis':
delta = np.ones((1, numYears))
elif var_name == '_nonindexed':
series1 = [np.ones((1,10)), Source1['outs'][10:]]
series2 = [np.ones((1,10)), Source2['outs'][10:]]
delta = series1 / series2
delta = delta[0:numYears] # truncate in case too long
else:
series1 = Source1[var_name]
series2 = Source2[var_name]
delta = series1 / series2
return delta
dynamic_series = {}
# Iterate over series names
for o in OutputWriter.series_names.keys():
series_name = o
var_name = OutputWriter.series_names[series_name]['var_name']
source = OutputWriter.series_names[series_name]['source']
source_name = OutputWriter.series_names[series_name]['source_name']
if len(source_name) == 0:
source_name = series_name
# Calculate Dynamic/Static delta
delta = makeDeltaSeries( Dynamic, Static, var_name )
# Calculate fixup factor for microsim (as delta open_baseline/baseline)
fixup = makeDeltaSeries( Dynamic_base, Dynamic_open_base, var_name )
# Calculate scaling series
v_scale = delta * fixup # Adjust by fix-up factor
v_scale[np.isnan(v_scale)] = 1
# Apply to source series
v_source = source_series[OutputWriter.series_names[series_name]['source']]['source_name']
if np.size(v_source,2) == numYears:
v_source = np.transpose(v_source) # frickin' matlab and its vector direction
if var_name == '_add_inflation_to_interestrate':
dynamic_series[series_name] = ((1+v_source) * delta) - 1
else:
dynamic_series[series_name] = v_source * v_scale
# Write series to file
series_table = pd.DataFrame(dynamic_series)
series_table.to_csv((os.path.join(outputDir, 'Aggregates.csv')))
## Write DYNAMICS.CSV
Dynamic['outvars'] = OutputWriter.dynamic_outvars
Market['outvars'] = OutputWriter.market_outvars
Static['outvars'] = Dynamic.outvars
StaticMarket['outvars'] = Market.outvars
# Create new column names for Static
for o in Static['outvars'].keys():
p = Static['outvars'][o]
Static['outvars'][o] = 'STATIC_' + p
for o in StaticMarket['outvars'].keys():
p = StaticMarket['outvars'][o]
StaticMarket['outvars'][o] = 'STATIC_' + p
# Load steady state variables
with open(os.path.join(PathFinder.getCacheDir(scenario.currentPolicy().steady()), 'dynamics.pkl'), 'rb') as handle:
Dynamic_steady = pickle.load(handle)
with open(os.path.join(PathFinder.getCacheDir(scenario.currentPolicy().steady()), 'market.pkl'), 'rb') as handle:
Market_steady = pickle.load(handle)
# Append steady state variables and reset the first year
firstYear = firstYear - 1
for o in Dynamic['outvars'].keys():
Dynamic[o] = np.hstack((Dynamic_steady[o], Dynamic[o]))
Static[o] = np.hstack((Dynamic_steady[o], Static[o]))
for o in Market['outvars'].keys():
Market[o] = np.hstack((Market_steady[o], Market[o]))
StaticMarket[o] = np.hstack((Market_steady[o], StaticMarket[o]))
# Concatenate structs
output_series = {}
for M in [Dynamic, Market, Static, StaticMarket]:
for o in M['outvars'].keys():
p = M['outvars'][o]
output_series[p] = M[o]
# Write series to file
series_table = pd.DataFrame(output_series)
series_table.to_csv(os.path.join(outputDir, 'Dynamics.csv' ))
success = 1
return success
