# Ënnstatus

# Copyright (C) 2015  Dennis Fink

#

# This program is free software: you can redistribute it and/or modify

# it under the terms of the GNU General Public License as published by

# the Free Software Foundation, either version 3 of the License, or

# (at your option) any later version.

#

# This program is distributed in the hope that it will be useful,

# but WITHOUT ANY WARRANTY; without even the implied warranty of

# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

# GNU General Public License for more details.

#

# You should have received a copy of the GNU General Public License

# along with this program.  If not, see <http://www.gnu.org/licenses/>.

import ipaddress

import json

import functools

import statistics

from pathlib import Path

from datetime import datetime

import jsonschema

import strict_rfc3339

from flask import current_app

from pkg_resources import resource_filename

from onion_py.manager import Manager

from onion_py.caching import OnionSimpleCache

from ..utils import check_ip

schema = json.load(

    open(

        resource_filename('ennstatus.api', 'schema/server.json'),

        encoding='utf-8'

    )

)

validate = functools.partial(

    jsonschema.validate,

    schema=schema,

    format_checker=jsonschema.FormatChecker()

)

manager = Manager(OnionSimpleCache())

def calculate_weight(data):

    obj = {}

    for subkey in ('1_week', '1_month', '3_months', '1_year', '5_years'):

        try:

            subdata = data[subkey]

        except KeyError:

            continue

        factor = subdata.factor

        values = [x * factor for x in subdata.values if x is not None]

        if values:

            obj[subkey] = statistics.mean(values) * 100

        else:

            obj[subkey] = None

    return obj

class ServerEncoder(json.JSONEncoder):

    def default(self, obj):

        if isinstance(obj, (ipaddress.IPv4Address, ipaddress.IPv6Address)):

            return str(obj)

        if isinstance(obj, datetime):

            return strict_rfc3339.timestamp_to_rfc3339_utcoffset(

                obj.timestamp()

            )

        return json.JSONEncoder.default(self, obj)

class ServerDecoder(json.JSONDecoder):

    def decode(self, json_string):

        default_obj = super().decode(json_string)

        for key in ('ip', 'ip6'):

            if key in default_obj:

                current_app.logger.debug('{}: {}'.format(

                    key, default_obj[key]

                )

                )

                default_obj[key] = ipaddress.ip_address(default_obj[key])

        current_app.logger.debug('Loading last_updated')

        default_obj['last_updated'] = datetime.fromtimestamp(

            strict_rfc3339.rfc3339_to_timestamp(default_obj['last_updated'])

        )

        return default_obj

class Server:

    def __init__(self, *args, **kwargs):

        self.name = kwargs['name']

        self.type = kwargs['type']

        self.status = kwargs.get('status')

        self.fingerprint = kwargs['fingerprint']

        self.last_updated = kwargs['last_updated']

        self.country = kwargs['country']

        self.bandwidth = kwargs.get('bandwidth')

        self.flags = kwargs.get('flags')

        if self.type == 'bridge':

            self.obfs = kwargs.get('obfs')

            self.fteproxy = kwargs.get('fteproxy')

            self.flashproxy = kwargs.get('flashproxy')

            self.meek = kwargs.get('meek')

        else:

            self.ip = kwargs['ip']

            if 'ip6' in kwargs:

                self.ip6 = kwargs['ip6']

            default_weights = {

                '1_week': None,

                '1_month': None,

                '3_months': None,

                '1_year': None,

                '5_years': None

            }

            self.mean_consensus_weight = kwargs.get(

                'mean_consensus_weight',

                default_weights

            )

            self.mean_guard_probability = kwargs.get(

                'mean_guard_probability',

                default_weights

            )

            self.mean_exit_probability = kwargs.get(

                'mean_exit_probability',

                default_weights

            )

            self.mean_consensus_weight_fraction = kwargs.get(

                'mean_consensus_weight_fraction',

                default_weights

            )

            self.mean_middle_probability = kwargs.get(

                'mean_middle_probability',

                default_weights

            )

    @classmethod

    def from_file_by_name(cls, name):

        filepath = Path('data') / (name.lower() + '.json')

        current_app.logger.info('Loading {}'.format(str(filepath)))

        if filepath.exists() and filepath.is_file():

            try:

                with filepath.open(encoding='utf-8') as f:

                    data = json.load(f, cls=ServerDecoder)

            except (IOError, ValueError):

                current_app.logger.error('IOError or ValueError')

                return False

            else:

                return cls(**data)

        else:

            current_app.logger.error('File error!')

            return False

    @classmethod

    def from_json(cls, server):

        try:

            if cls.check_json_format(json.loads(server)):

                decoded = json.loads(server, cls=ServerDecoder)

                return cls(**decoded)

        except (jsonschema.ValidationError, ValueError) as e:

            raise e

    @classmethod

    def from_dict(cls, server):

        return cls.from_json(json.dumps(server))

    def json(self):

        return json.dumps(self.__dict__, cls=ServerEncoder)

    @staticmethod

    def check_json_format(server):

        try:

            validate(server)

        except jsonschema.ValidationError as e:

            raise e

        for key in ('ip', 'ip6'):

            if key in server:

                address = ipaddress.ip_address(server[key])

                if not check_ip(address):

                    raise ValueError('{} is not accepted!\n'.format(key))

        return True

    def save(self):

        filepath = Path('data') / (self.name.lower() + '.json')

        try:

            with filepath.open(mode='w', encoding='utf-8') as f:

                json.dump(self.__dict__, f, cls=ServerEncoder)

        except Exception as e:

            raise e

    def update_weights(self):

        if self.type not in ('exit', 'relay'):

            raise NotImplementedError

        try:

            data = manager.query('weights', lookup=self.fingerprint)

        except:

            raise NotImplementedError

        if data is not None:

            data = data.relays[0]

        self.mean_consensus_weight = calculate_weight(data.consensus_weight)

        self.mean_exit_probability = calculate_weight(data.exit_probability)

        self.mean_guard_probability = calculate_weight(

            data.guard_probability

        )

        self.mean_middle_probability = calculate_weight(

            data.middle_probability

        )

        self.mean_consensus_weight_fraction = calculate_weight(

            data.consensus_weight_fraction

        )

    def update_flags(self):

        try:

            data = manager.query('details', lookup=self.fingerprint)

        except:

            raise NotImplementedError

    def check_status(self):

        now = datetime.utcnow()

        delta = now - self.last_updated

        if delta.seconds >= 3600:

            self.status = False

        elif delta.seconds >= 600:

            self.status = None

# Ënnstatus

# Copyright (C) 2015  Dennis Fink

#

# This program is free software: you can redistribute it and/or modify

# it under the terms of the GNU General Public License as published by

# the Free Software Foundation, either version 3 of the License, or

# (at your option) any later version.

#

# This program is distributed in the hope that it will be useful,

# but WITHOUT ANY WARRANTY; without even the implied warranty of

# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

# GNU General Public License for more details.

#

# You should have received a copy of the GNU General Public License

# along with this program.  If not, see <http://www.gnu.org/licenses/>.

import ipaddress

import json

from datetime import datetime

from flask import (Blueprint, request, current_app, jsonify, render_template,

                   abort)

from werkzeug.exceptions import BadRequest

import strict_rfc3339

import pygeoip

from ennstatus import csrf

from ennstatus.status.functions import (single_server, all_servers,

                                        all_servers_by_type)

from .model import Server

from .auth import httpauth

api_page = Blueprint('api', __name__)

gi4 = pygeoip.GeoIP('/usr/share/GeoIP/GeoIP.dat', pygeoip.MEMORY_CACHE)

gi6 = pygeoip.GeoIP('/usr/share/GeoIP/GeoIPv6.dat', pygeoip.MEMORY_CACHE)

@csrf.exempt

@api_page.route('/update', methods=('POST',))

@httpauth.login_required

def update():

    current_app.logger.info('Handling update')

    try:

        servers = current_app.config['ENNSTATUS_SERVERS']

    except KeyError as e:

        current_app.logger.error(str(e))

        return abort(500)

    username = httpauth.username()

    try:

        if request.remote_addr not in servers[username]['IPS']:

            current_app.logger.warn(

                'Unallowed IP {} tried to update data!'.format(

                    request.remote_addr

                )

            )

            return 'IP not allowed!\n', 403, {'Content-Type': 'text/plain'}

    except KeyError as e:

        current_app.logger.error(str(e))

        return abort(500)

    try:

        data = request.get_json()

    except BadRequest:

        current_app.logger.info('No JSON data supplied!')

        return 'No JSON data supplied!\n', 400, {'Content-Type': 'text/plain'}

    try:

        if username != data['name'].lower():

            current_app.logger.warn(

                'Unallowed user {} tried to update {}!'.format(

                    username, data['name']

                )

            )

            return ('You are not allowed to update this server\n',

                    403, {'Content-Type': 'text/plain'})

    except KeyError:

        return abort(409)

    if 'ip' in data:

        ip = data['ip']

    elif 'ip6' in data:

        ip = data['ip6']

    else:

        ip = request.remote_addr

        try:

            temp_ip = ipaddress.ip_address(ip)

        except ipaddress.AddressValueError:

            return 'IP not allowed!\n', 403, {'Content-Type': 'text/plain'}

        else:

            if temp_ip.version == 4:

                data['ip'] = ip

            elif temp_ip.verison == 6:

                data['ip6'] = ip

    try:

        country = gi4.country_name_by_addr(ip)

    except pygeoip.GeoIPError:

        country = gi6.country_name_by_addr(ip)

    data['country'] = country

    data['last_updated'] = strict_rfc3339.timestamp_to_rfc3339_utcoffset(

        datetime.utcnow().timestamp()

    )

    try:

        server = Server.from_dict(data)

    except Exception as e:

        current_app.logger.warning(' '.join([str(e), str(data)]))

        return str(e), 409, {'Content-Type': 'text/plain'}

    try:

        server.save()

    except Exception as e:

        current_app.logger.error(str(e))

        return str(e), 500, {'Content-Type': 'text/plain'}

    current_app.logger.info('Return result')

    return (

        server.json(), 201,

        {

            'Location': '/api/export/json/single?server_name={}'.format(

                server.name

            )

        }

    )

@api_page.route('/export', defaults={'server_type': 'all'})

@api_page.route(('/export/<any("all", "exit", "bridge", "relay", "single")'

                 ':server_type>'))

def export(server_type):

    current_app.logger.info('Handling export')

    if server_type == 'single':

        server_name = request.args.get('server_name', None)

        if server_name is not None:

            server = single_server(server_name)

            if server:

                return server.json(), 200, {'Content-Type': 'application/json'}

            else:

                current_app.logger.warning('Server not found!')

                return ('Server not found!\n',

                        404, {'Content-Type': 'text/plain'})

        else:

            current_app.logger.warning('No server_name specified!')

            return ('No server_name specified!\n',

                    400, {'Content-Type': 'text/plain'})

    else:

        if server_type == 'all':

            current_app.logger.info('Getting all servers!')

            servers = [

                json.loads(

                    server.json()

                ) for server in all_servers()

            ]

        else:

            current_app.logger.info('Getting all {}!'.format(server_type))

            servers = [

                json.loads(

                    server.json()

                ) for server in all_servers_by_type(server_type.lower())

            ]

        return json.dumps(servers), 200, {'Content-Type': 'application/json'}

@api_page.route('/fingerprints', defaults={'server_type': 'all'})

@api_page.route('/fingerprints/<any("all", "exit", "relay"):server_type>')

def fingerprint(server_type):

    if server_type == 'all':

        servers = [server.fingerprint for server in all_servers()

                   if server.type != 'bridge']

    else:

        servers = [server.fingerprint

                   for server in all_servers_by_type(server_type.lower())]

    return '\n'.join(servers), 200, {'Content-Type': 'text/plain'}

# Ënnstatus

# Copyright (C) 2015  Dennis Fink

#

# This program is free software: you can redistribute it and/or modify

# it under the terms of the GNU General Public License as published by

# the Free Software Foundation, either version 3 of the License, or

# (at your option) any later version.

#

# This program is distributed in the hope that it will be useful,

# but WITHOUT ANY WARRANTY; without even the implied warranty of

# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

# GNU General Public License for more details.

#

# You should have received a copy of the GNU General Public License

# along with this program.  If not, see <http://www.gnu.org/licenses/>.

import pathlib

import click

@click.group()

@click.option('-p', '--path', default='/srv/http/enn.lu',

              help='Path where the config files are',

              type=click.Path(exists=True,

                              file_okay=False,

                              writable=True,

                              readable=True)

              )

@click.pass_context

def cli(ctx, path):

    ctx.obj = {}

    path = pathlib.Path(path)

    ctx.obj['path'] = path

    ctx.obj['config_file'] = path / 'config.json'

    ctx.obj['data_dir'] = path / 'data'

if __name__ == '__main__':

    cli()

# Ënnstatus

# Copyright (C) 2015  Dennis Fink

#

# This program is free software: you can redistribute it and/or modify

# it under the terms of the GNU General Public License as published by

# the Free Software Foundation, either version 3 of the License, or

# (at your option) any later version.

#

# This program is distributed in the hope that it will be useful,

# but WITHOUT ANY WARRANTY; without even the implied warranty of

# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

# GNU General Public License for more details.

#

# You should have received a copy of the GNU General Public License

# along with this program.  If not, see <http://www.gnu.org/licenses/>.

from .config import config

# Ënnstatus

# Copyright (C) 2015  Dennis Fink

#

# This program is free software: you can redistribute it and/or modify

# it under the terms of the GNU General Public License as published by

# the Free Software Foundation, either version 3 of the License, or

# (at your option) any later version.

#

# This program is distributed in the hope that it will be useful,

# but WITHOUT ANY WARRANTY; without even the implied warranty of

# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

# GNU General Public License for more details.

#

# You should have received a copy of the GNU General Public License

# along with this program.  If not, see <http://www.gnu.org/licenses/>.

import json

import ipaddress

from pprint import pprint

import click

from ...utils import check_ip

@click.group(short_help='Configure ennstatus')

def config():

    pass

@config.command('show', short_help='Show current configuration')

@click.pass_obj

def show(obj):

    with obj['config_file'].open(encoding='utf-8') as f:

        config = json.load(f)

    pprint(config)

@config.group(short_help='Configure servers')

def server():

    pass

@server.command('add', short_help='Add server')

@click.argument('name')

@click.option('-i', '--ips', prompt='IPs (comma separated)')

@click.password_option()

@click.option('--bridgeprogram/--no-bridgeprogram', default=False)

@click.pass_obj

def add(obj, name, ips, password, bridgeprogram):

    with obj['config_file'].open() as f:

        config = json.load(f)

    name = name.lower()

    ips = [ip.strip() for ip in ips.split(',')]

    try:

        if name in config['ENNSTATUS_SERVERS']:

            try:

                click.confirm('Server already exits! Overwrite?', abort=True)

            except click.Abort as e:

                raise SystemExit from e

    except KeyError:

        config['ENNSTATUS_SERVERS'] = {}

    converted_ips = {ipaddress.ip_address(ip) for ip in ips}

    for ip in converted_ips:

        if not check_ip(ip):

            raise SystemExit('ip {} is not accepted!'.format(str(ip)))

    config['ENNSTATUS_SERVERS'][name] = {

        'IPS': ips,

        'PASSWORD': password

    }

    if bridgeprogram:

        try:

            config['ENNSTATUS_BRIDGE_PROGRAM'].append(name)

        except KeyError:

            config['ENNSTATUS_BRIDGE_PROGRAM'] = [name]

    with obj['config_file'].open(mode='w', encoding='utf-8') as f:

        json.dump(config, f, indent=4, sort_keys=True)

@server.command('delete', short_help='Remove server')

@click.argument('name')

@click.pass_obj

def delete(obj, name):

    with obj['config_file'].open() as f:

        config = json.load(f)

    name = name.lower()

    try:

        del config['ENNSTATUS_SERVERS'][name]

    except KeyError:

        raise SystemExit('{} does not exists!'.format(name))

    try:

        config['ENNSTATUS_BRIDGE_PROGRAM'].remove(name)

        pass

    with obj['config_file'].open(mode='w', encoding='utf-8') as f:

        json.dump(config, f, indent=4, sort_keys=True)

    filename = obj['data_dir'] / (name + '.json')

    try:

        filename.unlink()

    except FileNotFoundError:

        pass