Example #1
0
 def handle(self, *args, **options):
     output_cfg = {}
     sql_conditions = {}
     find_type = 'normal'
     code = 0
 
     CollectorRegistry.load()
     if options.get('list_stats'):
         cols = CollectorRegistry.all()
         print 'Available Statistics:'
         for col in cols:
            print "{0:20} - {1}".format(col.stat.collector, col.desc)
         sys.exit(0)
         
     since_regex = re.search('(\d+(?:\.?\d+)?)([hdwm])?', options.get('since', ''))
     if options.get('since') == 'last':
         find_type = 'last'
     elif since_regex is not None:
         num, unit = since_regex.groups()
         num = float(num)
         if unit == 'h':
             time = datetime.now() - timedelta(hours=num)
         elif unit == 'd':
             time = datetime.now() - timedelta(days=num)
         elif unit == 'w':
             time = datetime.now() - timedelta(weeks=num)
         elif unit == 'm':
             time = datetime.now() - timedelta(minutes=num)
         else:
             time = datetime.now() - timedelta(seconds=num)
         sql_conditions['since'] = time
             
     if options.get('where') is not None:
         sql_conditions['where'] = options.get('where')
     
     if options.get('group_by') is not None:
         sql_conditions['group'] = options.get('group_by')
         
     if options.get('select_columns') is not None:
         sql_conditions['select'] = options.get('select_columns')
         
     if options.get('order_by') is not None:
         sql_conditions['order'] = options.get('order_by')
         
     if options.get('limit') is not None:
         sql_conditions['limit'] = options.get('limit')
     
     for k,v in settings.REPORT_OPTIONS.items():
         output_cfg[k] = v
             
     output_cfg['full'] = options.get('output_full')
     output_cfg['raw'] = options.get('output_raw')
     output_cfg['display_width'] = options.get('output_width')
     
     output = Formatter.get_runner_for(options.get('output'))(sys.stderr)
     
     try:
         Model = TrackingTable._TrackingTable__tables.get(options.get('stat', 'definition'))
         if find_type == 'normal':
             query = Model.objects.all()
         else:
             query = Model.objects.find_most_recent_versions(Model)
         
         if sql_conditions.get('since') is not None:
             query = query.filter(run_time__gte=sql_conditions.get('since'))
         
         if sql_conditions.get('where') is not None:
             query = query.extra(where=[sql_conditions.get('where'),])
         
         if sql_conditions.get('order') is not None:
             cols = sql_conditions.get('order').split(',')
             query = query.order_by(*cols)
         
         # Do reject_ignores filter before limit
         if not output_cfg.get('raw', False):
             if settings.USE_INCLUDE_NOT_IGNORE:
                 query = output.report_include(query)
             else:
                 query = output.reject_ignores(query)
         if sql_conditions.get('limit') is not None:
             query = query[:sql_conditions.get('limit')]
         code = output.format(query, output_cfg)
     except Exception, e:
         tb = traceback.format_exc()
         if settings.SEND_CRASHREPORTS:
             logger = logging.getLogger('tableizer')
         else:
             logger = logging.getLogger('management_command')
         logger.error(tb)
Example #2
0
                hs.pop('timestamp')
            if u.table_perm:
                hs.pop('table_priv')
                hs.pop('column_priv')
            elif u.column_perm:
                hs.pop('column_priv')
            elif u.proc_perm:
                hs.pop('proc_priv')
            
            newu = rd.stat(**hs)
            if u.table_perm:
                newu.perms_fromsetstr(curp.get('table_priv'))
            elif u.column_perm:
                newu.perms_fromsetstr(curp.get('column_priv'))
            elif u.proc_perm:
                newu.perms_fromsetstr(curp.get('proc_priv'))
            newu.save()
            rd.stat_updated(newu.id, u.id)

Collector(TableUser, "user privilige tracking", action)

def for_action(stream, data, options):
    col_width = options.get('display_width', 80)
    server = str(data.server) if data.server is not None else ''
    if not options.get('header', False):
        stream.write('{1:15} {2:{0}}\n'.format(col_width-15, server, data))
    else:
        stream.write('{1:15} {2:{0}}\n'.format(col_width-15, 'host', 'grant'))

Formatter.proc_for('user', 'text', for_action)
Example #3
0
            rd.stat_updated(tbl.id, t.id)
            rd.logger.info("[deleted] %s" % (rd.stat.objects.filter(id=t.id).values()))
            
    return rd

Collector(TableDefinition, "'create syntax' tracking", action)

def for_action(stream, data, options):
    display_width = options.get('display_width', 80)
    col_width = display_width/5
    server = str(data.server) if data.server is not None else ''
    database_name = str(data.database_name) if data.database_name is not None else ''
    table_name = str(data.table_name) if data.table_name is not None else ''
    if not options.get('header', False):
        stream.write('{1:^10} {2:^{0}} {3:^{0}} {4:^{0}} {5:^15}\n'.format(col_width,
                                                                            data.status,
                                                                            server[:col_width],
                                                                            database_name[:col_width],
                                                                            table_name[:col_width],
                                                                            str(data.created_at)))
        if options.get('full', False):
            stream.write('{1}\n{2:{0}}\n{3:{0}}\n{4}\n'.format(display_width,
                                                    'OLD:',
                                                    data.previous_version.create_syntax if data.previous_version is not None else '',
                                                    'NEW:',
                                                    data.create_syntax))
    else:
        stream.write('{1:^10} {2:^{0}} {3:^{0}} {4:^{0}} {5:^15}\n'.format(col_width, 'status', 'server', 'database name', 'table name', 'created at'))

Formatter.proc_for('definition', 'text', for_action)
Example #4
0
                                                                                        data.data_length/1024/1024 if data.data_length is not None else '',
                                                                                        data.index_length/1024/1024 if data.index_length is not None else '',
                                                                                        data.data_free/1024/1024 if data.data_free is not None else ''))
        else:
            stream.write('{1:10} {2:{0}} {3:{0}} {4:{0}} {5:^18}\n'.format(col_width,
                                                                        data.status[:10],
                                                                        server[:col_width],
                                                                        database_name[:col_width],
                                                                        table_name[:col_width],
                                                                        (data.data_length + data.index_length)/1024/1024 \
                                                                        if data.data_length is not None and data.index_length is not None else ''))
    else:
        if options.get('full', False):
            stream.write('{1:^10} {2:^{0}} {3:^{0}} {4:^{0}} {5:^18} {6:^18} {7:^18}\n'.format(col_width,
                                                                                        'status',
                                                                                        'server',
                                                                                        'database name',
                                                                                        'table name', 
                                                                                        'data length(mb)',
                                                                                        'index length(mb)',
                                                                                        'data free(mb)'))
        else:
            stream.write('{1:^10} {2:^{0}} {3:^{0}} {4:^{0}} {5:^18}\n'.format(col_width,
                                                                        'status',
                                                                        'server',
                                                                        'database name',
                                                                        'table name',
                                                                        'size(mb)'))

Formatter.proc_for('volume', 'text', for_action)
Example #5
0
            rd.stat_updated(tbl.id, t.id)
            rd.logger.info("[deleted] %s" % (rd.stat.objects.filter(id=t.id).values()))
            
    return rd
    
Collector(TableView,  "'create view' tracking", action)

def for_action(stream, data, options):
    display_width = options.get('display_width', 80)
    col_width = display_width/5
    server = str(data.server) if data.server is not None else ''
    database_name = str(data.database_name) if data.database_name is not None else ''
    table_name = str(data.table_name) if data.table_name is not None else ''
    if not options.get('header', False):
        stream.write('{1:^10} {2:^{0}} {3:^{0}} {4:^{0}} {5:^15}\n'.format(col_width,
                                                                            data.status,
                                                                            server[:col_width],
                                                                            database_name[:col_width],
                                                                            table_name[:col_width],
                                                                            str(data.created_at)))
        if options.get('full', False):
            stream.write('{1}\n{2:{0}}\n{3:{0}}\n{4}\n'.format(display_width,
                                                    'OLD:',
                                                    data.previous_version.create_syntax if data.previous_version is not None else '',
                                                    'NEW:',
                                                    data.create_syntax))
    else:
        stream.write('{1:^10} {2:^{0}} {3:^{0}} {4:^{0}} {5:^15}\n'.format(col_width, 'status', 'server', 'database name', 'table name', 'created at'))

Formatter.proc_for('view', 'text', for_action)