1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
|
#!/usr/bin/env python
import gflags
from google.protobuf import text_format
import logging
import os
import sys
import time
from wsgiref import simple_server
from ct.dashboard import grapher
from ct.client.db import sqlite_connection as sqlitecon
from ct.client import prober
from ct.client.db import sqlite_cert_db
from ct.client.db import sqlite_log_db
from ct.client.db import sqlite_temp_db
from ct.proto import client_pb2
FLAGS = gflags.FLAGS
gflags.DEFINE_string("dashboard_host", "127.0.0.1", "Dashboard server host")
gflags.DEFINE_integer("dashboard_port", 8000, "Dashboard server port")
gflags.DEFINE_string("ctlog_config", "ct/config/logs.config",
"Configuration file for log servers to monitor")
# TODO(ekasper): clean up storage configuration so there's one base directory.
gflags.DEFINE_string("ct_sqlite_db", "/tmp/ct", "Location of the CT database")
gflags.DEFINE_string("ct_sqlite_cert_db", "/tmp/ct_cert", "Location of "
"certificate database.")
gflags.DEFINE_string("ct_sqlite_temp_dir", "/tmp/ct_tmp", "Directory for "
"temporary CT data.")
gflags.DEFINE_string("monitor_state_dir", "/tmp/ct_monitor",
"Filename prefix for monitor state. State for a given log "
"will be stored in a monitor_state_dir/log_id file")
gflags.DEFINE_string("log_level", "WARNING", "logging level")
class DashboardServer(object):
template_pages = {"default", "sth"}
"""A simple web application for serving status pages."""
def __init__(self, host, port, db, ct_server_list):
self.host = host
self.port = port
self.db = db
self.grapher = grapher.GvizGrapher()
self.templates = {}
self._read_templates()
self.favicon = ""
self._read_favicon()
def _read_templates(self):
"""Read the HTML templates from the templates/ directory."""
for page in DashboardServer.template_pages:
template_file = os.path.join(os.path.dirname(__file__),
"templates/%s.html" % page)
self.templates[page] = open(template_file, "r").read()
def _read_favicon(self):
"""Read favicon.ico."""
favicon_file = os.path.join(os.path.dirname(__file__), "favicon.ico")
self.favicon = open(favicon_file, "rb").read()
def __repr__(self):
return "%r(%r:%r)" % (self.__class__.__name__,
self.host, self.port)
def __str__(self):
return "%s(%s:%d)" % (self.__class__.__name__,
self.host, self.port)
def __call__(self, environ, start_response):
page = environ.get("PATH_INFO", "").strip("/")
# Serve the default page when there is no match
status = "200 OK"
if page == "favicon.ico":
headers = [("Content-type", "image/png")]
start_response(status, headers)
return self.favicon
status = "200 OK"
headers = [("Content-type", "text/html")]
start_response(status, headers)
varz = {}
varz["current_time"] = "\nCurrent time: %s\n" % time.strftime("%c")
if page == "sth":
self._fill_sth_template(varz)
return self.templates["sth"] % varz
else:
self._fill_default_template(varz)
return self.templates["default"] % varz
def _fill_default_template(self, varz):
"""Update the varz with variables required by the default template."""
varz["pages"] = """<a href=http://%s:%d/sth>
The Signed Tree Head Dashboard</a>\n""" % (
self.host, self.port)
def _fill_sth_template(self, varz):
# TODO(ekasper): graph all logs
server_id = ct_server_list[0]
varz["log"] = server_id.encode("ascii")
one_week_ago = (time.time() - 7*24*60*60)*1000
columns = [("sth.timestamp", "timestamp_ms", "Timestamp"),
("sth.tree_size", "number", "Tree size")]
sth_to_show = self.db.scan_latest_sth_range(server_id,
start=one_week_ago,
limit=1000)
varz["json"] = self.grapher.make_table(sth_to_show, columns,
order_by="timestamp")
def run(self):
"""Set up the HTTP server and loop forever."""
httpd = simple_server.make_server(self.host, self.port, self)
logging.info("Serving on http://%s:%d" % (self.host, self.port))
httpd.serve_forever()
if __name__ == "__main__":
sys.argv = FLAGS(sys.argv)
logging.basicConfig(level=FLAGS.log_level)
sqlite_log_db = sqlite_log_db.SQLiteLogDB(
sqlitecon.SQLiteConnectionManager(FLAGS.ct_sqlite_db))
sqlite_cert_db = sqlite_cert_db.SQLiteCertDB(
sqlitecon.SQLiteConnectionManager(FLAGS.ct_sqlite_cert_db))
if not os.path.exists(FLAGS.ct_sqlite_temp_dir):
logging.info("Creating directory for temporary data at %s" %
FLAGS.ct_sqlite_temp_dir)
os.makedirs(FLAGS.ct_sqlite_temp_dir)
if not os.path.exists(FLAGS.monitor_state_dir):
logging.info("Creating directory for monitor state at %s" %
FLAGS.monitor_state_dir)
os.makedirs(FLAGS.monitor_state_dir)
sqlite_temp_db_factory = sqlite_temp_db.SQLiteTempDBFactory(
sqlitecon.SQLiteConnectionManager(FLAGS.ct_sqlite_temp_dir + "/meta"),
FLAGS.ct_sqlite_temp_dir)
ctlogs = client_pb2.CtLogs()
with open(FLAGS.ctlog_config, "r") as config:
log_config = config.read()
text_format.Merge(log_config, ctlogs)
ct_server_list = []
for log in ctlogs.ctlog:
sqlite_log_db.update_log(log)
ct_server_list.append(log.log_server)
prober_thread = prober.ProberThread(ctlogs,
sqlite_log_db,
sqlite_cert_db,
sqlite_temp_db_factory,
FLAGS.monitor_state_dir)
prober_thread.daemon = True
prober_thread.start()
server = DashboardServer(FLAGS.dashboard_host, FLAGS.dashboard_port,
sqlite_log_db, ct_server_list)
server.run()
|
