Foro - Perl en Español

por **tutoki** » 2012-10-09 17:03 @752

Hola, segun voy avanzando en esto de Perl me van surgiendo dudas que os expongo.

Tengo un fichero data.csv (que anexo), que después de tratarlo con Perl, creará varios ficheros xml que luego se convertirán en gráficos.

En este csv, se recogen varios valores, digamos principales:

campo(0) : "value" valor del dato, lo que aparece en la gráfica
campo(1) : "Timestamp" tiempo Eje X (día)
campo(2) : "MetricId" Eje Y (8 valores diferentes, agrupados en 3)

Son estos:
1ª agrupación -> @grupocpu = qw(cpu.ready.summation cpu.usage.average);

2ª agrupación -> @grupomem = qw(mem.active.average mem.consumed.average mem.granted.average mem.vmmemctl.average);

3ª agrupación -> @grupoio = qw(datastore.totalreadlatency.average datastore.totalwritelatency.average);

TODO Completo -> @stats = qw(cpu.ready.summation cpu.usage.average datastore.totalreadlatency.average datastore.totalwritelatency.average mem.active.average mem.consumed.average mem.granted.average mem.vmmemctl.average) ;

campo(5) : "Entity" Elemento sobre el que se realizan los cálculos (3 servidores)

@maquinas = qw (ropo01 ropo02 sav01)

Esto quiere decir que a cada cambio del campo 5 se deben de generar los hash relacionados con las agrupaciones de datos similares para poder generar los XML. En total serían 9 ficheros (3 elementos/servidores * 3 agrupaciones de datos similares).

¿Cómo lo hago? Genero 3 hash diferentes donde la clave sea el tiempo, es decir campo 1.

¿Cómo ataco este problema?

Gracias por anticipado.

Luego tengo que generar los XML, lo vemos más adelante.

un hash cuyas claves son las entidades, ya que son ellos el objeto principal de estudio
los valores de estos hash deberían ser una referencia a otro hash, cuyas claves serían el valor de MetricId
los valores de estos hash serían otra referencia a otro hash, cuyas claves serían los valores de Timestamp. Y sus valores, los del campo Value correspondiente

De esa manera, tendríamos algo así (una estructura tridimensional):

$datos{"ropo01"}->{"cpu.usage.average"}->{"09/10/2012 18:00:00"} = "1,35";

con lo que sería fácil recorrer, excepto en los Timestamp, que no tienen un formato estándar. Casi mejor transformarlos antes a un formato ISO 8601: "09/10/2012 18:00:00" => "20120910T180000", y así ya puedes, con un for y un sort, sacar los datos ordenados por fecha y hora.

por **tutoki** » 2012-10-10 17:37 @776

Estructura tridimensional, humm, intento acercarme a tus consejos, ( no muy acertadamente ;-)

)

Sintáxis: [ Descargar ] [ Ocultar ]

Using perl Syntax Highlighting

#!/usr/bin/perl 
#use warnings;
#use strict;
use Time::Local;
use v5.14;
use autodie;
 
my @datos;
my %datos;
my @Maquinas;
my %Maquinas;
my @Metricas;
my %data;
 
####################################################################################
#   Listas de variables a usar                                                     #
####################################################################################
 
#my @grupocpu = qw ( cpu_ready_summation cpu_usage_average);
#my @grupomem = qw ( mem_active_average mem_consumed_average mem_granted_average mem_vmmemctl_average);
#my @grupoio = qw ( datastore_totalreadlatency_average datastore_totalwritelatency_average);
my @stats
    = qw ( cpu_ready_summation cpu_usage_average datastore_totalreadlatency_average datastore_totalwritelatency_average mem_active_average mem_consumed_average mem_granted_average mem_vmmemctl_average);
 
#my @maquinas = qw (ropo01 ropo02 sav01);
 
####################################################################################
#   LEctura del fichero de entrada via entrada estandard                           #
####################################################################################
my $csv_a_procesar = shift;            # es igual a  shift @ARGV
 
open my $fh, "<", $csv_a_procesar;
 
## Lectura
 
while (<$fh>) {
 
    if ( $_ =~ /^"Value"/ ) {          # Nos saltamos la primera linea
        next;
    }
    else {
        chomp;                            # muerdo el retorno de carro final
        s/"//g;                           # Borro las comillas
        my @datos = split( ";", $_ );     # separo los campos
        $datos[0] =~ s/"//g,  $datos[0];     # Value
        $datos[1] =~ s/ /-/g, $datos[1];     # Timestamp
        $datos[1] =~ s/-(\d):/-0$1:/;        # Transformo fecha
        $datos[2] =~ s/\./_/g, $datos[2];    # MetricId
        my $Maquinas = $datos[5];            # Entity
        my $Metricas = $datos[2];
        $data{"$Maquinas"}->{"$Metricas"}->{"$datos[1]"} = $datos[0];
    }
}
 
close $fh;
 
# Imprime los datos
foreach my $data ( keys %data ) {
    say "$data = $data{%data}";        # no muestra lo que yo quiero
}
 
Coloreado en 0.005 segundos,  usando GeSHi 1.0.8.4

por **explorer** » 2012-10-10 19:03 @835

Ya... pero... ¿qué quieres sacar, y de qué forma?

Si se trata de una estructura tridimensional, debes acceder a ella de la misma manera en que la has creado.

Si quieres ver la estructura que se ha creado, puedes hacerle un Dumper:

Sintáxis: [ Descargar ] [ Ocultar ]

Using perl Syntax Highlighting

use Data::Dumper;
print Dumper(\%data);
Coloreado en 0.001 segundos,  usando GeSHi 1.0.8.4

Con eso verificas que la estructura está bien creada.

por **tutoki** » 2012-10-11 00:28 @061

Hola, explorer.
Necesito generar ficheros xml con los valores de estos datos.

ropo01
#cpu.ready.summation
#cpu.usage.average

ropo01
#datastore.totalreadlatency.average
#datastore.totalwritelatency.average

ropo01
#mem.active.average
#mem.consumed.average
#mem.granted.average
#mem.vmmemctl.average

ropo02..... igual que el anterior

sav01...... igual que el anterior

Con estos datos generaría varios XML, en este caso 9 ficheros ( 3 agrupaciones x 3 máquinas = 9) que entiendo se podría hacer en un bucle ( o en tres, uno por tipo de XML cpu., datastore., mem.)

Un ejemplo de XML:
#ropo01
#cpu.ready.summation
#cpu.usage.average
#####################################

Sintáxis: [ Descargar ] [ Ocultar ]

Using perl Syntax Highlighting

 ## Salida
    open my $fhout, ">", "ropo01.xml";
     
    say $fhout
        ' <chart showvalue="0" caption="Prueba con poco datos" xaxisname="tiempo" yaxisname="datos" palette="1">';
     
    say $fhout ' <categories>';
     
    for my $date (@fechas) {
        say $fhout qq(            <category label="$date" />);
    }
     
    say $fhout ' </categories>';
     
    say $fhout ' <dataset SeriesName="cpu.ready.summation">';
     
    for my $date (@fechas) {
        say $fhout qq(            <set value="$datos{$date}" />);
    }
     
    say $fhout ' </dataset>';
    say $fhout ' <dataset SeriesName="cpu.usage.average">';
     
    for my $date (@fechas) {
        say $fhout qq(            <set value="$datos{$date}" />);
    }
     
    say $fhout ' </dataset>';
    say $fhout ' </chart>';
     
    close $fhout;
 
Coloreado en 0.004 segundos,  usando GeSHi 1.0.8.4

por **tutoki** » 2012-10-12 13:30 @604

No sé si al final se entiende lo que estoy intentado hacer, cualquier ayuda será bienvenida.

SALUD...

por **explorer** » 2012-10-12 19:19 @846

La solución no es sencilla, porque se trata de una estructura tridimensional, de la que tenemos que modificar unos campos, y luego sacarlos de una determinada manera, y en un determinado orden. Y la sintaxis de Perl se complica a medida de que las estructuras se vuelven más complejas.

Esta es la primera solución, sin usar módulos:

Sintáxis: [ Descargar ] [ Ocultar ]

Using perl Syntax Highlighting

#!/usr/bin/perl 
use v5.14;              # activa programación estricta, salida de advertencias y nuevas características
use autodie;            # «Mejor morir que regresar con deshonor» --Proverbio Kinglon
 
####################################################################################
## Constantes
####################################################################################
my %medidas = (
    cpu => {
        caption   => "Uso de la CPU",
        xaxisname => "tiempo",
        yaxisname => "CPU",
        datos     => [qw(
                        cpu_ready_summation
                        cpu_usage_average
                    )],
    },
    mem => {
        caption   => "Uso de la memoria",
        xaxisname => "tiempo",
        yaxisname => "Memoria",
        datos     => [qw(
                        mem_active_average
                        mem_consumed_average
                        mem_granted_average
                        mem_vmmemctl_average
                    )],
    },
    io  => {
        caption   => "Uso de la E/S",
        xaxisname => "tiempo",
        yaxisname => "E/S",
        datos     => [qw(
                        datastore_totalreadlatency_average
                        datastore_totalwritelatency_average
                    )],
    },
);
 
####################################################################################
## Argumentos
####################################################################################
@ARGV == 1 or die "Uso: $0 <archivo CSV a procesar>\n";
 
my $archivo_csv = shift;
 
 
####################################################################################
## Lectura del archivo
####################################################################################
my %log;                # Almacena toda la información
my @campos;             # Nombre de los campos, en el orden en que aparecen
my %campos;             # Datos de cada línea
 
open my $INPUT, '<', $archivo_csv;
while (<$INPUT>) {
    chomp;
    s/"//g;
    my @datos = split /;/;                              # Separo los campos
 
    if ($. == 1) {                                      # Si es la primera línea
        @campos = @datos;                               # Leemos los nombres de los campos
    }
    else {
        @campos{@campos} = @datos;                      # %campos <- @datos
 
        my($dia, $mes, $year, $hora, $minuto, $segundo) = $campos{'Timestamp'} =~ /(\d+)/g;
        $campos{'Timestamp'} = sprintf "%02d%02d%02dT%02d%02d%02d", $year, $mes, $dia, $hora, $minuto, $segundo;
 
        $campos{'MetricId'} =~ s/[.]/_/g;
 
        $log{ $campos{'Entity'} }->{ $campos{'MetricId'} }->{ $campos{'Timestamp'} } = $campos{'Value'};
    }
}
 
close   $INPUT;
 
 
#use Data::Dumper;
#say Dumper \%log;           # comprobar que se genera bien la estructura
 
####################################################################################
## Salida
####################################################################################
for my $maquina (keys %log) {                                   # por cada máquina
 
    say $maquina;
 
    for my $medida (keys %medidas) {                            # por cada medida
        say "\t$medida";
 
        open my $SALIDA, '>', "${maquina}_$medida.xml";
 
        say $SALIDA
            '<',
            join(' ',
                'chart',
                'showvalue="0"',
                qq(caption="$medidas{$medida}->{caption}"),
                qq(xaxisname="$medidas{$medida}->{xaxisname}"),
                qq(yaxisname="$medidas{$medida}->{yaxisname}"),
                'palette="1"',
            ),
            '>'
            ;
                                                                # fechas
        say $SALIDA '  <categories>';
        my @fechas = sort keys %{ $log{$maquina}->{ ${$medidas{$medida}->{datos}}[0] } }; 
        for my $fecha (@fechas) {
            say $SALIDA qq(    <category label="$fecha" />);
        }
        say $SALIDA '  </categories>';
                                                                # por cada magnitud
        for my $item (@{ $medidas{$medida}->{datos}}) {
            say "\t\t$item";
 
            say $SALIDA qq(  <dataset SeriesName="$item">);
 
            for my $fecha (@fechas) {
                say $SALIDA qq(    <set value="$log{$maquina}->{$item}->{$fecha}" />);
            }
 
            say $SALIDA qq(  </dataset>);
        }
 
        say $SALIDA '</chart>';
 
        close   $SALIDA;
    }
}
 
__END__
Coloreado en 0.006 segundos,  usando GeSHi 1.0.8.4

Lo único reseñable es que usamos los campos de la primera línea del CSV (línea 62) para construir un hash (línea 65), y de esa manera, podemos acceder a los datos de las siguientes líneas sin tener que acordarnos que el 'Value' está en la posición 0, o el 'Timestamp' en el 1. Además, si en el futuro cambia de formato el CSV, el programa seguirá funcionando, aunque los campos cambien de posición.

Esta es otra solución, usando módulos y un poco más de Perl elaborado. Queda un poco más corta, claro.

Sintáxis: [ Descargar ] [ Ocultar ]

Using perl Syntax Highlighting

#!/usr/bin/perl 
use v5.14;
use autodie;            # «Mejor morir que regresar con deshonor» --Proverbio Kinglon
 
use Text::CSV::Slurp;
use XML::Simple;
 
 
####################################################################################
## Constantes
####################################################################################
my %medidas = (
    cpu => {
        caption   => "Uso de la CPU",
        xaxisname => "tiempo",
        yaxisname => "CPU",
        datos     => [qw(
                        cpu_ready_summation
                        cpu_usage_average
                    )],
    },
    mem => {
        caption   => "Uso de la memoria",
        xaxisname => "tiempo",
        yaxisname => "Memoria",
        datos     => [qw(
                        mem_active_average
                        mem_consumed_average
                        mem_granted_average
                        mem_vmmemctl_average
                    )],
    },
    io  => {
        caption   => "Uso de la E/S",
        xaxisname => "tiempo",
        yaxisname => "E/S",
        datos     => [qw(
                        datastore_totalreadlatency_average
                        datastore_totalwritelatency_average
                    )],
    },
);
 
####################################################################################
## Argumentos
####################################################################################
@ARGV == 1 or die "Uso: $0 <archivo CSV a procesar>\n";
 
my $archivo_csv = shift;
 
####################################################################################
## Lectura del archivo
####################################################################################
my $datos = Text::CSV::Slurp->load(file => $archivo_csv, sep_char => ';', quote_char => '"');
 
my %log;
 
for my $item ( @$datos ) {
    my($dia, $mes, $year, $hora, $minuto, $segundo) = $item->{Timestamp} =~ /(\d+)/g;
    $item->{Timestamp} = sprintf "%02d%02d%02dT%02d%02d%02d", $year, $mes, $dia, $hora, $minuto, $segundo;
    $item->{MetricId} =~ s/[.]/_/g;
 
    $log  { $item->{Entity   } }
        ->{ $item->{MetricId } }
        ->{ $item->{Timestamp} }
        =   $item->{Value    };
}
 
 
####################################################################################
## Salida
####################################################################################
for my $maquina (keys %log) {                                   # por cada máquina
    say $maquina;
 
    for my $medida (keys %medidas) {                            # por cada medida
        say "\t$medida";
 
        # la raíz de todos los males
        my $xml = {
            chart => {
                showvalue       => 0,
                caption         => $medidas{$medida}->{caption  },
                xaxisname       => $medidas{$medida}->{xaxisname},
                yaxisname       => $medidas{$medida}->{yaxisname},
                palette         => 1,
            }
        };
        
        # fechas
        my @fechas = sort keys %{ $log{$maquina}->{ ${$medidas{$medida}->{datos}}[0] } }; 
 
        $xml->{chart}->{categories}->{category} = [ map { { label => $_ } } @fechas ];
 
        # por cada magnitud
        for my $item (@{ $medidas{$medida}->{datos}}) {
            say "\t\t$item";
 
            # sacamos el conjunto de datos, para esas fechas
            my @set = map { { value => $log{$maquina}->{$item}->{$_} } } @fechas;
 
            push @{ $xml->{chart}->{dataset} }, {
                SeriesName => $item,
                set        => [ @set ],
            };
        }
 
        open my $SALIDA, '>', "${maquina}_$medida.xml";
        print   $SALIDA XMLout($xml, KeepRoot => 1);
        close   $SALIDA;
    }
}
 
__END__
Coloreado en 0.004 segundos,  usando GeSHi 1.0.8.4

Bueno, son solo veinte líneas menos, pero queda un poco más claro, y más fácil de mantener en el futuro.

La salida son los nueve archivos, con este aspecto:

Sintáxis: (sav01_cpu.xml) [ Descargar ] [ Ocultar ]

Using xml Syntax Highlighting

<chart caption="Uso de la CPU" palette="1" showvalue="0" xaxisname="tiempo" yaxisname="CPU">
  <categories>
    <category label="20121009T000000" />
    <category label="20121009T020000" />
    <category label="20121009T040000" />
    <category label="20121009T060000" />
    <category label="20121009T080000" />
    <category label="20121009T100000" />
    <category label="20121009T120000" />
    <category label="20121009T140000" />
    <category label="20121009T160000" />
    <category label="20121009T180000" />
  </categories>
  <dataset SeriesName="cpu_ready_summation">
    <set value="5557" />
    <set value="5468" />
    <set value="5243" />
    <set value="5765" />
    <set value="6066" />
    <set value="6227" />
    <set value="6385" />
    <set value="5928" />
    <set value="5893" />
    <set value="5521" />
  </dataset>
  <dataset SeriesName="cpu_usage_average">
    <set value="1,51" />
    <set value="1,48" />
    <set value="1,52" />
    <set value="1,49" />
    <set value="1,59" />
    <set value="1,67" />
    <set value="1,66" />
    <set value="1,58" />
    <set value="1,52" />
    <set value="1,56" />
  </dataset>
</chart>
Coloreado en 0.001 segundos,  usando GeSHi 1.0.8.4

por **tutoki** » 2012-10-12 19:21 @848

Este código (es de otra consulta que hice) que pego está adaptado a la consulta de este hilo.

En el hilo original era más fácil ya que solo había dos campos a tratar y no cambiaban.

El quid de la cuestión yo creo que está en el CSV que anexo, os copio un extracto.

Quizás el problema presentado es mas complejo de lo que yo pensaba y podemos dividir en trozos más sencillos para poder ir avanzando, el código intenta escribir en un fichero XML solo las métricas (MetricId) cpu.usage.average y cpu.ready.summation de ropo01 (Entity)

Sintáxis: [ Descargar ] [ Ocultar ]

Using text Syntax Highlighting

"Value";"Timestamp";"MetricId";"Unit";"Description";"Entity";

"1,35";"09/10/2012 18:00:00";"cpu.usage.average";"%";"CPU usage";"ropo01"

"5512";"09/10/2012 18:00:00";"cpu.ready.summation";"millisecond";"Percentage ;"ropo01"</span>

"4186112";"09/10/2012 18:00:00";"mem.granted.average";"KB";"memory ";"ropo01"

"84616";"09/10/2012 18:00:00";"mem.active.average";"KB";"memory actively";"ropo01"

"0";"09/10/2012 18:00:00";"mem.vmmemctl.average";"KB";"memory";"ropo01";Coloreado en 0.000 segundos,  usando GeSHi 1.0.8.4

Sintáxis: [ Descargar ] [ Ocultar ]

Using perl Syntax Highlighting

#!/usr/bin/perl 
use autodie;
use Text::CSV::Slurp;
use XML::Simple;
 
my $csv_a_procesar = shift
    or die "Uso: $0 <nombre de fichero>\n";
 
my $data = Text::CSV::Slurp->load(                      # Leer archivo CSV
    file        => $csv_a_procesar,
#   quote_char  => q["],
    sep_char    => q[;],
);
 
my @category;
my @set1;
my @set2;
 
for my $data (@$data) {                                  
    push @category,  { label => $data->{'Timestamp'} };  
    push @set1,      { value => $data->{'Value'    } };#aquí habría que procesar solo los valores de cpu_ready_summation   
    push @set2,      { value => $data->{'Value'    } };#aquí habría que procesar solo los valores de cpu_usage_average
}
 
my $xml1 = {                                            # cabecera del XML
        chart => {
            showvalue   => 0,
            caption     => 'Solo CPU',
            xaxisname   => 'tiempo',
            yaxisname   => 'datos',
            palette     => 1,
        }
    };
 
my $xml2 = { category => \@category };                  # categories
 
my $xml3 = {                                            # dataset
    dataset => {
        SeriesName => 'cpu_ready_summation',                    # Aquí solo se deberían de escribir 
        set => \@set1,                                                                  # los datos de esta métrica en particular
    }
};
my $xml4 = {                                            # dataset
    dataset => {
        SeriesName => 'cpu_usage_average',                              # Aquí solo se deberían de escribir
        set => \@set2,                                                                  # los datos de esta métrica en particular
    }
};
 
 
my $xml5 = {chart};
 
open my $fhout, ">", "test1.xml";    #salida
 
print   $fhout XMLout($xml1, KeepRoot => 0, RootName => '');
print   $fhout XMLout($xml2, RootName => 'categories' );
print   $fhout XMLout($xml3, KeepRoot => 1 );
print   $fhout XMLout($xml4, KeepRoot => 1 );
print   $fhout XMLout($xml5, RootName => '/chart' );
close   $fhout;
Coloreado en 0.002 segundos,  usando GeSHi 1.0.8.4

por **tutoki** » 2012-10-12 19:34 @857

bufff "tas pasao", no tengo palabras. Déjame digerirlo, buenas noches

SALUD

por **tutoki** » 2012-10-14 15:55 @704

Hola

Tenía una ristra de preguntas pero analizándolas veo que el problema que tengo es que me pierdo con la referencias (sobretodo), los hashes de arrays o los arrays de arrays, etcétera.

Líneas como:

Sintáxis: [ Descargar ] [ Ocultar ]

Using perl Syntax Highlighting

my @fechas = sort
                  keys %{ $log{$maquina}->{ ${ $medidas{$medida}->{datos} }[0] } };
#
for my $item ( @{ $medidas{$medida}->{datos} } )
#
open my $SALIDA, '>', "${maquina}_$medida.xml";
Coloreado en 0.001 segundos,  usando GeSHi 1.0.8.4

A mi no se me ocurrirían ni amenazándome de muerte y por muchos tutoriales que lea tampoco te creas que me acaba de quedar claro.

Bien, voy a trabajar con las dos pedazo de soluciones que me has dado para generar menos ficheros (por ejemplo 3, uno por máquina) a ver qué tal se me da.

cualquier pista sera bienvenida,

Muchas Gracias y hasta la próxima

SALUD...

Foro - Perl en Español

Parseando CSV

Parseando CSV

Publicidad

Re: Parseando CSV

Re: Parseando CSV

Re: Parseando CSV

Re: Parseando CSV

Re: Parseando CSV

Re: Parseando CSV

Re: Parseando CSV

Re: Parseando CSV

Re: Parseando CSV

¿Quién está conectado?