Ejemplo n.º 1
0
def search(field=None, action=None, value=None):
    '''Plugin search
    A generalized search system that accepts both single-criteria get requests
    as well as multi-criteria posts.
    '''
    filters = []
    if request.method == 'GET':
        fields = bleach.clean(request.query.fields or 'slug,plugin_name,description').split(',')
        start = c.sint(bleach.clean(request.query.start or None))
        size = c.sint(bleach.clean(request.query.size or None))
        sort = bleach.clean(request.query.sort or 'slug')
        field = bleach.clean(field)
        value = bleach.clean(value)
        filters = [
            {'field': field, 'action': action, 'value': value}
        ]
    else:
        req = json.dumps(request.forms.get('search'))
        fields = req['fields'] if 'fields' in req else ['slug', 'plugin_name', 'description']
        start = req['start'] if 'sort' in req else None
        size = req['size'] if 'size' in req else None
        sort = req['sort'] if 'sort' in req else 'slug'
        filters = req['filters'] if 'filters' in req else []
    try:
        data = c.plugin_search(filters, fields, sort)
    except:
        raise bottle.HTTPError(400, '{"error": "invalid post"}')
    else:
        if start is not None and size is not None:
            return c.jsonify(data[start:start+size])
        return c.jsonify(data)
Ejemplo n.º 2
0
def search(base=None, field=None, action=None, value=None):
    '''Plugin search
    A generalized search system that accepts both single-criteria get requests
    as well as multi-criteria posts.
    '''
    fields = bleach.clean(request.query.fields or 'name,plugname,description').split(',')
    fields = v2to3(fields)
    start = c.sint(bleach.clean(request.query.start or None))
    size = c.sint(bleach.clean(request.query.size or None))
    sort = bleach.clean(request.query.sort or 'slug')
    field = bleach.clean(field)
    value = bleach.clean(value)
    base = bleach.clean(base)
    if base == 'version':
        field = 'versions.%s' % field
    filters = [
        {'field': field, 'action': action, 'value': value}
    ]
    try:
        data = c.plugin_search(filters, fields, sort)
    except:
        raise bottle.HTTPError(400, '{"error": "invalid search"}')
    else:
        if start is not None and size is not None:
            return c.jsonify(v3to2(data[start:start+size]))
        return c.jsonify(v3to2(data))
Ejemplo n.º 3
0
def valid(msg, schema):
    try:
        log.debug('Validating message %s with schema %s', c.jsonify(msg),
                  c.jsonify(schema))
        jsonschema.Draft3Validator(schema).validate(msg)
    except jsonschema.ValidationError as e:
        log.warning("Message is not valid %s", e.message)
        return False
    return True
Ejemplo n.º 4
0
def category_plugins(name, server=None):
    '''Category Plugin listing
    returns the list of plugins that match a specific category.  Optionally a
    specific server binary compatability can be specified.
    '''
    fields = bleach.clean(request.query.fields or 'slug,plugin_name,description').split(',')
    start = c.sint(bleach.clean(request.query.start or None))
    size = c.sint(bleach.clean(request.query.size or None))
    sort = bleach.clean(request.query.sort or 'slug')
    data = c.list_category_plugins(server, name, fields, sort)
    if size is not None and start is not None:
        return c.jsonify(data[start:start+size])
    return c.jsonify(data)
Ejemplo n.º 5
0
def plugin_list(server=None):
    '''Plugin Listing
    Returns the plugin listing.  Can optionally be limited to a specific server
    binary compatability type.
    '''
    fields = bleach.clean(request.query.fields or 'slug,plugin_name,description').split(',')
    start = c.sint(bleach.clean(request.query.start or None))
    size = c.sint(bleach.clean(request.query.size or None))
    sort = bleach.clean(request.query.sort or 'slug')
    data = c.list_plugins(server, fields, sort)
    if size is not None and start is not None:
        return c.jsonify(data[start:start+size])
    return c.jsonify(data)
Ejemplo n.º 6
0
def author_plugins(name, server=None):
    '''Author Plugin Listing
    Returns the plugins associated with a specific author.  Optionally can also
    be restricted to a specific server binary compatability.
    '''
    fields = bleach.clean(request.query.fields or 'slug,plugin_name,description').split(',')
    start = c.sint(bleach.clean(request.query.start or None))
    size = c.sint(bleach.clean(request.query.size or None))
    sort = bleach.clean(request.query.sort or 'slug')
    data = c.list_author_plugins(server, name, fields, sort)
    if size is not None and start is not None:
        return c.jsonify(data[start:start+size])
    return c.jsonify(data)
Ejemplo n.º 7
0
def plugin_list():
    '''Plugin Listing
    Returns the plugin listing.  Can optionally be limited to a specific server
    binary compatability type.
    '''
    data = c.list_plugins('bukkit', ['slug',], 'slug')
    return c.jsonify([a['slug'] for a in data])
Ejemplo n.º 8
0
def export_json(db):
    u = input('enter file path: ')
    sdata = common.jsonify(db.get_all())
    file = open(u, "w")
    file.write(sdata)
    file.close()
    print('data exported succesfully')
Ejemplo n.º 9
0
def wakeup_asg(asg):
    log.debug('Initializing ASG: %s', pprint.saferepr(asg))
    tags = {i['Key']: i['Value'] for i in asg['Tags']}
    if not valid(tags, desired_wakeup_tags_schema):
        error = "Autoscaling group doesn't contain correct wakeup tags %s ".format(
            c.jsonify(tags))
        log.error(error)
        raise ValueError(error)

    initial_capacity = int(tags['InitialCapacity'])
    desired_capacity = int(tags['DesiredCapacity'])
    min_size = int(tags['MinSize'])
    max_size = int(tags['MaxSize'])

    if (int(asg['MinSize'])         != min_size or \
        int(asg['MaxSize'])         != max_size or \
        int(asg['DesiredCapacity']) != desired_capacity) and \
        int(asg['MaxSize'])         == initial_capacity:
        log.info(
            'Resizing autoscaling group from initial %i to desired %i capacity',
            initial_capacity, desired_capacity)
        asg_client.update_auto_scaling_group(
            AutoScalingGroupName=asg['AutoScalingGroupName'],
            MinSize=min_size,
            MaxSize=max_size,
            DesiredCapacity=desired_capacity)
Ejemplo n.º 10
0
    def get_messages(self):
        self.user
        game = str(self.json.get('game', ""))
        all_messages = self.messages.filter(game = self.user.game) if game else self.messages.filter(game = None)
        if str(self.json['game']):
            try:
                game_id = int(game)

                if self.user.game is None or game_id != self.user.game.id:
                    raise BadGame()

            except ValueError:
                raise BadGame()

        try:
            since = float(str(self.json['since']))
        except ValueError:
            raise BadSince()

        messages = [msg for msg in all_messages if msg.timestamp >= since]


        return jsonify(
            result="ok",
            messages=[{ "time": msg.timestamp, "text": msg.text, "login": msg.user.login} for msg in messages])
Ejemplo n.º 11
0
    def signin(self):
        user = self.users.filter(login=self._str_param('login'), password=self.users.encode(self._str_param('password')))

        if user.count() != 1:
            raise Incorrect()
        user = user.items()[0]
        return jsonify(result="ok", sid=user.authenticate())
Ejemplo n.º 12
0
def generation_info():
    '''Generation Information
    Returns the generation information as requested.  User can optionall request
    to look X number of versions back.
    '''
    size = c.sint(bleach.clean(request.query.size or None))
    return c.jsonify(c.list_geninfo(size))
Ejemplo n.º 13
0
 def join_game(self):
     user = self._user_by_sid()
     try:
         user.join_game(id=int(self.json['game']))
         # self.current_games.game(int(self.json['game'])).add_player(user.id, user.login)
     except ValueError:
         raise BadGame()
     return jsonify(result="ok")
Ejemplo n.º 14
0
    def start_testing(self):
        self.models.flush()
        self.games.flush()

        CommonController.WEBSOCKET_MODE_SYNC = True if self.json.get("websocketMode") == "sync" else False
        print("websocketMode: ", self.json["websocketMode"])

        return jsonify(result="ok")
Ejemplo n.º 15
0
def plugin_details(server, slug, version=None):
    '''Plugin Details 
    Returns the document for a specific plugin.  Optionally can return only a
    specific version as part of the data as well.
    '''
    fields = bleach.clean(request.query.fields or '').split(',')
    fields = v2to3(fields)
    data = c.plugin_details(server, slug, version, fields)
    return c.jsonify(v3to2([data])[0])
Ejemplo n.º 16
0
def naughty_list():
    plugins = list(c.db.plugins.find({'_use_dbo': {'$exists': True}}, 
                                {
                                    '_id': 0,
                                    'slug': 1, 
                                    'plugin_name': 1,
                                    'authors': 1,
                                }))
    return c.jsonify(plugins)
Ejemplo n.º 17
0
 def get_maps(self):
     maps = self.maps.all()
     return jsonify(
         maps=[{
             "id": map.id,
             "name": map.name,
             "map": map.map,
             "maxPlayers": map.max_players,
             } for map in maps],
         result="ok")
Ejemplo n.º 18
0
    def signup(self):
        try:
            password = self._str_param('password')
            if len(password) < self.MIN_PASSWORD_SYMBOLS:
                raise BadPassword()

            self.users.new(login=self._str_param('login'), password=self.users.encode(password))
        except CommitException:
            raise UserExists()

        return jsonify(result="ok")
Ejemplo n.º 19
0
 def upload_map(self):
     try:
         self.maps.new(
             name = str(self.json['name']),
             map = list(self.json['map']),
             max_players = int(str(self.json['maxPlayers'])))
     except CommitException:
         raise MapExists()
     except ValueError:
         raise BadMaxPlayers()
     return jsonify(result="ok")
Ejemplo n.º 20
0
def plugin_details(server, slug, version=None):
    '''Plugin Details 
    Returns the document for a specific plugin.  Optionally can return only a
    specific version as part of the data as well.
    '''
    fields = bleach.clean(request.query.fields or '').split(',')
    size = c.sint(bleach.clean(request.query.size or None))
    data = c.plugin_details(server, slug, version, fields)
    if size is not None:
        data['versions'] = data['versions'][:size]
    return c.jsonify(data)
Ejemplo n.º 21
0
    def get_games(self):
        games = self.games.filter(status=str(self.json["status"])).all() if self.json.get("status") else self.games.all()

        return jsonify(
            games=[{
                "name": game.name,
                "id": game.id,
                "map": game.map.id,
                "maxPlayers": game.max_players,
                "players": [player.login for player in game.players.all()],
                "status": game.status
                } for game in games],
            result="ok")
Ejemplo n.º 22
0
def search(field=None, action=None, value=None):
    '''Plugin search
    A generalized search system that accepts both single-criteria get requests
    as well as multi-criteria posts.
    '''
    fields = ['slug',]
    start = c.sint(bleach.clean(request.query.start or None))
    size = c.sint(bleach.clean(request.query.size or None))
    sort = bleach.clean(request.query.sort or 'slug')
    field = bleach.clean(field)
    value = bleach.clean(value)
    filters = [
        {'field': field, 'action': action, 'value': value}
    ]
    try:
        data = c.plugin_search(filters, fields, sort)
    except:
        raise bottle.HTTPError(400, '{"error": "invalid search"}')
    else:
        if start is not None and size is not None:
            return c.jsonify([a['slug'] for a in data[start:start+size]])
        return c.jsonify([a['slug'] for a in data])
Ejemplo n.º 23
0
def todays_trends():
    today = datetime.date.today().strftime('%Y-%m-%d')
    stats = list(c.db.stats.find({'counts.%s' % today: {'$exists': True}},
                {'_id': 0, 'slug': 1, 'server': 1, 'counts.%s' % today: 1})\
                .sort('counts.%s' % today, -1).limit(10))
    plugins = c.db.plugins.find({},{'slug': 1, 'versions.version': 1})
    pcount = 0
    vcount = 0
    for plugin in plugins:
        pcount += 1
        for version in plugin['versions']: vcount += 1
    return c.jsonify({
            'plugin_count': pcount,
            'version_count': vcount,
            'top_plugs': stats,
    })
Ejemplo n.º 24
0
    def get_stats(self):
        gameid = int(self.json["game"])
        try:
            game = self.games.get(gameid)
            if game.status == "running":
                raise BadGame()
        except:
            raise BadGame()

        return jsonify(
            players=[{
                login: player.login,
                kills: player.kills,
                deaths: player.deaths
            } for player in game.player_stats]
        )
Ejemplo n.º 25
0
    def leave_game(self):
        user = self._user_by_sid()

        if user.game:
            game = self.current_games.game(user.game.id)
            if game:
                game.remove_player(user.id)
                if len(user.game.players.all()) == 1:

                    for player in game.players_.values():
                        user.game.player_stats.new(login=player.login, kills=player.kills, deaths=player.deaths)

                    self.current_games.remove_game(user.game.id)

        user.leave_game()

        return jsonify(result="ok")
Ejemplo n.º 26
0
    def create_game(self):
        if self.user.game:
            raise AlreadyInGame()

        try:
            map = self.maps.get(id=int(self.json['map']))
        except (ValueError, ObjectNotFound):
            raise BadMap()

        try:
            game = self.games.new(map = map, name =  str(self.json['name']), max_players = int(str(self.json['maxPlayers'])))
            self.user.game = game
            self.user.save()
            self.current_games.add_game(game.id, map.map, self.json.get('consts')) #.add_player(self.user.id, self.user.login)
        except CommitException:
            raise GameExists()
        except ValueError:
            raise BadMaxPlayers()
        return jsonify(result="ok")
Ejemplo n.º 27
0
def plugin_details(slug, version=None):
    '''Plugin Details 
    Returns the document for a specific plugin.  Optionally can return only a
    specific version as part of the data as well.
    '''
    data = c.plugin_details('bukkit', slug, version, [])

    # Moving data to the old format
    data['name'] = data['slug']
    data['bukkitdev_link'] = data['dbo_page']
    data['desc'] = data['description']

    # Deleting all of the data that didnt exist in the old format.
    del(data['slug'])
    del(data['dbo_page'])
    del(data['description'])
    del(data['logo'])
    del(data['logo_full'])
    del(data['server'])
    del(data['website'])
    if '_use_dbo' in data: del(data['_use_dbo'])

    # Now we will perform the same actions for each version.
    versions = []
    for version in data['versions']:
        version['dl_link'] = version['download']
        version['name'] = version['version']
        del(version['commands'])
        del(version['permissions'])
        del(version['changelog'])
        del(version['md5'])
        del(version['slug'])
        del(version['download'])
        if 'dbo_version' in version: del(version['dbo_version'])
        versions.append(version)
    data['versions'] = versions
    return c.jsonify(data)
Ejemplo n.º 28
0
def handler(event, context):
    log.info("Incoming event: %s", c.jsonify(event))

    if not valid(event, event_schema):
        raise Exception(
            'This lambda expects SNS events however have got unexpected event',
            event)

    responses = []

    for rec in event['Records']:
        msg = message(rec)
        msg_id = rec['Sns']['MessageId']

        log.debug("Checking if incoming message is a SNS test notification")
        if is_wakeup_message(msg):
            log.info('This is an ASG wakeup message. %s', c.jsonify(msg))
            asg_name = msg['AutoScalingGroupName']
            asg_obj = describe_asg(asg_name)
            wakeup_asg(asg_obj)
            # log.info(c.jsonify(asg_obj))
            continue

        log.debug(
            "Checking if incoming message is valid ASG lifecycle hook message with metadata"
        )
        if not valid(msg, ags_hook_msg_schema):
            log.error("Unexpected incoming message. Payllad: %s",
                      c.jsonify(msg))
            continue

        metadata = msg['NotificationMetadata']
        r53_zone_id = metadata['HostedZoneId']
        # r53_domain      = metadata['r53_hosted_zone_domain']
        asg_name = msg['AutoScalingGroupName']
        instances = asg_running_instances(asg_name)

        try:
            resp = asg_client.complete_lifecycle_action(
                LifecycleHookName=msg['LifecycleHookName'],
                AutoScalingGroupName=msg['AutoScalingGroupName'],
                LifecycleActionToken=msg['LifecycleActionToken'],
                LifecycleActionResult='CONTINUE')
            responses.append(resp)
            log.debug("Completed ASG scaling event with: %s", resp)
        except botocore.exceptions.ClientError as e:
            log.error("Cannot finish autoscaling group event %s", e.message)

        log.info("Updating hosted zone %s record set", r53_zone_id)

        changes = {
            'Comment':
            "Updated by AutoScalingGroupsng group: {}".format(asg_name),
            'Changes': [{
                'Action': i['Action'],
                'ResourceRecordSet': {
                    'Name':
                    i['Name'],
                    'Type':
                    i['Type'],
                    'TTL':
                    int(i['TTL']),
                    'ResourceRecords': [{
                        'Value':
                        pystache.render(i['Template'], j)
                    } for j in instances]
                }
            } for i in metadata['Changes']]
        }
        log.info(c.jsonify(changes))
        r53_client.change_resource_record_sets(HostedZoneId=r53_zone_id,
                                               ChangeBatch=changes)
        responses.append({
            "MessageId": msg_id,
            "Result": "Dns records {} and {} has been updated"
        })

    return {'Responses': responses}
Ejemplo n.º 29
0
 def msg(self):
     return jsonify(result="notInGame")
Ejemplo n.º 30
0
 def msg(self):
     return jsonify(result="gameFull")
Ejemplo n.º 31
0
 def msg(self):
     return jsonify(result="alreadyInGame")
Ejemplo n.º 32
0
 def msg(self):
     return jsonify(result="gameExists")
Ejemplo n.º 33
0
 def msg(self):
     return jsonify(result="badMaxPlayers")
Ejemplo n.º 34
0
 def msg(self):
     return jsonify(result="badMap")