#!/usr/bin/env python

# -*- coding: utf-8 -*-

from flask import Flask, request, session, g, redirect, url_for, abort, render_template, flash, jsonify

import lxclite as lxc

import lwp

import subprocess

import time

import re

import hashlib

import sqlite3

import os

import ConfigParser

import socket

import sys

import json

# configuration

config = ConfigParser.SafeConfigParser()

try:

config.readfp(open('/etc/lwp/lwp.conf'))

except:

print ' * missed /etc/lwp/lwp.conf file'

try:

# fallback on local config file

config.readfp(open('lwp.conf'))

except:

print ' * cannot read config files. Exit!'

sys.exit(1)

SECRET_KEY = '\xb13\xb6\xfb+Z\xe8\xd1n\x80\x9c\xe7KM\x1c\xc1\xa7\xf8\xbeY\x9a\xfa<.'

DEBUG = config.getboolean('global', 'debug')

DATABASE = config.get('database', 'file')

ADDRESS = config.get('global', 'address')

PORT = int(config.get('global', 'port'))

try:

SSL = bool(config.get('global', 'ssl'))

PKEY = config.get('global', 'pkey')

CERT = config.get('global', 'cert')

if not os.path.isfile(PKEY) or not os.path.isfile(CERT):

SSL = False

except ConfigParser.NoOptionError:

SSL = False

print "- SSL feature disabled"

try:

USE_BUCKET = bool(config.get('global', 'buckets'))

BUCKET_HOST = config.get('buckets', 'buckets_host')

BUCKET_PORT = config.get('buckets', 'buckets_port')

except:

USE_BUCKET = False

print "- Bucket feature disabled"

try:

AUTH = config.get('global', 'auth')

print ' * Auth type: ' + AUTH

if (AUTH == 'ldap'):

import ldap

LDAP_HOST = config.get('ldap', 'host')

LDAP_PORT = int(config.get('ldap', 'port'))

LDAP_BASE = config.get('ldap', 'base')

LDAP_BIND_DN = config.get('ldap', 'bind_dn')

LDAP_PASS = config.get('ldap', 'password')

except NameError as err:

print ' ! Revert to DB authentication ' + err

AUTH = 'database'

storage_repos = config.items('storage_repository')

# Flask app

app = Flask(__name__)

app.config.from_object(__name__)

def connect_db():

return sqlite3.connect(app.config['DATABASE'])

@app.before_request

def before_request():

g.db = connect_db()

@app.teardown_request

def teardown_request(exception):

g.db.close()

def if_logged_in(function=render_template, f_args=('login.html', )):

return decorator

def get_bucket_token(container):

return query['bucket_token']

@app.route('/')

@app.route('/home')

@if_logged_in()

def home():

return render_template('index.html', containers=lxc.ls(), containers_all=containers_all, dist=lwp.check_ubuntu(), host=socket.gethostname(), templates=lwp.get_templates_list(), storage_repos=storage_repos, auth=AUTH)

@app.route('/about')

@if_logged_in()

def about():

return render_template('about.html', containers=lxc.ls(), version=lwp.check_version())

@app.route('/<container>/edit', methods=['POST', 'GET'])

@if_logged_in()

def edit(container=None):

return render_template('edit.html', containers=lxc.ls(), container=container, infos=infos, settings=cfg, host_memory=host_memory, storage_repos=storage_repos)

@app.route('/settings/lxc-net', methods=['POST', 'GET'])

@if_logged_in()

def lxc_net():

return render_template('lxc-net.html', containers=lxc.ls(), cfg=lwp.get_net_settings(), running=lxc.running())

@app.route('/lwp/users', methods=['POST', 'GET'])

@if_logged_in()

def lwp_users():

return render_template('users.html', containers=lxc.ls(), users=users, nb_users=nb_users, su_users=su_users)

@app.route('/lwp/tokens', methods=['POST', 'GET'])

@if_logged_in()

def lwp_tokens():

return render_template('tokens.html', tokens=tokens)

@app.route('/checkconfig')

@if_logged_in()

def checkconfig():

return render_template('checkconfig.html', containers=lxc.ls(), cfg=lxc.checkconfig())

@app.route('/action', methods=['GET'])

@if_logged_in()

def action():

return redirect(url_for('home'))

@app.route('/action/create-container', methods=['GET', 'POST'])

@if_logged_in()

def create_container():

return redirect(url_for('home'))

@app.route('/action/clone-container', methods=['GET', 'POST'])

@if_logged_in()

def clone_container():

return redirect(url_for('home'))

@app.route('/action/backup-container', methods=['GET', 'POST'])

@if_logged_in()

def backup_container():

return redirect(url_for('home'))

@app.route('/login', methods=['GET', 'POST'])

def login():

return render_template('login.html', auth=AUTH)

@app.route('/logout')

def logout():

return redirect(url_for('login'))

@app.route('/_refresh_cpu_host')

@if_logged_in()

def refresh_cpu_host():

return lwp.host_cpu_percent()

@app.route('/_refresh_uptime_host')

@if_logged_in()

def refresh_uptime_host():

return jsonify(lwp.host_uptime())

@app.route('/_refresh_disk_host')

@if_logged_in()

def refresh_disk_host():

return jsonify(lwp.host_disk_usage(partition=config.get('overview', 'partition')))

@app.route('/_refresh_memory_<name>')

@if_logged_in()

def refresh_memory_containers(name=None):

return jsonify({'memusg': lwp.memory_usage(name)})

@app.route('/_check_version')

@if_logged_in()

def check_version():

return jsonify(lwp.check_version())

def hash_passwd(passwd):

return hashlib.sha512(passwd).hexdigest()

def get_token():

return hashlib.md5(str(time.time())).hexdigest()

def query_db(query, args=(), one=False):

cur = g.db.execute(query, args)

rv = [dict((cur.description[idx][0], value) for idx, value in enumerate(row)) for row in cur.fetchall()]

return (rv[0] if rv else None) if one else rv

def check_session_limit():

session['last_activity'] = now

#####################################

# API implementation

#####################################

def api_auth():

return decorator

@app.route('/api/v1/containers')

@api_auth()

def get_containers():

return json.dumps(list_container)

@app.route('/api/v1/container/<name>')

@api_auth()

def get_container(name):

return jsonify(lxc.info(name))

@app.route('/api/v1/container/<name>', methods=['POST'])

@api_auth()

def post_container(name):

return jsonify(status="error", error="Container doesn' t exists"), 409

@app.route('/api/v1/container/', methods=['PUT'])

@api_auth()

def add_container():

return jsonify(status="ok"), 200

@app.route('/api/v1/container/<name>', methods=['DELETE'])

@api_auth()

def delete_container(name):

return jsonify(status="error", error="Container doesn' t exists"), 400

@app.route('/api/v1/token/', methods=['POST'])

@api_auth()

def add_token():

return jsonify(status="ok"), 200

@app.route('/api/v1/token/<token>', methods=['DELETE'])

@api_auth()

def delete_token(token):

g.db.execute('delete from api_tokens where token=?', [token])

g.db.commit()

return jsonify(status="ok"), 200

if __name__ == '__main__':

# override debug configuration from command line

app.debug = True if '--debug' in sys.argv[1:] else DEBUG

if app.config['SSL']:

from OpenSSL import SSL

context = SSL.Context(SSL.SSLv23_METHOD)

context.use_privatekey_file(app.config['PKEY'])

context.use_certificate_file(app.config['CERT'])

app.run(host=app.config['ADDRESS'], port=app.config['PORT'], ssl_context=context)

else:

app.run(host=app.config['ADDRESS'], port=app.config['PORT'])