import ipaddress

import json

import functools

import statistics

from pathlib import Path

from datetime import datetime

import jsonschema

import strict_rfc3339

import requests

from flask import current_app

from pkg_resources import resource_filename

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()

)

def calculate_weight(data):

    obj = {}

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

        subdata = data[subkey]

        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.tor_status = kwargs.get('tor_status')

        self.fingerprint = kwargs['fingerprint']

        self.last_updated = kwargs['last_updated']

        self.country = kwargs['country']

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

        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 any({address.is_private, address.is_multicast,

                        address.is_unspecified, address.is_reserved,

                        address.is_loopback}):

                    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

        url = 'https://onionoo.torproject.org/weights?lookup={}'.format(

            self.fingerprint

        )

        data = requests.get(url)

        try:

            data.raise_for_status()

        except requests.HTTPError as e:

            raise e

        else:

            data = data.json()['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 check_status(self):

        now = datetime.utcnow()

        delta = now - self.last_updated

        if delta.seconds >= 3600:

            self.status = False

            self.tor_status = False

            return False

        else:

            return True

import json

from datetime import datetime

import strict_rfc3339

import pygeoip

from .model import Server

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

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

    if request.remote_addr not in accepted_ips:

        current_app.logger.warn('Unallowed IP %s tried to update data!'

                                % request.remote_addr)

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

    data = request.get_json()

    if data is None:

    if 'ip' in data:

        ip = data['ip']

    elif 'ip6' in data:

        ip = data['ip6']

    if ip.version == 4:

        data['country'] = gi4.country_name_by_addr(str(ip))

    elif ip.version == 6:

        data['country'] = gi6.country_name_by_addr(str(ip))

    else:

        data['country'] = None

    data['last_updated'] = strict_rfc3339.timestamp_to_rfc3339_utcoffset(

        datetime.utcnow().timestamp()

    )

    data['status'] = True

    try:

        server = Server.from_json(json.dumps(data))

    except Exception as e:

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

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

    if server.type in ('exit', 'relay'):

        server.update_weights()

    try:

        server.save()

    except Exception as e:

        current_app.logger.error(str(e))

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

    return (server.json(), 201,

             % server.name})

                    return (server.json(), 200,

                            {'Content-Type': 'application/json'})

            servers = [server.json() for server in all_servers()]

            servers = list(all_servers_by_type(server_type.lower()))

            return str(servers)

from ..api.model import Server

    server = Server.from_file_by_name(name)

    if server:

        server.check_status()

    return server

            yield f

            yield single_server(f[:-5])

            if server.type == type:

            servers[server.type].append(server)

    return render_template('status/index.html', exit=servers['exit'],

                           relay=servers['relay'], bridge=servers['bridge'])

    <type>{{ server.type }}</type>

    <name>{{ server.name }}</name>

    <status>{{ server.status }}</status>

    <tor_status>{{ server.tor_status }}</tor_status>

    <country>{{ server.country }}</country>

    <last_updated>{{ server.last_updated }}</last_updated>

    <fingerprint>{{ serverfingerprint }}</fingerprint>

    {% if server.type == 'bridge' %}

    <obfs>{{ server.obfs }}</obfs>

    <fteproxy>{{ server.fteproxy }}</fteproxy>

    <flashproxy>{{ server.flashproxy }}</flashproxy>

    <meek>{{ server.meek }}</meek>

    <ip>{{ server.ip }}</ip>

        <ip6>{{ server.ip6</ip6>

        {{ macros.create_server_table('exit', exit) }}

        {{ macros.create_server_table('relay', relay) }}

        {{ macros.create_server_table('bridge', bridge) }}

  {% if status %}

  {% elif status is none %}

  {% if server_type in ('exit', 'relay') %}

  <h2>{{ server_type.capitalize() }}</h2>

      {% for server in servers|sort(attribute='name')|sort(attribute='country') %}

      <tr {% if server.name in config['ENNSTATUS_BRIDGE_PROGRAM'] %}class="info"{% endif %}>

          {% if server_type in ('exit', 'relay') %}

            <td>{{ create_name(server.name) }}</td>

            <td>{{ server.ip }}</td>

            <td>{{ server.ip6 or 'N/A' }}</td>

            {% if server.name in config['ENNSTATUS_BRIDGE_PROGRAM'] %}

              <td><a href="{{ url_for('root.bridgeprogram') }}">{{ server.name }}</a></td>

              <td>{{ server.name }}</td>

          {% for status in (server.status, server.tor_status) %}

          <td>{{ create_country(server.country) }}</td>

          <td>{{ create_fingerprint(server.fingerprint, server.type) }}</td>

          {% if server_type == 'bridge' %}

            <td>{{ colorize_obfs(server.obfs) }}</td>

            <td>{{ colorize_obfs(server.fteproxy) }}</td>

            <td>{{ colorize_obfs(server.flashproxy) }}</td>

            <td>{{ colorize_obfs(server.meek) }}</td>

  {% if server_type == 'bridge' %}