예제 #1
0
def redis_config():
    _params = dict(
            address  = config.get('REDIS', 'address'),
            db       = config.get('REDIS', 'db'),
            minsize  = config.get('REDIS', 'min'),
            maxsize  = config.get('REDIS', 'max')
        )

    _password = config.get('REDIS', 'password')
    if _password:
        _params['password'] = _password

    return _params
예제 #2
0
    async def _start(self, loop):
        await listen(config.get(self.NAME, 'host_local'), config.get(self.NAME, 'port'))

        try:
            _backdoor_port = config.get(self.NAME, 'adminport')

            if isinstance(_backdoor_port, int) and _backdoor_port > 1024:
                from backdoor import listen as blisten
                await blisten(int(_backdoor_port))
            else:
                raise Exception('unknown backdoor port:{0}'.format(_backdoor_port))
        except Exception as e:
            log.warn('can not open backdoor. error:{0}'.format(e))

        load_all_routes(self.NAME)
예제 #3
0
    def __init__(self):
        self.jira_ticket_url = None
        self.jira_exists = None

        if len(sys.argv) != 2:
            exit("Error: please enter exactly 1 CLI argument - AWS profile name")
        # boto3 client for aws - we take the account alias from telegraf's first CLI argument
        self.iam = boto3.session.Session(profile_name=sys.argv[1]).client('iam')
        self.dynamo_client = boto3.session.Session(profile_name=config["aws_dynamodb_profile_name"],
                                                   region_name=config["aws_dynamodb_region"]).client("dynamodb")

        # check if env variable is logging info level
        if os.environ.get("LOGGING_LEVEL") == "INFO":
            logging.basicConfig(level=logging.INFO)
        else:
            # log the config
            logging.basicConfig(level=logging.WARNING)

        if config.get("expire_age") == '' or config.get("expire_age") is None:
            config["expire_age"] = 180

        logging.info("Program configs are: Expire_age={}, Slack={}, dump_metric_to_console={}, Jira={}, "
                     "Disabling_expired_keys={}".format(config["expire_age"], config["slack"],
                                                        config["dump_metric_to_console"],
                                                        config["jira_ticket"],
                                                        config["disable_key"]))

        self.accountAlias = sys.argv[1]

        # fetching api keys from credstash
        self.ATLASSIAN_API_TOKEN = config["atlassian_api_token"]
        self.SLACK_API_TOKEN = config["slack_api_token"]

        self.key_rotation_string = """ 
To rotate your key you must:

You can rotate your access key using the `awscli`:

`aws iam create-access-key --user-name <user_name>`

`aws iam update-access-key --access-key-id <old_key_id> --status Inactive --user-name <user_name>`

`aws iam delete-access-key --access-key-id <old_key_id> --user-name <user_name>`

For more information visit aws.amazon.com/blogs/security/how-to-rotate-access-keys-for-iam-users/
        """

        self.run()
예제 #4
0
def get_monthly_history():
    users = config.get('WITHINGS', 'users').split(',')
    history_list_header = ['Month']
    for user in users:
        history_list_header += ['', user[0] + ' avg', user[0] + ' min', user[0] + ' max', user[0] + ' #']
    history_list_header = [history_list_header]
    history_list = []
    with get_session_manager() as session_manager:
        (min_date, ) = session_manager.query(Weights.date).order_by(Weights.date).first()
        min_date = datetime.date(min_date.year, min_date.month, 1)
        while min_date < datetime.date.today():
            month_string = '{year}-{month:0>2}'.format(year=min_date.year, month=min_date.month)
            month_count = 0
            month_row = [month_string]
            for user in users:
                (avg_weight, min_weight, max_weight, count_weight) = \
                    session_manager.query(func.avg(Weights.weight),
                                          func.min(Weights.weight),
                                          func.max(Weights.weight),
                                          func.count(Weights.weight)).\
                        filter(and_(Weights.user == user,
                                    Weights.date.like(month_string + '%'))).first()
                month_count += count_weight
                month_row += ['', avg_weight, min_weight, max_weight, count_weight]
            if month_count >  0:
                history_list += [month_row]
            min_date = min_date + datetime.timedelta(days=32)
            min_date = datetime.date(min_date.year, min_date.month, 1)
    history_list = sorted(history_list, reverse=True)
    history_list = history_list_header + history_list
    #print history_list
    return history_list
예제 #5
0
def get_stat_last_period(days = 30):
    users = config.get('WITHINGS', 'users').split(',')
    stat_list_header = ['Day']
    for user in users:
        stat_list_header += ['', user[0] + ' weight', user[0] + ' avg weight', user[0] + ' weight loss']
    stat_list_header = [stat_list_header]
    stat_list = []
    last_weights = {}
    last_avg_weights = {}
    min_avg_weight = {}
    min_weights = {}
    for user in users:
        last_weights[user] = []
        last_avg_weights[user] = []
        min_avg_weight[user] = 100
        min_weights[user] = 100 # TODO ??? better ???
    min_date = datetime.datetime.now() - datetime.timedelta(days=days+20)
    min_date = datetime.date(min_date.year, min_date.month, min_date.day)
    with get_session_manager() as session_manager:
        while min_date <= datetime.date.today():
            stat_row = [str(min_date)]
            for user in users:
                weight, avg_weight, weight_loss = None, None, None
                (weight,) = session_manager.query(func.avg(Weights.weight)).\
                    filter(and_(Weights.user == user,
                                Weights.date == str(min_date))).first()
                if weight:
                    last_weights[user].append(weight)
                else:
                    if last_weights[user]:
                        last_weights[user].append(last_weights[user][-1])
                        weight = last_weights[user][-1]
                if last_weights[user]:
                    if not last_avg_weights[user] or len(last_avg_weights[user])<5:
                        avg_weight = last_weights[user][-1]
                        weight_loss = 0
                        last_avg_weights[user].append(avg_weight)
                    else:
                        avg_weight = last_avg_weights[user][-1] + (weight - last_avg_weights[user][-5])/10
                        weight_loss = (last_avg_weights[user][-5]-avg_weight)/5
                        last_avg_weights[user].append(avg_weight)
                last_weights[user] = last_weights[user][-10:]
                last_avg_weights[user] = last_avg_weights[user][-10:]
                if weight and avg_weight and weight_loss:
                    if avg_weight < min_avg_weight[user]:
                        min_avg_weight[user] = avg_weight
                        avg_weight = ('background:#CC9999', avg_weight)
                    if weight < min_weights[user]:
                        min_weights[user] = weight
                        weight = ('background:#CC9999', weight)
                    stat_row += ['', weight, avg_weight, max(weight_loss,0)]
                else:
                    stat_row += ['', '', '', '']
            #print stat_row
            stat_list += [stat_row]
            min_date += datetime.timedelta(days=1)
    stat_list = sorted(stat_list, reverse=True)
    stat_list = stat_list[:days]
    stat_list = stat_list_header + stat_list
    return stat_list
예제 #6
0
def supervisord_server_url(server_name):
    _service_conf = config.get('DASHBOARD', 'servers')

    for name, _url in _service_conf:
        if name == server_name:
            return _url
    else:
        return ''
예제 #7
0
def rename_suffix(channel_list, suffix):
    apk_dir = os.path.expanduser(config.get('build', 'out_dir'))
    for channel in channel_list:
        naming = Naming(channel)
        cur_name = naming.signed_aligned()
        renamed_name = naming.signed_aligned(suffix)
        cur_file = os.path.join(apk_dir, cur_name)
        replaced_file = os.path.join(apk_dir, renamed_name)
        os.rename(cur_file, replaced_file)
예제 #8
0
def delete_apk(channel_list):
    apk_dir = os.path.expanduser(config.get('build', 'out_dir'))
    for channel in channel_list:
        name = Naming(channel).signed_aligned()
        apk_file = os.path.join(apk_dir, name)
        if os.path.exists(apk_file):
            print 'remove', channel
            os.remove(apk_file)
        else:
            print channel, 'not exists'
예제 #9
0
def get_user_graph_section(days=40):
    users = config.get('WITHINGS', 'users').split(',')
    header = 'Graphs:'
    section = ''
    for user in users:
        graph_title = 'Last {days} days for {user}'.format(days=days,
                                                       user=user)
        section += create_graph(graph_title, get_user_stat_last_period(user, days), ['weight', 'avg. weight'])
    return HTML_SECTION.format(header=header,
                               section=section)
예제 #10
0
    async def _start(self, loop):
        await listen('', config.get(self.NAME, 'port'))

        try:
            _backdoor_port = config.get(self.NAME, 'adminport')

            if isinstance(_backdoor_port, int) and _backdoor_port > 1024:
                from backdoor import listen as blisten
                await blisten(int(_backdoor_port))
            else:
                raise Exception('unknown backdoor port:{0}'.format(_backdoor_port))
        except Exception as e:
            log.warn('can not open backdoor. error:{0}'.format(e))

        load_all_routes(self.NAME)
        await self.connectGW()
        await self.connectCS()
        conf = config.get('REDIS')
        await redis.init(**conf) 
예제 #11
0
def dbconfig():
    return dict(
            host     = config.get('DB', 'host'),
            port     = config.get('DB', 'port'),
            user     = config.get('DB', 'user'),
            password = config.get('DB', 'password'),
            db       = config.get('DB', 'userdb'),
            minsize  = config.get('DB', 'min'),
            maxsize  = config.get('DB', 'max')
        )
예제 #12
0
def channel_list():
    all = []
    channel_file_dir = os.path.expanduser(
        config.get('channel', 'channel_file_dir'))
    for channel_file_name in os.listdir(channel_file_dir):
        channel_file = os.path.join(channel_file_dir, channel_file_name)
        if os.path.isfile(channel_file):
            with open(channel_file) as f:
                channels = f.read().strip().splitlines()
                for channel in channels:
                    if channel not in all:
                        all.append(channel)

    return all
예제 #13
0
def message_center():
    gmail_service = get_gmail_service()
    users = config.get('WITHINGS', 'users').split(',')
    for user in ['Bitten']:
        email_body = ''
        email_body += check_for_enough_weighings(user)
        email_body += check_for_goals_reached(user)
        email_body += check_maximum_weight(user)
        if email_body:
            user_email_address = get_email_address(user)
            print('Sending email to user: '******'Message from weights.', email_body)
            print(email_message)
            send_message(gmail_service, email_message)
예제 #14
0
def get_goal_status():  # TODO check this works after message center implemented
    goal_list = [['User',
                  'Avg. weight this week',
                  'BMI',
                  'Next goal',
                  'Final goal',
                  'Weight loss',
                  'Expected days next goal',
                  'Expected days final goal']]
    users = config.get('WITHINGS', 'users').split(',')
    with get_session_manager() as session_manager:
        for user in users:
            (goal, next_goal, height) = session_manager.query(Users.goal,
                                                       Users.next_goal,
                                                       Users.height_in_cm).filter(Users.user == user).first()
            end_date = datetime.datetime.now()
            start_date = end_date - datetime.timedelta(days=7)
            (avg_this_week,) = session_manager.query(func.avg(Weights.weight)).filter(and_(Weights.user == user,
                                                                                        Weights.date > start_date,
                                                                                        Weights.date <= end_date)).first()
            end_date = start_date
            start_date = end_date - datetime.timedelta(days=7)
            (avg_last_week,) = session_manager.query(func.avg(Weights.weight)).filter(and_(Weights.user == user,
                                                                                        Weights.date > start_date,
                                                                                        Weights.date <= end_date)).first()
            weight_loss = (avg_last_week - avg_this_week)/7
            days_to_next_goal = (avg_this_week-next_goal)/weight_loss
            days_to_final_goal = (avg_this_week-goal)/weight_loss
            if days_to_next_goal < 0:
                days_to_next_goal = 'NA'
                days_to_final_goal = 'NA'
            else:
                days_to_next_goal = int(days_to_next_goal)
                days_to_final_goal = int(days_to_final_goal)
            bmi = avg_this_week / ((height/100.0) ** 2)
            goal_list += [[user, avg_this_week, bmi, next_goal, goal, weight_loss, days_to_next_goal, days_to_final_goal]]
    return goal_list
예제 #15
0
#!/usr/bin/env python

from config_parser import config

APP_NAME = config.get('app', 'app_name')
VERSION_CODE = config.get('app', 'version_code')
APP_SUFFIX = config.get('app', 'app_suffix')


class Naming:
    def __init__(self, channel):
        self.channel = channel
        self.base_name = '{app_name}-{version_code}-{channel}'.format(
            app_name=APP_NAME, version_code=VERSION_CODE, channel=channel)

    def unsigned(self):
        return '{name}.apk'.format(name=self.base_name)

    def signed(self):
        return '{name}-signed.apk'.format(name=self.base_name)

    def signed_aligned(self, suffix=APP_SUFFIX):
        return '{name}-signed-aligned-{suffix}.apk'.format(name=self.base_name,
                                                           suffix=suffix)


if __name__ == '__main__':

    naming = Naming('testchannel')
    print naming.signed_aligned()
예제 #16
0
 def get_host(self, name):
     port = config.get(name, 'port')
     host = config.get(name, 'host_local')
     return host, port
예제 #17
0
#!/usr/bin/env python

import zipfile
import argparse
import shutil
import os, os.path

from config_parser import config
from apk_naming import Naming

import apkfile

BUILD_DIR = os.path.expanduser(config.get('build', 'build_dir'))
OUT_DIR = os.path.expanduser(config.get('build', 'out_dir'))
META_CHANNEL_FILE_NAME_TEMPLATE = "META-INF/channel_{channel}"


def make(src_apk_path, channel_list):
    tmp_src_apk_path = os.path.join(BUILD_DIR, 'temp.apk')
    shutil.copy(src_apk_path, tmp_src_apk_path)
    channel_files = apkfile.find_channel_files(tmp_src_apk_path,
                                               'META-INF/channel_')
    apkfile.remove_channel_files(tmp_src_apk_path, channel_files)

    if not os.path.exists(OUT_DIR):
        os.makedirs(OUT_DIR)

    empty_file_name = 'empty'
    empty_file_path = os.path.join(OUT_DIR, empty_file_name)
    open(empty_file_path, 'w').close()
    for channel in channel_list:
예제 #18
0
#!/usr/bin/env python

import shutil

from config_parser import config
import os, os.path
from apk_naming import Naming

OUT_DIR = os.path.expanduser(config.get('build', 'out_dir'))
APKS_DIR = os.path.join(OUT_DIR, 'apks')

shutil.rmtree(APKS_DIR, ignore_errors=True)
os.mkdir(APKS_DIR)

channel_file_dir = os.path.expanduser(config.get('channel',
                                                 'channel_file_dir'))
for channel_file_name in os.listdir(channel_file_dir):
    if channel_file_name == '.DS_Store':
        continue
    dir = os.path.join(APKS_DIR, channel_file_name)
    os.mkdir(dir)

    channel_file = os.path.join(channel_file_dir, channel_file_name)
    with open(channel_file) as f:
        channels = f.read().strip().splitlines()
        for channel in channels:
            apk_file_name = Naming(channel).signed_aligned()
            src_apk_file = os.path.join(OUT_DIR, apk_file_name)
            dst_apk_file = os.path.join(dir, apk_file_name)
            if os.path.exists(src_apk_file):
                shutil.copy(src_apk_file, dst_apk_file)
예제 #19
0
def all_servers():
    return [name for name, _ in config.get('DASHBOARD', 'servers')]
예제 #20
0
def get_stat_last_period_section():
    last_period_in_days = int(config.get('FLAGS', 'last_period_in_days'))
    header = 'Last {days} days:'.format(days=last_period_in_days)
    section = get_html_table(get_stat_last_period(last_period_in_days))
    return HTML_SECTION.format(header=header,
                               section=section)
예제 #21
0
#-*-coding: utf-8-*-

# Version: 0.1
# Author: Don Li <*****@*****.**>
# License: Copyright(c) 2015 Don.Li
# Summary:

from config_parser import config
from osutil        import root_path

URL_ROOT = 'http://{0}:{1}'.format(
        config.get('DASHBOARD', 'hostname'),
        config.get('DASHBOARD', 'port').split(':')[1]
    )

ROOT_PATH = root_path()
STATIC_PATH   = ROOT_PATH + config.get('DASHBOARD', 'static_path')
TEMPLATE_PATH = ROOT_PATH + config.get('DASHBOARD', 'template_path')
예제 #22
0
#!/usr/bin/env python

from config_parser import config
import os
import os.path
import xlrd
import re
from collections import OrderedDict

CHANNEL_FILE_DIR = os.path.expanduser(config.get('channel',
                                                 'channel_file_dir'))
CHANNEL_SHEET_FILE = os.path.expanduser(
    config.get('channel', 'channel_sheet_file'))

CONFIG = [
    dict(file='market', sheet_index=0, column_index=4),
    dict(file='ad', sheet_index=1, column_index=4)
]

if not os.path.exists(CHANNEL_FILE_DIR):
    os.makedirs(CHANNEL_FILE_DIR)


def dedupe(_list):
    return OrderedDict((item, None) for item in _list).keys()


def is_ascii(s):
    return all(ord(c) < 128 for c in s)

예제 #23
0
from rpc  import route
from log  import log
from time import time

from config_parser import config
from server        import server

from constant      import *
from errorno       import *

from protocol_manager import g_protoMgr, gs_call, ms_call, alli_call

import redis

httpport = config.get(server.NAME, 'httpport')
REGISTERING_ACCOUTs = set()

@route()
async def register(p, request):
    res_err = [REGISTER_FAILED, [None, int(time()), httpport, 0]]
    _account_name = getattr(p, 'account', None)

    if not _account_name:
        p.kick('no account info when register')
        return res_err

    lead_id, nick_name, login_type, platform_id, version, sid = req
    had_cid = await redis.hget(DICT_NICKNAME_REGISTERED, nick_name)
    if had_cid:
        log.error('The nick_name had been used. had_cid: {0}, nick_name: {1}.'.format( had_cid, nick_name ))