def Stop(self):
from Logging import mainlog
mainlog.info("Service shut down requested")
self.server.shutdown() # stop the server_forever loop
self.stopRequestedEvent.set() # not really necessary
self.stopEvent.wait() # will be set when leaving self.Run()
mainlog.info("Service shut down acknowledged")
def upgrade(version):
filename = "horse-{}.zip".format(version)
dest = os.path.join(horse_dir,filename)
mainlog.info("Downloading a new version {} into {}".format(filename,dest))
mf = MediaFire(configuration.get("MediaFire","email"),
configuration.get("MediaFire","password"),
configuration.get("MediaFire","appid"),
configuration.get("MediaFire","sessionkey"),
configuration.get("Proxy","proxy_url"),
configuration.get("Proxy","proxy_port"))
res = ""
folder = mf.load_directory()
for entry in folder:
if isinstance(entry,MediaFireFile) and entry.filename == filename:
mf.download(entry, dest) # FIXME dest
configuration.set("DownloadSite","current_version",str(version))
configuration.set("DownloadSite","client_path",dest)
configuration.save()
return "Successfully downloaded version {}. Config was updated.".format(str(version))
raise Exception("Version {} was not found on MediaFire".format(str(version)))
def alter_data():
mainlog.info("Setting employee is_active flag")
session().connection().execute("""
update horse.employees
set is_active = (roles is not null) or (select count(*) from horse.timetracks where employee_id = horse.employees.employee_id and start_time > date '2013-11-01') > 0;"""
)
session().commit()
def alter_data():
q = session().query(Employee).filter(Employee.roles != None).all()
mainlog.info("Updating {} records".format(len(q)))
for employee in q:
if len(employee.roles) > 0:
mainlog.info(employee)
# The roles attributes is not easy to work with :-(
r = employee.roles
r.add(RoleType.view_prices)
employee.roles = r
session().commit()
def alter_data():
q = session().query(OrderPart).filter(
and_(OrderPart.state == OrderPartStateType.completed,
OrderPart.completed_date == None)).all()
mainlog.info("Updating {} completed records".format(len(q)))
for part in q:
part.completed_date = part.order.completed_date
q = session().query(OrderPart).filter(
and_(OrderPart.state == OrderPartStateType.aborted,
OrderPart.completed_date == None)).all()
mainlog.info("Updating {} aborted records".format(len(q)))
for part in q:
part.completed_date = part.order.completed_date
session().commit()
def Run(self):
from Logging import mainlog
mainlog.info("Running service")
# All of this to make sure the service remains
# stoppable whatever happens
while True:
try:
# serve_forever will be interrupted by server.shutdown
# when Windows' Service Manager will call the
# Stop method.
# I set the poll interval because I think
# Python's default is too high
self.server.serve_forever(poll_interval=1)
# Warn the Stop method that we have
# acknowledged the stop request
self.stopEvent.set()
except Exception as ex:
# Make sure the service restarts if something
# went wrong
mainlog.error(str(ex))
pass
def Initialize(self, configFileName):
from Logging import mainlog, horse_dir, init_logging
init_logging('web_server.log')
mainlog.info("Horse dir : {}".format(horse_dir))
try:
from Configurator import load_configuration, configuration, resource_dir
mainlog.info("Resource dir : {}".format(resource_dir))
load_configuration("server.cfg", "server_config_check.cfg")
mainlog.info("configuration loaded")
from koi.http_handler import HorseHTTPHandler
p = int(configuration.get("DownloadSite", "port"))
mainlog.info("Listening on port {}".format(p))
self.server = HTTPServer(('', p), HorseHTTPHandler)
except Exception as ex:
mainlog.exception(ex)
raise ex
import urllib.request, urllib.error, urllib.parse
from Logging import init_logging, mainlog, horse_dir, log_stacktrace
init_logging("file_server.log")
from Configurator import load_configuration, init_i18n, configuration, resource_dir
load_configuration("server.cfg", "server_config_check.cfg")
if __name__ == "__main__":
base_url = "http://localhost:{}".format(
configuration.get("DownloadSite", "port"))
mainlog.info("Testing {}".format(base_url))
response = urllib.request.urlopen(base_url)
if "This is the Horse download site !" not in response.read():
mainlog.error("Can't see homepage")
else:
mainlog.info("Homepage OK")
response = urllib.request.urlopen(base_url + "/database")
mainlog.info("Database = " + response.read())
response = urllib.request.urlopen(base_url + "/version")
mainlog.info("Version = " + response.read())
response = urllib.request.urlopen(base_url + "/file")
mainlog.info("Client file = {} ".format(
response.info().headers[4].strip()))
mainlog.info("Client file = {} bytes".format(len(response.read())))
def handle_request(self):
path = re.sub("\\?.*","",self.path)
params = urlparse.parse_qs( urlparse.urlparse(self.path).query)
if path == '/version':
self.send_response(200)
self.send_header('Content-type', 'text/html')
self.end_headers()
self.wfile.write(configuration.get("DownloadSite","current_version"))
return
elif path == '/file':
configure_zip_with_config(configuration.get("DownloadSite","client_path"), configuration)
f = open( configuration.get("DownloadSite","client_path"), 'rb' )
bytes = f.read()
f.close()
self.send_response(200)
self.send_header('Content-type', 'application/octet-stream')
self.send_header('Content-Length', str(len(bytes)))
self.send_header('Content-Disposition', 'attachment; filename={}'.format(os.path.split(configuration.get("DownloadSite","client_path"))[-1]))
self.send_header('Content-Transfer-Encoding', 'binary')
self.end_headers()
self.wfile.write(bytes)
mainlog.info("Served {} with {} bytes".format(configuration.get("DownloadSite","client_path"), len(bytes)))
return
elif path == '/database':
self.send_response(200)
self.send_header('Content-type', 'text/html')
self.end_headers()
self.wfile.write(configuration.get("Database","url"))
return
elif path == '/delivery_slips':
f = open( configuration.get("DownloadSite","client_path"), 'rb' )
bytes = f.read()
f.close()
self.send_response(200)
self.send_header('Content-type', 'application/octet-stream')
self.send_header('Content-Length', str(len(bytes)))
self.end_headers()
self.wfile.write(bytes)
return
elif path == '/logo.png':
f = open( os.path.join(resource_dir,"file_server_logo.png"), 'rb' )
bytes = f.read()
f.close()
self.send_response(200)
self.send_header('Content-type', 'image/png')
self.send_header('Content-Length', str(len(bytes)))
self.end_headers()
self.wfile.write(bytes)
return
elif self.path.startswith('/upgrade'):
if 'version' not in params:
mainlog.error("Upgrade requested without version")
self.send_response(500)
self.send_header('Content-type', 'text/html')
self.end_headers()
self.wfile.write("Version parameter not supplied")
return
version = ''.join(params['version']).strip()
mainlog.info("Upgrade requested to version {}".format(version))
res = "No message"
try:
res = upgrade(version)
self.send_response(200)
except Exception as ex:
mainlog.error("Upgrade failed because {}".format(str(ex)))
res = str(ex)
self.send_response(500)
self.send_header('Content-type', 'text/html')
self.end_headers()
self.wfile.write(cgi.escape(res))
return
else:
mainlog.error("Unsupported path {} from {}".format(self.path, self.client_address))
load_configuration("server.cfg","server_config_check.cfg")
bytes = """<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html><head>
<meta http-equiv="content-type" content="text/html; charset=ISO-8859-1"><style>
p,h2 {text-align:center; font-family:Verdana; }
table, th, td { border: 1px solid #2900af; border-collapse:collapse; padding:0; margin:0; }
img {background-color:white;}
</style></head>
<body>
<br/>
<p><img koi="logo.png"></p>
<br/>
<table width="100%" height="1"><tr><td></td><tr/></table><br/><br/>
<h2>This is the Horse download site !</h2>
<p>The current version is <b>{version}</b>.</p>
<p>To download the latest delivery_slips, <a href='/file'>click here</a>.</p>
</body></html>
"""
bytes = bytes.replace("{version}",configuration.get("DownloadSite","current_version"))
self.send_response(200)
self.send_header('Content-type', 'text/html')
self.send_header('Content-Length', str(len(bytes)))
self.end_headers()
self.wfile.write(bytes)
def alter_data():
mainlog.info("Terminating the old indirect order")
old_indirects = dao.order_dao.find_by_accounting_label(1)
old_indirects.state = OrderStatusType.order_completed
old_indirects.completed_date = date(2010, 1, 1)
session().commit()
mainlog.info("Reset everything to allow for multiple runs")
session().query(OrderPart).update({
OrderPart.state: OrderPartStateType.preorder,
OrderPart.completed_date: None
})
parts = session().query(OrderPart,Order.state,Order.creation_date).join(Order).\
filter(and_( Order.completed_date == None,
Order.state.in_([OrderStatusType.order_completed,OrderStatusType.order_aborted]))).\
all()
mainlog.info(
"Setting completed/aborted orders without date. Updating {} records".
format(len(parts)))
for part, order_state, creation_date in parts:
part.state = OrderPartStateType.state_from_order_state(order_state)
part.completed_date = creation_date
parts = session().query(OrderPart,Order.state,Order.completed_date).join(Order).\
filter(and_( Order.completed_date != None,
Order.state.in_([OrderStatusType.order_completed,OrderStatusType.order_aborted]))).\
all()
mainlog.info(
"Setting completed/aborted orders. Updating {} records".format(
len(parts)))
for part, order_state, completed_date in parts:
part.state = OrderPartStateType.state_from_order_state(order_state)
part.completed_date = completed_date
mainlog.info(
"Setting orders which are neither completed or aborted; clearing completion dates"
)
parts = session().query(OrderPart,Order.state).join(Order).\
filter(~Order.state.in_([OrderStatusType.order_aborted,OrderStatusType.order_completed])).\
all()
mainlog.info("Updating {} records".format(len(parts)))
for part, order_state in parts:
part.state = OrderPartStateType.state_from_order_state(order_state)
part.completed_date = None
mainlog.info("Setting completed_date")
parts = session().query(OrderPart.order_part_id,
func.max(DeliverySlip.creation).label("last_delivery")).\
filter(
and_( OrderPart.completed_date == None,
~OrderPart.state.in_([OrderPartStateType.completed,OrderPartStateType.aborted]),
or_( and_(OrderPart.estimated_time_per_unit > 0, OrderPart.tex2 == OrderPart.qty),
and_(OrderPart.estimated_time_per_unit == 0, OrderPart.qty == 0)))).\
outerjoin(DeliverySlipPart).\
outerjoin(DeliverySlip).\
group_by(OrderPart.order_part_id).\
all()
mainlog.info("Updating {} records".format(len(parts)))
for part in parts:
part.state = OrderPartStateType.completed
part.completed_date = date.today()
mainlog.info("Commit")
session().commit()
print('^C received, shutting down server')
server.socket.close()
if __name__ == '__main__':
# Grab the koi directory (to get Logging, Configurator,...)
# FIXME rather fragile...
sys.path.append(os.path.join(os.path.abspath(__file__), '..', '..'))
from koi.http_handler import HorseHTTPHandler
from Logging import init_logging, mainlog, horse_dir, log_stacktrace
init_logging("file_server.log")
from Configurator import load_configuration, init_i18n, configuration, resource_dir
load_configuration("server.cfg", "server_config_check.cfg")
mainlog.info("Starting server on port {}".format(
configuration.get("DownloadSite", "port")))
frozen = getattr(sys, 'frozen', False)
# if (not frozen and len(sys.argv) >= 2) or (frozen and len(sys.argv) >= 2):
# mainlog.info("Service invocation")
# win32api.SetConsoleCtrlHandler(ctrlHandler, True)
# r = win32serviceutil.HandleCommandLine(HorseWindowsService)
# if r == 0:
# mainlog.info("Service invocation successful")
# else:
# mainlog.error("Service invocation failed with return code {}".format(r))
# sys.exit(1)
# else:
mainlog.info("Command line invocation")
console_runner()
