mejores prácticas para administrar y cargar propiedades

Question

Espero conocer algunos de los mejores enfoques para administrar archivos de propiedades.

Tenemos un conjunto de dispositivos (decirlo). Cada uno de estos dispositivos tiene ciertas propiedades. p. dispositivo A tiene propiedades

A.a11 = valuea11

A.a12 = valuea12

.

Dispositivo B tiene propiedades

B.b11 = valueb11

B.b12 = valueb12 .

Aparte de esto tienen algunas propiedades comunes aplicables para todos los dispositivos.

X.x11 = valuex11

X.x12 = valuex12

Estoy escribiendo una automatización para la ejecución de algunos de pruebas en estos dispositivos. Por vez, pruebe el script en ejecución en un solo dispositivo. El nombre del dispositivo se pasará como un argumento. Según el nombre del dispositivo, el código captará las propiedades y propiedades comunes respectivas y actualizará el dispositivo con estas propiedades. p.ej. para el dispositivo A, el código tomará las propiedades A.a11, A.a12 (específico del dispositivo A) y X.x11, X.x12 (común) y lo cargará en el dispositivo antes de ejecutar el script de prueba.

Por lo tanto, en el código, lo que necesito para administrar estas propiedades de manera que sólo los dispositivos propiedades específicas y comunes serán colocados en el dispositivo, ignorando el resto. Estoy manejando como este dispositivo de gestión de

if ($device eq 'A') then 
    upload A's properties 
elsif ($device eq 'B') then 
    upload B's properties 
endif 

upload Common (X) properties. 

de esta manera se está convirtiendo poco difícil, ya que el número de dispositivos se mantienen en aumento.

Así que estoy deseando por alguna otra mejor enfoque para gestionar estas propiedades.

Answer 1

Este es un buen caso en v (también conocido como rasgos de la literatura generalizada programación orientada a objetos) serán útiles.

En lugar del objeto clásico es una clase, con papeles un objeto * * hace un papel.

Mira la documentación de los alces apropiadas para la forma más información.

Ejemplo:

package Device::ActLikeA; 
use Moose::Role; 

has 'attribute' => (
    isa => string, 
    is => 'rw', 
    default => 'Apple', 
); 

sub an_a_like_method { 
    my $self = shift; 

    # foo 
} 

1; 

Así que ahora tengo un papel llamado Device::ActLikeA, ¿qué hago con ella?

Bueno, se puede aplicar el papel a una clase, y el código y atributos definidos en ActLikeA estará disponible en la clase:

package Device::USBButterChurn; 
use Moose; 

does 'Device::ActLikeA'; 

# now has an attribute 'attribute' and a method 'an_a_like_method' 
1; 

También puede aplicar funciones a instancias individuales de una clase.

package Device; 
use Moose; 

has 'part_no' => (
    isa => 'Str', 
    is => 'ro', 
    required => 1, 
); 

has 'serial' => { 
    isa => 'Str', 
    is => 'ro', 
    lazy => 1, 
    build => '_build_serial', 
); 

1; 

Y a continuación, el código principal que mira a la pieza y se aplica roles apropiados:

my @PART_MATCH = (
    [ qr/Foo/,    'Device::MetaSyntacticVariable' ], 
    [ qr/^...-[^_]*[A][^-], 'Device::ActLikeA; ], 
    [ qr/^...-[^_]*[B][^-], 'Device::ActLikeB; ], 
# etc 
); 

my $parts = load_parts($config_file); 

for my $part (@$parts) { 

    my $part_no = $part->part_number(); 

    for my $_ (@PART_MATCH) { 
     my ($match, $role) = @$_; 
     $part->apply_role($role) 
      if $part_no =~ /$match/; 
    } 

} 

Answer 2

Aquí es un enfoque muy directo.

En primer lugar usted necesita una manera de indicar que A "es-un" X y B "es-un" X, es decir, X es una matriz de A y B.

Luego, su voluntad upload_device rutina algo parecido a esto:

sub upload_properties { 
    my $device = shift; 
    ... upload the "specific" properties of $device ... 
    for my $parent (parent's of $device) { 
    upload_properties($parent); 
    } 
} 

una aplicación:

Indicar el "es-un" relación con una línea en el fichero de configuración como:

A.isa = X 

(Siéntase libre de utilizar alguna otra sintaxis - lo que utilice dependerá de cómo desea analizar el archivo.)

Desde el archivo de configuración, crear un hash de todos los dispositivos que tiene este aspecto:

$all_devices = { 
    A => { a11 => valuea11, a12 => valuea12, isa => [ 'X' ]}, 
    B => { b11 => valueb11, b12 => valueb12, isa => [ 'X' ] }, 
    X => { x11 => valuex11, x12 => valuex12, isa => [] }, 
} 

el upload_properties rutina:

sub upload_properties { 
    my ($device) = @_; 
    for my $key (keys %$device) { 
    next if $key eq "isa"; 
    ... upload property $key => $device->{$key} ... 
    } 
    my $isa = $device->{isa}; # this should be an array ref 
    for my $parent_name (@$isa) { 
    my $parent = $all_devices->{$parent_name}; 
    upload_properties($parent); 
    } 
} 

# e.g. to upload device 'A': 

upload_properties($all_devices->{'A'}); 

Answer 3

se puede eliminar la gran cadena if-else mediante el almacenamiento de las propiedades del dispositivo en un hash. Entonces solo necesita asegurarse de que el $ dispositivo particular aparezca en ese hash.

#!/usr/bin/perl 
use warnings; 
use strict; 

my %vals = (
    A => { 
     a11 => 'valuea11', 
     a12 => 'valuea12', 
    }, 
    B => { 
     b11 => 'valueb11', 
     b12 => 'valueb12', 
    }, 
); 

foreach my $device qw(A B C) { 
    if (exists $vals{$device}) { 
     upload_properties($vals{$device}); 
    } 
    else { 
     warn "'$device' is not a valid device\n"; 
    } 
} 

sub upload_properties { 
    my($h) = @_; 
    print "setting $_=$h->{$_}\n" for sort keys %$h; # simulate upload 
    print "\n"; 
}