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