Debian Codegraph @

xpp/perl_modules/Dahdi/Config/Gen.pm

raw
1 package Dahdi::Config::Gen;
2 #
3 # Written by Oron Peled <[email protected]>
4 # Copyright (C) 2009, Xorcom
5 # This program is free software; you can redistribute and/or
6 # modify it under the same terms as Perl itself.
7 #
8 # $Id$
9 #
10
11 =head1 NAME
12
13 Dahdi::Config::Gen -- Wrapper class for configuration generators.
14
15 =head1 SYNOPSIS
16
17 use Dahdi::Config::Gen qw(is_true);
18 my $params = Dahdi::Config::Params->new('the-config-file');
19 my $gconfig = Dahdi::Config::Gen->new($params);
20 my $num = $gconfig->{'base_exten'};
21 my $overlap = is_true($gconfig->{'brint_overlap'});
22 $gconfig->dump; # For debugging
23 $gconfig->run_generator('system', {}, @spans);
24
25 =head1 DESCRIPTION
26
27 The constructor must be given an C<Dahdi::Config::Params> object.
28 The returned object contains all data required for generation in the
29 form of a hash.
30
31 The constructor maps the C<item()>s from the parameter object into semantic
32 configuration keys. E.g: the C<lc_country> item is mapped to C<loadzone> and
33 C<defaultzone> keys.
34
35 The actual generation is done by delegation to one of the generators.
36 This is done via the C<run_generator()> method which receive the
37 generator name, a generator specific options hash and a list of
38 span objects (from C<Dahdi::Span>) for which to generate configuration.
39
40 This module contains few helper functions. E.g: C<is_true()>, C<bchan_range()>.
41
42 =cut
43
44 require Exporter;
45 @ISA = qw(Exporter);
46
47 @EXPORT_OK = qw(is_true);
48
49 use strict;
50
51 # Parse values as true/false
52 sub is_true($) {
53 my $val = shift;
54 return undef unless defined $val;
55 return $val =~ /^(1|y|yes)$/i;
56 }
57
58 sub range_string($$) {
59 my ($start, $end) = @_;
60
61 if($start == $end) {
62 sprintf "%d", $start;
63 } else {
64 sprintf "%d-%d", $start, $end;
65 }
66 }
67
68 # Generate channel range strings from arrays of chan numbers
69 # E.g: "63-77,79-93"
70 sub channo_range(@) {
71 my @channos = sort { $a <=> $b } @_;
72 my $first_num = $channos[0];
73 my $range_start = $first_num;
74 my @range;
75 my $prev = undef;
76
77 foreach my $c (@channos) {
78 my $curr = $c;
79 if(!defined($prev)) {
80 # First iteration
81 $prev = $curr;
82 } elsif($curr != $prev + 1) {
83 # New range
84 push(@range, range_string($range_start, $prev));
85 $range_start = $curr;
86 }
87 $prev = $curr;
88 }
89 if($prev >= $first_num) {
90 # Last range
91 push(@range, range_string($range_start, $prev));
92 }
93 return join(',', @range);
94 }
95
96 # Generate channel range strings from chan objects
97 # E.g: "63-77,79-93"
98 sub chan_range(@) {
99 my @chans = sort { $a->num <=> $b->num } @_;
100 my @channos = map { $_->num } @chans;
101 channo_range(@channos);
102 }
103
104 # Generate channel range strings from digital span objects
105 # E.g: "63-77,79-93"
106 sub bchan_range($) {
107 my $span = shift || die;
108 die unless $span->is_digital();
109 my $first_chan = ($span->chans())[0];
110 my $first_num = $first_chan->num();
111 my $bchan_ref = $span->bchan_list();
112 my @channos = map { $_ + $first_num } @{$bchan_ref};
113 channo_range(@channos);
114 }
115
116 # Returns a channel numbers array from a channel range string
117 sub parse_chan_range($) {
118 my $rangestr = shift;
119 $rangestr =~ s/\s*//g; # Squeeze
120 die "Bad characters in '$rangestr'" if $rangestr =~ /[^\d\s,-]/;
121 my @ranges = split(/,/, $rangestr);
122 my @channos;
123 my $last_end;
124
125 foreach my $range (@ranges) {
126 my ($start, $end) = split(/-/, $range, 2);
127 $end = $start unless defined $end;
128 die "Bad characters in '$start'" if $start =~ /\D/;
129 die "Bad characters in '$end'" if $end =~ /\D/;
130 die "Reversed range $end < $start" if $end < $start;
131 die "Channel number < 1" if $start < 1;
132 die "New range begins below previous $start <= $last_end" if defined($last_end) && $last_end >= $start;
133 for(my $i = $start + 0; $i <= $end; $i++) {
134 push(@channos, $i);
135 }
136 $last_end = $end;
137 }
138 return sort { $a <=> $b } @channos;
139 }
140
141 sub new($) {
142 my $pack = shift || die "$0: Missing package argument";
143 my $p = shift || die "$0: Missing parameters argument";
144
145 # Set defaults
146 my $fxs_default_start = $p->item('fxs_default_start');
147 my $fxo_default_start = $p->item('fxo_default_start');
148
149 my %default_context = (
150 FXO => $p->item('context_lines'),
151 FXS => $p->item('context_phones'),
152 IN => $p->item('context_input'),
153 OUT => $p->item('context_output'),
154 DYN => $p->item('context_lines'),
155 BRI_TE => $p->item('context_lines'),
156 BRI_NT => $p->item('context_lines'),
157 E1_TE => $p->item('context_lines'),
158 T1_TE => $p->item('context_lines'),
159 J1_TE => $p->item('context_lines'),
160 E1_NT => $p->item('context_lines'),
161 T1_NT => $p->item('context_lines'),
162 J1_NT => $p->item('context_lines'),
163 );
164 my %default_group = (
165 FXO => $p->item('group_lines'),
166 FXS => $p->item('group_phones'),
167 IN => '',
168 OUT => '',
169 DYN => '',
170 BRI_TE => $p->item('group_lines'),
171 BRI_NT => $p->item('group_lines'),
172 E1_TE => $p->item('group_lines'),
173 T1_TE => $p->item('group_lines'),
174 J1_TE => $p->item('group_lines'),
175 E1_NT => $p->item('group_lines'),
176 T1_NT => $p->item('group_lines'),
177 J1_NT => $p->item('group_lines'),
178 );
179 my %default_dahdi_signalling = (
180 FXO => "fxs$fxo_default_start",
181 FXS => "fxo$fxs_default_start",
182 IN => "fxo$fxs_default_start",
183 OUT => "fxo$fxs_default_start",
184 DYN => "clear",
185 );
186 my %default_chan_dahdi_signalling = (
187 FXO => "fxs_$fxo_default_start",
188 FXS => "fxo_$fxs_default_start",
189 IN => "fxo_$fxs_default_start",
190 OUT => "fxo_$fxs_default_start",
191 DYN => "auto", # Cheating. Won't really work
192 );
193
194 # First complex mapping
195 my $gconfig = {
196 PARAMETERS => $p,
197 'loadzone' => $p->item('lc_country'),
198 'defaultzone' => $p->item('lc_country'),
199 'context' => \%default_context,
200 'group' => \%default_group,
201 'dahdi_signalling' => \%default_dahdi_signalling,
202 'chan_dahdi_signalling' => \%default_chan_dahdi_signalling,
203 };
204 # Now add trivial mappings
205 my @trivial = qw(
206 base_exten
207 freepbx
208 fxs_immediate
209 bri_hardhdlc
210 bri_sig_style
211 r2_idle_bits
212 tdm_framing
213 echo_can
214 brint_overlap
215 pri_termtype
216 pri_connection_type
217 em_signalling
218 );
219 foreach my $k (@trivial) {
220 $gconfig->{$k} = $p->item($k);
221 }
222 bless $gconfig,$pack;
223
224 return $gconfig;
225 }
226
227 sub run_generator($$@) {
228 my $gconfig = shift || die;
229 my $name = shift || die "$0: Missing generator name argument";
230 my $genopts = shift || die "$0: Missing genopts argument";
231 ref($genopts) eq 'HASH' or die "$0: Bad genopts argument";
232 my @spans = @_;
233
234 my $module = "Dahdi::Config::Gen::$name";
235 #print STDERR "DEBUG: $module\n";
236 eval "use $module";
237 if($@) {
238 die "Failed to load configuration generator for '$name': $@\n";
239 }
240 my $cfg = $module->new($gconfig, $genopts);
241 $cfg->generate(@spans);
242 }
243
244 sub dump($) {
245 my $self = shift || die;
246 printf STDERR "%s dump:\n", ref $self;
247 my $width = 30;
248 foreach my $k (sort keys %$self) {
249 my $val = $self->{$k};
250 my $ref = ref $val;
251 #print STDERR "DEBUG: '$k', '$ref', '$val'\n";
252 if($ref eq '') {
253 printf STDERR "%-${width}s %s\n", $k, $val;
254 } elsif($ref eq 'SCALAR') {
255 printf STDERR "%-${width}s %s\n", $k, ${$val};
256 } elsif($ref eq 'ARRAY') {
257 #printf STDERR "%s:\n", $k;
258 my $i = 0;
259 foreach my $v (@{$val}) {
260 printf STDERR "%-${width}s %s\n", "$k\->[$i]", $v;
261 $i++;
262 }
263 } elsif($ref eq 'HASH') {
264 #printf STDERR "%s:\n", $k;
265 foreach my $k1 (keys %{$val}) {
266 printf STDERR "%-${width}s %s\n", "$k\->\{$k1\}", ${$val}{$k1};
267 }
268 } else {
269 printf STDERR "%-${width}s (-> %s)\n", $k, $ref;
270 }
271 }
272 }
273
274
275 1;