Coverage for webgeodyn/server/server.py: 0%

1import tornado.ioloop as ioloop 

2import tornado.web as web 

3from tornado.httpserver import HTTPServer 

4from tornado.log import enable_pretty_logging, gen_log 

5from tornado.concurrent import run_on_executor 

6 

7import json 

8import signal 

9import os 

10import sys 

11import urllib 

12import webbrowser 

13import uuid 

14import logging 

15 

16from webgeodyn.server.datahandlers import * 

17from webgeodyn.obsdata import ObsData 

18 

19static_path = os.path.normpath(os.path.join(os.path.dirname(__file__) , "..", "www")) # path of static files 

20listeningport = 8080 

21 

22 

23class CloseHandler(RequestHandler): 

24 closeUUID = str(uuid.uuid4()) 

25 

26 def get(self): 

27 self.write(json.dumps({'closeUUID': self.closeUUID})) 

28 

29 def post(self): 

30 gen_log.info("User closed web browser.") 

31 str_data = tornado.escape.url_unescape(self.request.body) 

32 json_request = json.loads(str_data) 

33 if json_request.get("closeUUID") == self.closeUUID: 

34 ioloop.IOLoop.current().add_timeout(datetime.timedelta(seconds=1), stopServer) 

35 

36 

37def stopServer(*args): 

38 gen_log.info(" Asking server to exit...") 

39 ioloop.IOLoop.current().stop() 

40 

41 

42def startServer(models, archive, allowarchive=False, allowclose=True, showbrowser=True, debug=False, obs_directory=None): 

43 import tornado.options 

44 

45 obsdata = ObsData(obs_directory=obs_directory) 

46 

47 DEFAULT_LEVEL = logging.DEBUG 

48 DEFAULT_FORMAT = '[%(levelname)s - %(asctime)s] %(message)s' 

49 

50 # Enable logging through tornado.web.Application.log_request in stdout 

51 tornado.log.enable_pretty_logging() 

52 

53 # Logging in seperate files (not used for now) 

54 # access_file = logging.FileHandler(os.path.join(os.path.dirname(__file__), 'log/access.log')) 

55 # access_file.setLevel(DEFAULT_LEVEL) 

56 # access_file.setFormatter(tornado.log.LogFormatter(fmt=DEFAULT_FORMAT)) 

57 # tornado.log.access_log.addHandler(access_file) 

58 # general_file = logging.FileHandler(os.path.join(os.path.dirname(__file__), 'log/general.log')) 

59 # general_file.setLevel(DEFAULT_LEVEL) 

60 # general_file.setFormatter(tornado.log.LogFormatter(fmt=DEFAULT_FORMAT)) 

61 # tornado.log.gen_log.addHandler(general_file) 

62 # app_file = logging.FileHandler(os.path.join(os.path.dirname(__file__), 'log/app.log')) 

63 # tornado.log.app_log.addHandler(app_file) 

64 

65 # Custom log function to have more info than the default logging function 

66 def log_function(handler): 

67 if handler.get_status() < 400: 

68 log_method = access_log.info 

69 elif handler.get_status() < 500: 

70 log_method = access_log.warning 

71 else: 

72 log_method = access_log.error 

73 request_time = 1000.0 * handler.request.request_time() 

74 request_ip = handler.request.headers.get('X-Real-IP') or handler.request.remote_ip 

75 

76 log_method("{0} {1.method} {1.uri} ({1.host} {2}) in {3:.2f}ms" 

77 .format(handler.get_status(), handler.request, request_ip, request_time)) 

78 return 

79 

80 settings = { 

81 "cookie_secret": str(uuid.uuid4()), 

82 "autoreload": debug, 

83 "debug": debug, 

84 "log_function": log_function, 

85 #"login_url": "/" 

86 } 

87 

88 handlers = [ 

89 url(r"/getdatalist", DataListHandler, {"models": models, "obsdata": obsdata}), 

90 url(r"/getglobedata", GlobeDataHandler, {"models": models, "obsdata": obsdata}), 

91 url(r"/getloddata", LodDataHandler, {"models": models, "obsdata": obsdata}), 

92 url(r"/getspherharmdata", SpherHarmDataHandler, {"models": models, "obsdata": obsdata}), 

93 url(r"/getspectradata", SpectraDataHandler, {"models": models, "obsdata": obsdata}), 

94 url(r"/gettimeseriedata", TimeSerieDataHandler, {"models": models, "obsdata": obsdata}), 

95 url(r"/getobservatorydata", ObservatoryDataHandler, {"models": models, "obsdata": obsdata}), 

96 url(r"/getexportfileinfo", ExportFileInfoHandler, {"models": models, "obsdata": obsdata}), 

97 ] 

98 

99 if allowarchive == True: 

100 handlers.append(url(r"/getexportarchiveinfo", ExportFileInfoHandler, {"models": archive, "obsdata": obsdata})), 

101 handlers.append(url(r"/getarchivelist", DataListHandler, {"models": archive, "obsdata": obsdata})), 

102 

103 if allowclose: 

104 handlers.append(url(r"/close", CloseHandler)) 

105 

106 # Add file handler for each model that link to the directory of the zip archive for export 

107 # Model 

108 for model_name, model in models.items(): 

109 handlers.append(url(r'/'+model_name+r'/('+model_name+r'\.zip)', StaticFileHandler, {'path': model.dataDirectory})) 

110 # Archive 

111 for archive_name, archive in archive.items(): 

112 handlers.append(url(r'/'+archive_name+r'/('+archive_name+r'\.zip)', StaticFileHandler, {'path': archive.dataDirectory})) 

113 

114 handlers.append(url(r'/(.*)', StaticFileHandler, 

115 {'path': static_path, 'default_filename': 'index.html'})) 

116 

117 

118 app = tornado.web.Application(handlers, **settings) 

119 

120 server = app.listen(listeningport, xheaders=True) 

121 

122 loop = ioloop.IOLoop.current() 

123 #signal.signal(signal.SIGQUIT, sig_exit) # SIGQUIT is send by our supervisord to stop this server. 

124 #signal.signal(signal.SIGTERM, sig_exit) # SIGTERM is send by Ctrl+C or supervisord's default. 

125 #signal.signal(signal.SIGINT, sig_exit) 

126 local_address = "http://localhost:"+str(listeningport)+"/" 

127 gen_log.info('Server listening to ' + str(listeningport) + ' local_address:{local_address}') 

128 

129 if showbrowser: 

130 webbrowser.open("http://localhost:"+str(listeningport)+"/", new=1, autoraise=True) 

131 

132 try: 

133 loop.start() 

134 except KeyboardInterrupt: 

135 gen_log.info("KeyboardInterrupt") 

136 stopServer() 

137 

138 server.stop() 

139 gen_log.info("Server stopped.")