def index(self):
domains = self._get_domains()
form = self._generate_domain_form()
log()
return render_template('domains/index.html', page_tite='All Domains', page_heading='All Domains',
domains=domains, form=form)
def _new_server_return(self, cluster):
form = ServerForm()
log()
return render_template('servers/new.html',
page_heading='New Server',
page_title='New Server',
form=form,
cluster=cluster)
def get(self, domain_name):
domain = self._get_domain(domain_name=domain_name)
if not domain:
flash('Domain not found', 'error')
return redirect(url_for('Domains:index'))
log()
return render_template('domains/show.html', page_title='Domain {0}'.format(domain.name),
page_heading='Domain {0}'.format(domain.name), domain=domain)
def _new_upstream_return(self, domain):
form = UpstreamForm()
log()
return render_template(
'upstreams/new.html',
page_heading='New upstream for domain {0}'.format(domain.name),
page_title='New upstream for domain {0}'.format(domain.name),
form=form,
domain=domain)
def status(source, **kwargs):
"""Get IDPH reports save to disk"""
with app.app_context():
use_s3 = source == "s3"
try:
response = get_status(use_s3=use_s3, **kwargs)
except Exception as e:
exception_hook(e.__class__.__name__, debug=app.debug, use_tb=True)
else:
log(**response)
def post(self):
form = ClusterForm()
cluster = Cluster.query.filter_by(audit_is_deleted=False, name=form.name.data).first()
if cluster:
flash('Cluster name already in use', 'error')
return self._new_cluster_return()
cluster = Cluster(name=form.name.data, is_active=True)
cluster.create()
log(cluster.id)
flash('Cluster created successfully', 'success')
return redirect(url_for('Clusters:index'))
def index(self, cluster_id):
cluster = Cluster.query.filter_by(audit_is_deleted=False,
id=cluster_id).first()
if not cluster:
flash('Cluster not found', 'error')
return redirect(url_for('Clusters:index'))
servers = cluster.servers.filter_by(audit_is_deleted=False).all()
log()
return render_template('servers/index.html',
page_heading='Servers',
page_title='Servers',
servers=servers,
cluster=cluster)
def post(self, domain_name):
form = UpstreamForm()
domain = self._get_domain(domain_name=domain_name)
if not domain:
flash('Domain not found', 'error')
return redirect(url_for('Domains:index'))
upstream = Upstream(domain_id=domain.id,
ip_address=form.ip_address.data,
port=form.port.data)
upstream.create()
log(upstream.id)
flash('Upstream created successfully', 'success')
return redirect(url_for('Domains:get', domain_name=domain.name))
def delete(self, domain_name, upstream_id):
domain = self._get_domain(domain_name=domain_name)
if not domain:
flash('Domain not found', 'error')
return redirect(url_for('Domains:index'))
upstream = Upstream.query.filter_by(audit_is_deleted=False,
id=upstream_id,
domain_id=domain.id).first()
if not upstream:
flash('Upstream not found', 'error')
upstream.delete()
log(upstream.id)
flash('Upstream deleted successfully', 'success')
return redirect(url_for('Servers:index'))
def delete(self, cluster_id):
cluster = Cluster.query.filter_by(audit_is_deleted=False, id=cluster_id).first()
if not cluster:
flash('Cluster not found', 'error')
return redirect(url_for('Clusters:index'))
if cluster.domains.filter_by(audit_is_deleted=False).count() > 0:
flash('Active domains in this cluster, Cannot delete', 'error')
return redirect(url_for('Clusters:index'))
for server in cluster.servers.filter_by(audit_is_deleted=False).all():
server.delete()
cluster.delete()
log(cluster.id)
flash('Cluster and all associated servers deleted successfully', 'success')
return redirect(url_for('Clusters:index'))
def load_reports(end, days, enqueue, **kwargs):
"""Fetch reports to return time series"""
with app.app_context():
end_date = dt.strptime(end, DATE_FORMAT)
for day in range(days):
start_date = end_date - timedelta(days=day)
report_date = start_date.strftime(DATE_FORMAT)
try:
response = load_report(report_date, enqueue=enqueue, **kwargs)
except Exception as e:
exception_hook(e.__class__.__name__,
debug=app.debug,
use_tb=True)
else:
log(**response)
def index(self):
stats = {
'online_servers':
Server.query.filter_by(audit_is_deleted=False,
is_active=True).count(),
'active_domains':
Domain.query.filter_by(audit_is_deleted=False,
is_active=True).count(),
'active_clusters':
Cluster.query.filter_by(audit_is_deleted=False,
is_active=True).count()
}
log()
return render_template('dashboard/index.html',
page_title='Dashboard',
page_heading='Dashboard',
stats=stats)
def post(self):
form = self._generate_domain_form()
cluster = Cluster.query.filter_by(audit_is_deleted=False, id=form.cluster_id.data).first()
if not cluster:
flash('Cluster not found', 'error')
return self._new_domain_return()
domain = self._get_domain(domain_name=form.name.data)
if domain:
flash('Domain name already exists', 'error')
return self._new_domain_return()
domain = Domain(name=form.name.data, is_active=True, cluster_id=cluster.id)
domain.create()
log(domain.id)
flash('Domain created successfully', 'success')
return redirect(url_for('Domains:index'))
def post(self, cluster_id):
form = ServerForm()
cluster = Cluster.query.filter_by(audit_is_deleted=False,
id=cluster_id).first()
if not cluster:
flash('Cluster not found', 'error')
return redirect(url_for('Clusters:index'))
server = Server.query.filter_by(audit_is_deleted=False,
name=form.name.data).first()
if server:
flash('Server name already in use', 'error')
return self._new_server_return()
server = Server(name=form.name.data,
is_active=True,
cluster_id=cluster_id)
server.create()
log(server.id)
flash('Server created successfully', 'success')
return redirect(url_for('Clusters:index'))
def post_ckan_reports(src, report_date, **kwargs):
mimetype = CTYPES["csv"]
report_type = kwargs["report_type"]
config = REPORTS[report_type]
report_phrase = get_report_phrase(report_date, report_type)
if kwargs.get("datastore"):
sources = gen_new_records(src, report_date, **kwargs)
else:
sources = gen_csvs(src, report_date, **kwargs)
responses = [
post_ckan_report(*args, mimetype=mimetype, **kwargs, **config)
for args in sources
]
ok = responses and all(r["ok"] for r in responses)
if ok:
message = f"Successfully posted data {report_phrase}!"
status_code = 200
elif responses:
message = f"Error(s) encountered posting data {report_phrase}!"
status_code = 500
for response in responses:
if not response["ok"]:
log(**response)
else:
ok = True
message = f"No data posted {report_phrase}!"
status_code = 304
return {
"ok": ok,
"message": message,
"result": responses,
"status_code": status_code,
}
def login(self):
if 'user_id' in session:
del session['user_id']
username = request.form['username']
password = request.form['password']
user = User.query.filter_by(username=username).first()
if not user:
flash('Invalid username or password', 'error')
return redirect(url_for('Auth:index'))
if not user.validate_password(password):
flash('Invalid username or password', 'error')
return redirect(url_for('Auth:index'))
app.logger.debug('Storing user ID {0} into session'.format(user.id))
session['user_id'] = user.id
user.last_seen = datetime.utcnow()
db.session.commit()
g.user = user
log()
return redirect(url_for('Dashboard:index'))
def index(self):
clusters = Cluster.query.filter_by(audit_is_deleted=False).all()
log()
return render_template('clusters/index.html', page_heading='Clusters', page_title='Clusters', clusters=clusters)
def _new_cluster_return(self):
form = ClusterForm()
log()
return render_template('clusters/new.html', page_heading='New Cluster', page_title='New Cluster', form=form)
def _new_domain_return(self):
form = self._generate_domain_form()
log()
return render_template('domains/new.html', page_heading='New Domain',
page_title='New Domain', form=form)
def logout(self):
if 'user_id' in session:
del session['user_id']
log()
return redirect(url_for('Auth:index'))
