← Back to branch summary

~ubuntu-branches/ubuntu/wily/torrus/wily-proposed

« back to all changes in this revision

Viewing changes to perllib/Torrus/ConfigTree.pm

  • Committer: Package Import Robot
  • Author(s): Marc Haber
  • Date: 2011-11-06 17:15:40 UTC
  • mto: (6.1.1 experimental) (1.3.1)
  • mto: This revision was merged to the branch mainline in revision 7.
  • Revision ID: package-import@ubuntu.com-20111106171540-myc0auwqqio8bmhl
Tags: upstream-2.01
Import upstream version 2.01

Show diffs side-by-side

added added

removed removed

Lines of Context:
perllib/Torrus/ConfigTree.pm
14
14
#  along with this program; if not, write to the Free Software
15
15
#  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307, USA.
16
16
 
17
 
# $Id: ConfigTree.pm,v 1.8 2007/04/11 15:09:17 ssinyagin Exp $
 
17
# $Id$
18
18
# Stanislav Sinyagin <ssinyagin@yahoo.com>
19
19
 
20
20
 
43
43
    defined( $self->{'db_config_instances'} ) or return( undef );
44
44
 
45
45
    my $i = $self->{'db_config_instances'}->get('ds:' . $self->{'treename'});
46
 
    $i = 0 unless defined( $i );
 
46
    if( not defined($i) )
 
47
    {
 
48
        $i = 0;
 
49
        $self->{'first_time_created'} = 1;
 
50
    }
47
51
 
48
52
    my $dsConfInstance = sprintf( '%d', $i );
49
53
 
82
86
            {
83
87
                $self->{'db_config_instances'}->c_put( $cursor, $key, 1 );
84
88
            }
85
 
            undef $cursor;
 
89
            $self->{'db_config_instances'}->c_close($cursor);
86
90
            if( not $ok )
87
91
            {
88
92
                return undef;
209
213
            my( $param, $prop ) = split( /:/o, $key );
210
214
            $self->{'paramprop'}{$prop}{$param} = $val;
211
215
        }
 
216
        $self->{'db_paramprops'}->c_close($cursor);
212
217
        undef $cursor;
213
218
        $self->{'db_paramprops'}->closeNow();
214
219
        delete $self->{'db_paramprops'};
216
221
 
217
222
    
218
223
    $self->{'db_sets'} =
219
 
        new Torrus::DB('tokensets',
 
224
        new Torrus::DB('tokensets_' . $dsConfInstance,
220
225
                       -Subdir => $self->{'treename'}, -Btree => 0,
221
226
                       -WriteAccess => 1, -Truncate => $options{'-Rebuild'});
222
227
    defined( $self->{'db_sets'} ) or return( undef );
223
228
 
 
229
 
224
230
    $self->{'db_nodepcache'} =
225
231
        new Torrus::DB('nodepcache_' . $dsConfInstance,
226
232
                       -Subdir => $self->{'treename'}, -Btree => 1,
229
235
                                     not $options{'-NoDSRebuild'}));
230
236
    defined( $self->{'db_nodepcache'} ) or return( undef );
231
237
 
 
238
 
 
239
    $self->{'db_nodeid'} =
 
240
        new Torrus::DB('nodeid_' . $dsConfInstance,
 
241
                       -Subdir => $self->{'treename'}, -Btree => 1,
 
242
                       -WriteAccess => 1,
 
243
                       -Truncate => ($options{'-Rebuild'} and
 
244
                                     not $options{'-NoDSRebuild'}));
 
245
    defined( $self->{'db_nodeid'} ) or return( undef );
 
246
 
232
247
    return $self;
233
248
}
234
249
 
245
260
        my $cursor = $self->{'db_config_instances'}->cursor( -Write => 1 );
246
261
        $self->{'db_config_instances'}->c_put
247
262
            ( $cursor, 'compiling:' . $self->{'treename'}, 0 );
248
 
        undef $cursor;
 
263
        $self->{'db_config_instances'}->c_close($cursor);
249
264
    }
250
265
    else
251
266
    {
325
340
                    'timestamp' => $timestamp } );
326
341
            }
327
342
        }
328
 
        undef $cursor;
 
343
        $self->{'db_readers'}->c_close($cursor);
329
344
        if( @readers > 0 )
330
345
        {
331
346
            Info('Waiting for ' . scalar(@readers) . ' readers:');
366
381
                        $self->{'db_readers'}->c_del( $cursor );
367
382
                    }
368
383
                }
369
 
                undef $cursor;
 
384
                $self->{'db_readers'}->c_close($cursor);
370
385
                $noReaders = 1;
371
386
            }
372
387
        }
463
478
    return defined( $self->{'db_dsconfig'}->get( 'pt:'.$path ) );
464
479
}
465
480
 
 
481
 
 
482
sub nodeType
 
483
{
 
484
    my $self = shift;
 
485
    my $token = shift;
 
486
 
 
487
    my $type = $self->{'nodetype_cache'}{$token};
 
488
    if( not defined( $type ) )
 
489
    {
 
490
        $type = $self->{'db_dsconfig'}->get( 'n:'.$token );
 
491
        if( not defined( $type ) )
 
492
        {
 
493
            $type = -1;
 
494
        }
 
495
        $self->{'nodetype_cache'}{$token} = $type;
 
496
    }
 
497
    return $type;
 
498
}
 
499
    
 
500
 
466
501
sub isLeaf
467
502
{
468
503
    my $self = shift;
469
504
    my $token = shift;
470
505
 
471
 
    return( $self->{'db_dsconfig'}->get( 'n:'.$token ) == 1 );
 
506
    return ( $self->nodeType($token) == 1 );
472
507
}
473
508
 
 
509
 
474
510
sub isSubtree
475
511
{
476
512
    my $self = shift;
477
513
    my $token = shift;
478
514
 
479
 
    return( $self->{'db_dsconfig'}->get( 'n:'.$token ) == 0 );
 
515
    return( $self->nodeType($token) == 0 );
480
516
}
481
517
 
482
518
# Returns the real token or undef
485
521
    my $self = shift;
486
522
    my $token = shift;
487
523
 
488
 
    return( ( $self->{'db_dsconfig'}->get( 'n:'.$token ) == 2 ) ?
 
524
    return( ( $self->nodeType($token) == 2 ) ?
489
525
            $self->{'db_dsconfig'}->get( 'a:'.$token ) : undef );
490
526
}
491
527
 
495
531
    my $self = shift;
496
532
    my $token = shift;
497
533
 
498
 
    return split( /,/o, $self->{'db_dsconfig'}->get( 'ar:'.$token ) );
 
534
    return $self->{'db_dsconfig'}->getListItems('ar:'.$token);
499
535
}
500
536
 
501
537
 
525
561
    my $token = shift;
526
562
    my $param = shift;
527
563
 
528
 
    my $value;
 
564
    # walk up the tree and save the grandparent's value at parent's cache
 
565
    
 
566
    my $value;    
529
567
    my $currtoken = $token;
 
568
    my @ancestors;
 
569
    my $walked = 0;
 
570
    
530
571
    while( not defined($value) and defined($currtoken) )
531
572
    {
532
573
        $value = $self->getParam( $currtoken, $param, 1 );
533
574
        if( not defined $value )
534
575
        {
535
 
            # get the parent's token
 
576
            if( $walked )
 
577
            {
 
578
                push( @ancestors, $currtoken );
 
579
            }
 
580
            else
 
581
            {
 
582
                $walked = 1;
 
583
            }
 
584
            # walk up to the parent
536
585
            $currtoken = $self->getParent($currtoken);
537
586
        }
538
587
    }
 
588
 
 
589
    foreach my $ancestor ( @ancestors )
 
590
    {
 
591
        $self->{'paramcache'}{$ancestor}{$param} = $value;
 
592
    }
 
593
    
539
594
    return $self->expandNodeParam( $token, $param, $value );
540
595
}
541
596
 
572
627
        $changed = 0;
573
628
 
574
629
        # Substitute definitions
575
 
        if( index($value, "\$") >= 0 )
 
630
        if( index($value, '$') >= 0 )
576
631
        {
577
632
            if( not $value =~ /\$(\w+)/o )
578
633
            {
685
740
    return $value;
686
741
}
687
742
 
 
743
 
688
744
sub getParamNames
689
745
{
690
746
    my $self = shift;
693
749
 
694
750
    my $db = $fromDS ? $self->{'db_dsconfig'} : $self->{'db_otherconfig'};
695
751
 
696
 
    my $list = $db->get( 'Pl:'.$name );
697
 
    if( defined( $list ) )
698
 
    {
699
 
        return split( /,/o, $list );
700
 
    }
701
 
    else
702
 
    {
703
 
        return ();
704
 
    }
 
752
    return $db->getListItems('Pl:'.$name);
705
753
}
706
754
 
 
755
 
707
756
sub getParams
708
757
{
709
758
    my $self = shift;
710
759
    my $name = shift;
711
760
    my $fromDS = shift;
712
761
 
713
 
    my %ret = ();
 
762
    my $ret = {};
714
763
    foreach my $param ( $self->getParamNames( $name, $fromDS ) )
715
764
    {
716
 
        $ret{$param} = $self->getParam( $name, $param, $fromDS );
 
765
        $ret->{$param} = $self->getParam( $name, $param, $fromDS );
717
766
    }
718
 
    return \%ret;
 
767
    return $ret;
719
768
}
720
769
 
721
770
sub getParent
746
795
    }
747
796
    else
748
797
    {
749
 
        my $children = $self->{'db_dsconfig'}->get( 'c:'.$token );
750
 
 
751
 
        if( defined $children )
752
 
        {
753
 
            my @clist = split(/,/o, $children);
754
 
            map { $self->{'parentcache'}{$_} = $token; } @clist;
755
 
            return @clist;
756
 
        }
757
 
        else
758
 
        {
759
 
            return ();
760
 
        }
 
798
        return $self->{'db_dsconfig'}->getListItems( 'c:'.$token );
761
799
    }
762
800
}
763
801
 
888
926
}
889
927
 
890
928
 
 
929
sub getNodeByNodeid
 
930
{
 
931
    my $self = shift;
 
932
    my $nodeid = shift;
 
933
 
 
934
    return $self->{'db_nodeid'}->get( $nodeid );
 
935
}
 
936
 
 
937
# Returns arrayref or undef.
 
938
# Each element is an arrayref to [nodeid, token] pair
 
939
sub searchNodeidPrefix
 
940
{
 
941
    my $self = shift;
 
942
    my $prefix = shift;
 
943
 
 
944
    return $self->{'db_nodeid'}->searchPrefix( $prefix );
 
945
}
 
946
 
 
947
 
 
948
# Returns arrayref or undef.
 
949
# Each element is an arrayref to [nodeid, token] pair
 
950
sub searchNodeidSubstring
 
951
{
 
952
    my $self = shift;
 
953
    my $substring = shift;
 
954
 
 
955
    return $self->{'db_nodeid'}->searchSubstring( $substring );
 
956
}
 
957
 
 
958
 
 
959
 
891
960
sub getDefaultView
892
961
{
893
962
    my $self = shift;
948
1017
sub getViewNames
949
1018
{
950
1019
    my $self = shift;
951
 
    my $vlist = $self->{'db_otherconfig'}->get( 'V:' );
952
 
 
953
 
    return defined($vlist) ? split(/,/o, $vlist) : ();
 
1020
    return $self->{'db_otherconfig'}->getListItems( 'V:' );
954
1021
}
955
1022
 
956
1023
 
965
1032
sub getMonitorNames
966
1033
{
967
1034
    my $self = shift;
968
 
    my $mlist = $self->{'db_otherconfig'}->get( 'M:' );
969
 
 
970
 
    return defined($mlist) ? split(/,/o, $mlist) : ();
 
1035
    return $self->{'db_otherconfig'}->getListItems( 'M:' );
971
1036
}
972
1037
 
973
1038
sub monitorExists
981
1046
sub getActionNames
982
1047
{
983
1048
    my $self = shift;
984
 
    my $alist = $self->{'db_otherconfig'}->get( 'A:' );
985
 
 
986
 
    return defined($alist) ? split(/,/o, $alist) : ();
 
1049
    return $self->{'db_otherconfig'}->getListItems( 'A:' );
987
1050
}
988
1051
 
989
1052
 
1032
1095
sub getTsets
1033
1096
{
1034
1097
    my $self = shift;
1035
 
    my $list = $self->{'db_sets'}->get('S:');
1036
 
    return defined($list) ? split(/,/o, $list) : ();
 
1098
    return $self->{'db_sets'}->getListItems('S:');
1037
1099
}
1038
1100
 
1039
1101
sub tsetMembers
1041
1103
    my $self = shift;
1042
1104
    my $tset = shift;
1043
1105
 
1044
 
    my $list = $self->{'db_sets'}->get('s:'.$tset);
1045
 
    return defined($list) ? split(/,/o, $list) : ();
 
1106
    return $self->{'db_sets'}->getListItems('s:'.$tset);
 
1107
}
 
1108
 
 
1109
sub tsetMemberOrigin
 
1110
{
 
1111
    my $self = shift;
 
1112
    my $tset = shift;
 
1113
    my $token = shift;
 
1114
    
 
1115
    return $self->{'db_sets'}->get('o:'.$tset.':'.$token);
1046
1116
}
1047
1117
 
1048
1118
sub tsetAddMember
1050
1120
    my $self = shift;
1051
1121
    my $tset = shift;
1052
1122
    my $token = shift;
 
1123
    my $origin = shift;
1053
1124
 
1054
1125
    $self->{'db_sets'}->addToList('s:'.$tset, $token);
 
1126
    $self->{'db_sets'}->put('o:'.$tset.':'.$token, $origin);
1055
1127
}
1056
1128
 
1057
1129
 
1062
1134
    my $token = shift;
1063
1135
 
1064
1136
    $self->{'db_sets'}->delFromList('s:'.$tset, $token);
 
1137
    $self->{'db_sets'}->del('o:'.$tset.':'.$token);
1065
1138
}
1066
1139
 
1067
1140
# Definitions manipulation
1076
1149
sub getDefinitionNames
1077
1150
{
1078
1151
    my $self = shift;
1079
 
    my $dlist = $self->{'db_dsconfig'}->get( 'D:' );
1080
 
 
1081
 
    return defined($dlist) ? split(/,/o, $dlist) : ();
 
1152
    return $self->{'db_dsconfig'}->getListItems( 'D:' );
1082
1153
}
1083
1154
 
1084
1155