CODEWITHSUNDEEP
javaperloopdesign-patternsproperties
rpg
rpg

Reputation: 1652

best practices to managing and loading properties

I am looking forward to know some best approaches to manage properties files.

We have a set of devices (say N). Each of these devices has certain properties. e.g. Device A has properties

A.a11=valuea11

A.a12=valuea12

.

Device B has properties

B.b11=valueb11

B.b12=valueb12 .

Apart from this they have some common properties applicable for all devices.

X.x11=valuex11

X.x12=valuex12

I am writing an automation for running some test suites on these devices. At a time, test script on run on a single device. The device name will be passed as a argument. Based on the device name, code will grab the respective properties and common properties and update the device with these properties. e.g. for device A, code will grab the A.a11, A.a12 (device A specific) and X.x11, X.x12 (common) properties and upload it to the device before running test script.

So, in code, I need to manage these properties so that only device specific and common properties will be uploaded to the device, ignoring the rest one. I am managing it like this

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

upload Common (X) properties.

Managing device in this way is becoming little bit difficult as the number of devices are keep on increasing.

So I am looking forward for some other best approach to manage these properties.

Upvotes: 6

Views: 493

Answers (3)

tadmc
tadmc

Reputation: 3744

You can eliminate the large if-else chain by storing the device properties in a hash. Then you need only ensure that the particular $device appears in that 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";
}

Upvotes: 0

ErikR
ErikR

Reputation: 52039

Here is a very direct approach.

First of all you need a way to indicate that A "is-a" X and B "is-a" X, i.e. X is a parent of both A and B.

Then your upload_device routine will look something like this:

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

One implementation:

Indicate the "is-a" relationship with a line in your config file like:

A.isa = X

(Feel free to use some other syntax - what you use will depend on how you want to parse the file.)

From the config file, create a hash of all devices that looks like this:

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

The upload_properties routine:

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'} );

Upvotes: 0

daotoad
daotoad

Reputation: 27183

This is a good case where v (aka traits in generalized OOP literature) will be useful.

Instead of the classical object is a class, with roles an object *does a * role.

Check out the appropriate Moose docs for way more information.

Example:

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

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

sub an_a_like_method {
    my $self = shift;

    # foo
}

1;

So now I have a role called Device::ActLikeA, what do I do with it?

Well, I can apply the role to a class, and the code and attributes defined in ActLikeA will be available in the class:

package Device::USBButterChurn;
use Moose;

does 'Device::ActLikeA';

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

You can also apply roles to individual instances of a class.

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;

And then main code that looks at the part and applies appropriate roles:

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/;
    }

}

Upvotes: 3

Related Questions