summaryrefslogtreecommitdiff
path: root/lib/Config
diff options
context:
space:
mode:
Diffstat (limited to 'lib/Config')
-rw-r--r--lib/Config/HAProxy.pm140
-rw-r--r--lib/Config/HAProxy/Iterator.pm68
-rw-r--r--lib/Config/HAProxy/Node.pm137
-rw-r--r--lib/Config/HAProxy/Node/Comment.pm31
-rw-r--r--lib/Config/HAProxy/Node/Empty.pm29
-rw-r--r--lib/Config/HAProxy/Node/Root.pm52
-rw-r--r--lib/Config/HAProxy/Node/Section.pm153
-rw-r--r--lib/Config/HAProxy/Node/Statement.pm45
8 files changed, 628 insertions, 27 deletions
diff --git a/lib/Config/HAProxy.pm b/lib/Config/HAProxy.pm
index 7938bcb..f99bf33 100644
--- a/lib/Config/HAProxy.pm
+++ b/lib/Config/HAProxy.pm
@@ -182,10 +182,10 @@ sub save {
182 $self->backup; 182 $self->backup;
183 rename($tempfile, $self->filename) 183 rename($tempfile, $self->filename)
184 or croak "can't rename $tempfile to ".$self->tempfile.": $!"; 184 or croak "can't rename $tempfile to ".$self->tempfile.": $!";
185 # This will fail unless we are root, let it be so.
186 chown $sb->uid, $sb->gid, $self->filename;
187 # This will succeed: we've created the file, so we're owning it. 185 # This will succeed: we've created the file, so we're owning it.
188 chmod $sb->mode & 0777, $self->filename; 186 chmod $sb->mode & 0777, $self->filename;
187 # This will fail unless we are root, let it be so.
188 chown $sb->uid, $sb->gid, $self->filename;
189 189
190 $self->tree->clear_dirty 190 $self->tree->clear_dirty
191} 191}
@@ -215,39 +215,90 @@ __END__
215 215
216=head1 NAME 216=head1 NAME
217 217
218Config::HAProxy - HAProxy configuration file 218Config::HAProxy - Parser for HAProxy configuration file
219 219
220=head1 SYNOPSIS 220=head1 SYNOPSIS
221 221
222use Config::HAProxy; 222 use Config::HAProxy;
223$cfg = new Config::HAProxy($filename); 223 $cfg = new Config::HAProxy($filename);
224$cfg->parse; 224 $cfg->parse;
225 225
226$name = $cfg->filename; 226 $name = $cfg->filename;
227 227
228@frontends = $cfg->select(name => 'frontend'); 228 @frontends = $cfg->select(name => 'frontend');
229 229
230$itr = $cfg->iterator(inorder => 1); 230 $itr = $cfg->iterator(inorder => 1);
231while (defined($node = $itr->next)) { 231 while (defined($node = $itr->next)) {
232 # do something with $node 232 # do something with $node
233} 233 }
234 234
235$cfg->save; 235 $cfg->save;
236 236
237$cfg->write($file_or_handle); 237 $cfg->write($file_or_handle);
238 238
239$cfg->backup; 239 $cfg->backup;
240$name = $self->backup_name; 240 $name = $self->backup_name;
241 241
242$cfg->reset; 242 $cfg->reset;
243$cfg->push($node); 243 $cfg->push($node);
244$node = $cfg->pop; 244 $node = $cfg->pop;
245$node = $cfg->tos; 245 $node = $cfg->tos;
246$node = $cfg->tree; 246 $node = $cfg->tree;
247 247
248=head1 DESCRIPTION 248=head1 DESCRIPTION
249 249
250FIXME 250The B<Config::HAProxy> class is a parser that converts the B<HAProxy>
251configuration file to a parse tree and provides methods for various
252operations on this tree, such as: searching, modifying and saving it
253to a file.
254
255An object of this class contains a I<parse tree> representing the
256configuration read from the file (or created from scratch). Nodes in the
257tree can be of four distinct classes:
258
259=over 4
260
261=item Empty
262
263Represents an empty line.
264
265=item Comment
266
267Represents a comment line.
268
269=item Statement
270
271Represents a simple statement.
272
273=item Section
274
275A container, representing a C<compound statement>, i.e. a statement that
276contains multiple sub-statements. Compound statements are: B<global>,
277B<defaults>, B<frontend>, and B<backend>.
278
279=back
280
281In addition to these four classes, a special class B<Root> is provided, which
282represents the topmost node in the parse tree (i.e. the parent of other nodes).
283
284A set of attributes is associated with each node. Among these, the B<orig>
285attribute contains the original line from the configuration file that triggered
286creation of this node, and B<locus> contains the location of this line (or
287lines, for sections) in the configuration file (as a B<Text::Locus>) object.
288
289These two attributes are meaningful for all nodes. For statement nodes (simple
290statements and sections) the B<kw> attribute contains the statement I<keyword>,
291and the B<argv> attribute - its arguments. For example, the statement
292
293 server localhost 127.0.0.1:8080
294
295is represented by a node of class B<Config::HAProxy::Node::Statement>, with
296C<server> as B<kw> and list (C<localhost>, C<127.0.0.1:8080>) as B<argv>.
297
298Additionally, section nodes provide methods for accessing their subtrees.
299
300For a detailed description of the node class and its methods, please refer to
301B<Config::HAProxy::Node>.
251 302
252=head1 CONSTRUCTOR 303=head1 CONSTRUCTOR
253 304
@@ -257,15 +308,23 @@ Creates and returns a new object for manipulating the HAProxy configuration.
257Optional B<$filename> specifies the name of the file to read configuration 308Optional B<$filename> specifies the name of the file to read configuration
258from. It defaults to F</etc/haproxy/haproxy.cfg>. 309from. It defaults to F</etc/haproxy/haproxy.cfg>.
259 310
260=head1 THE PARSE TREE 311=head2 filename
312
313 $s = $cfg->filename;
314
315Returns the configuration file name given when creating the object.
316
317=head1 PARSING
261 318
262=head2 parse 319=head2 parse
263 320
264 $cfg->parse; 321 $cfg->parse;
265 322
266Reads and parses the configuration file. Croaks if the file does not exist. 323Reads and parses the configuration file. Croaks if the file does not exist.
324Returns B<$cfg>.
267 325
268 326=head1 BUILDING THE PARSE TREE
327
269=head2 reset 328=head2 reset
270 329
271 $cfg->reset; 330 $cfg->reset;
@@ -305,7 +364,7 @@ Returns the last node in the tree.
305 364
306 $cfg->save; 365 $cfg->save;
307 366
308Saves the configuration file. 367Saves the parse tree in the configuration file.
309 368
310=head2 write 369=head2 write
311 370
@@ -327,3 +386,34 @@ Normally, comments retain their original indentation. However, if the
327key B<reintent_comments> is present, and its value is evaluated as true, 386key B<reintent_comments> is present, and its value is evaluated as true,
328then comments are reindented following the rules described above. 387then comments are reindented following the rules described above.
329 388
389=head1 SEE ALSO
390
391B<Config::HAProxy::Node>,
392B<Config::HAProxy::Node::Section>,
393B<Config::HAProxy::Node::Statement>,
394B<Config::HAProxy::Iterator>.
395
396=head1 AUTHOR
397
398Sergey Poznyakoff, E<lt>gray@gnu.orgE<gt>
399
400=head1 COPYRIGHT AND LICENSE
401
402Copyright (C) 2018 by Sergey Poznyakoff
403
404This library is free software; you can redistribute it and/or modify it
405under the terms of the GNU General Public License as published by the
406Free Software Foundation; either version 3 of the License, or (at your
407option) any later version.
408
409It is distributed in the hope that it will be useful,
410but WITHOUT ANY WARRANTY; without even the implied warranty of
411MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
412GNU General Public License for more details.
413
414You should have received a copy of the GNU General Public License along
415with this library. If not, see <http://www.gnu.org/licenses/>.
416
417=cut
418
419
diff --git a/lib/Config/HAProxy/Iterator.pm b/lib/Config/HAProxy/Iterator.pm
index 6b0208e..6d80dd9 100644
--- a/lib/Config/HAProxy/Iterator.pm
+++ b/lib/Config/HAProxy/Iterator.pm
@@ -63,6 +63,74 @@ sub next {
63} 63}
64 64
651; 651;
66__END__
67
68=head1 NAME
69
70Config::HAProxy::Iterator - Iterate over objects in the parse tree
71
72=head1 SYNOPSIS
73
74 $cfg = Config::HAProxy->new->parse;
75 $itr = $cfg->iterator(inorder => 1);
76 while (defined(my $node = $itr->next)) {
77 # Do something with $node
78 }
79
80=head1 DESCRIPTION
81
82The iterator object provides a method for iterating over all nodes in the
83HAProxy parse tree. The object is returned by the B<iterator> method of
84B<Config::HAProxy> and B<Config::HAProxy::Node> objects. The method takes
85as optional argument the keyword specifying the order in which the tree nodes
86should be traversed. This keyword can be one of the following:
87
88=over 4
89
90=item B<recursive =E<gt> 0>
91
92No recursion. The traversal will not descend into section nodes. This is the
93default.
94
95=item B<inorder =E<gt> 1>
96
97The nodes will be traversed in the inorder manner, i.e. the section node
98will be visited first, and all its sub-nodes after it.
99
100=item B<postorder =E<gt> 1>
101
102The nodes will be traversed in the postorder manner, i.e. for each section
103node, its sub-nodes will be visited first, and the node itself afterward.
104
105=back
106
107=head1 CONSTRUCTOR
108
109Note: This section is informative. You never need to create
110B<Config::HAProxy::Iterator> objects explicitly. Please use the B<iterator>
111method of B<Config::HAProxy> or B<Config::HAProxy::Node> class objects.
112
113 $itr = new Config::HAProxy::Iterator($node, %rec);
114
115Returns new iterator object for traversing the tree starting from B<$node>,
116which must be a B<Config::HAProxy::Node> object. Optional B<%rec> is one of
117the keywords discussed above, in section B<DESCRIPTION>.
118
119=head1 METHODS
120
121=head2 next
122
123 $node = $itr->next;
124
125Returns next node in the traversal sequence. If all nodes were visited, returns
126B<undef>.
127
128=head1 SEE ALSO
129
130B<HAProxy::Config>, B<HAProxy::Config::Node>.
131
132=cut
133
66 134
67 135
68 136
diff --git a/lib/Config/HAProxy/Node.pm b/lib/Config/HAProxy/Node.pm
index be09538..8210067 100644
--- a/lib/Config/HAProxy/Node.pm
+++ b/lib/Config/HAProxy/Node.pm
@@ -97,3 +97,140 @@ sub is_empty { 0 }
97sub is_comment { 0 } 97sub is_comment { 0 }
98 98
991; 991;
100__END__
101
102=head1 NAME
103
104Config::HAProxy::Node - Abstract HAProxy configuration node
105
106=head1 DESCRIPTION
107
108The class B<Config::HAProxy::Node> represents an abstract node in the
109HAProxy configuration parse tree. It serves as a base class for classes
110representing configuration tree, section, simple statement, comment and
111empty line.
112
113=head1 CONSTRUCTOR
114
115 $obj = new Config::HAProxy::Node(%args);
116
117Returns new object. B<%args> can contain the following keys:
118
119=over 4
120
121=item B<kw>
122
123Configuration keyword (string),
124
125=item B<argv>
126
127Reference to the list of arguments.
128
129=item B<orig>
130
131Original text as read from the configuration file.
132
133=item B<locus>
134
135Locus (a B<Text::Locus> object) where this statement occurred.
136
137=item B<parent>
138
139Parent node.
140
141=back
142
143=head1 METHODS
144
145=head2 B<kw>, B<argv>, B<orig>, B<locus>, B<parent>
146
147These methods return the corresponding field of the node. When called
148with an argument, they set the field prior to returning it. The B<argv>
149method returns array of strings and takes as its argument a reference to
150the array of strings:
151
152 @a = $node->argv;
153
154 $node->argv([@a]);
155
156=head2 index
157
158Index (0-based) of this node in the parent node.
159
160=head2 arg
161
162 $a = $node->arg($n)
163
164Returns the B<$n>th argument (0-based) from the argument list.
165
166=head2 drop
167
168 $node->drop;
169
170Removes this node and destroys it.
171
172=head2 iterator
173
174 $itr = $node->iterator(@args);
175
176Returns the iterator for this node. See B<Config::HAProxy::Iterator> for
177a detailed discussion.
178
179=head2 depth
180
181 $n = $node->depth;
182
183Returns the depth of this node in the configuration tree. Depth is the
184number of parent nodes between the root of tree and this node. Top-level
185nodes have depth 0.
186
187=head2 root
188
189 $root_node = $node->root;
190
191Returns the root node of the parse tree this node belongs to.
192
193=head2 as_string
194
195 $s = $node->as_string;
196
197Returns canonical string representation of this node. The canonical
198representation consists of the keyword followed by arguments delimited
199with horizontal space characters.
200
201=head1 ABSTRACT METHODS
202
203Derived classes must overload at least one of the following methods:
204
205=head2 is_root
206
207True if the node is a root node, false otherwise.
208
209=head2 is_section
210
211True if the node represents a section (i.e. contains subnodes).
212
213=head2 is_statement
214
215True if the node is a simple statement.
216
217=head2 is_empty
218
219True if the node represents an empty line.
220
221=head2 is_comment
222
223True if the node represents a comment.
224
225=head1 SEE ALSO
226
227B<Config::HAProxy::Node::Comment>,
228B<Config::HAProxy::Node::Empty>,
229B<Config::HAProxy::Node::Root>,
230B<Config::HAProxy::Node::Section>,
231B<Config::HAProxy::Node::Statement>,
232B<Config::HAProxy::Iterator>,
233B<Config::HAProxy>,
234B<Text::Locus>.
235
236=cut
diff --git a/lib/Config/HAProxy/Node/Comment.pm b/lib/Config/HAProxy/Node/Comment.pm
index 5d7ef88..17a513b 100644
--- a/lib/Config/HAProxy/Node/Comment.pm
+++ b/lib/Config/HAProxy/Node/Comment.pm
@@ -1,6 +1,37 @@
1package Config::HAProxy::Node::Comment; 1package Config::HAProxy::Node::Comment;
2use parent 'Config::HAProxy::Node'; 2use parent 'Config::HAProxy::Node';
3 3
4=head1 NAME
5
6Config::HAProxy::Node::Comment - comment node in HAProxy configuration
7
8=head1 DESCRIPTION
9
10Objects of this class represent comments in HAProxy configuration file.
11
12=head1 METHODS
13
14=head2 is_comment
15
16Returns true.
17
18=head2 orig
19
20Returns original line as it appeared in the configuration file.
21
22=head2 locus
23
24Returns the location of this statement in the configuration file (the
25B<Text::Locus> object).
26
27=head1 SEE ALSO
28
29B<Config::HAProxy::Node>, B<Text::Locus>.
30
31=cut
32
4sub is_comment { 1 } 33sub is_comment { 1 }
5 34
61; 351;
36
37
diff --git a/lib/Config/HAProxy/Node/Empty.pm b/lib/Config/HAProxy/Node/Empty.pm
index bee0f2e..19ce5da 100644
--- a/lib/Config/HAProxy/Node/Empty.pm
+++ b/lib/Config/HAProxy/Node/Empty.pm
@@ -1,6 +1,35 @@
1package Config::HAProxy::Node::Empty; 1package Config::HAProxy::Node::Empty;
2use parent 'Config::HAProxy::Node'; 2use parent 'Config::HAProxy::Node';
3 3
4=head1 NAME
5
6Config::HAProxy::Node::Empty - empty HAProxy configuration node
7
8=head1 DESCRIPTION
9
10Objects of this class represent empty lines in HAProxy configuration file.
11
12=head1 METHODS
13
14=head2 is_empty
15
16Always true.
17
18=head2 orig
19
20Returns original line as it appeared in the configuration file.
21
22=head2 locus
23
24Returns the location of this statement in the configuration file (the
25B<Text::Locus> object).
26
27=head1 SEE ALSO
28
29B<Config::HAProxy::Node>, B<Text::Locus>.
30
31=cut
32
4sub is_empty { 1 } 33sub is_empty { 1 }
5 34
61; 351;
diff --git a/lib/Config/HAProxy/Node/Root.pm b/lib/Config/HAProxy/Node/Root.pm
index 656bb9f..ca6e575 100644
--- a/lib/Config/HAProxy/Node/Root.pm
+++ b/lib/Config/HAProxy/Node/Root.pm
@@ -4,6 +4,19 @@ use warnings;
4use parent 'Config::HAProxy::Node::Section'; 4use parent 'Config::HAProxy::Node::Section';
5use Carp; 5use Carp;
6 6
7=head1 NAME
8
9Config::HAProxy::Node::Root - root node of HAProxy configuration parse tree
10
11=head1 DESCRIPTION
12
13Objects of this class represent the topmost node in HAProxy configuration tree.
14Each parse tree contains exactly one object of this class. This node can be
15reached from every node in the tree by following its B<parent> attribute
16and is returned by the B<tree> method of B<Config::HAProxy> class.
17
18=cut
19
7sub new { 20sub new {
8 my $class = shift; 21 my $class = shift;
9 my $self = $class->SUPER::new(@_); 22 my $self = $class->SUPER::new(@_);
@@ -11,21 +24,58 @@ sub new {
11 return $self; 24 return $self;
12} 25}
13 26
27=head1 METHODS
28
29=head2 is_root
30
31Always true.
32
33=head2 is_dirty
34
35 $bool = $node->is_dirty;
36
37Returns true if the tree is C<dirty>, i.e. it was modified since it has been
38created from the disk configuration file.
39
40=cut
41
14sub is_dirty { 42sub is_dirty {
15 my $self = shift; 43 my $self = shift;
16 return $self->{dirty} 44 return $self->{dirty}
17} 45}
18 46
47=head2 mark_dirty
48
49 $node->mark_dirty;
50
51Sets the C<dirty> attribute.
52
53=cut
54
19sub mark_dirty { 55sub mark_dirty {
20 my $self = shift; 56 my $self = shift;
21 $self->{dirty} = 1; 57 $self->{dirty} = 1;
22} 58}
23 59
60=head2 clear_dirty
61
62 $node->clear_dirty;
63
64Clears the C<dirty> attribute.
65
66=cut
67
24sub clear_dirty { 68sub clear_dirty {
25 my $self = shift; 69 my $self = shift;
26 $self->{dirty} = 0; 70 $self->{dirty} = 0;
27} 71}
28 72
73=head1 SEE ALSO
74
75B<Config::HAProxy::Node>.
76
77=cut
78
291; 791;
30 80
31 81
diff --git a/lib/Config/HAProxy/Node/Section.pm b/lib/Config/HAProxy/Node/Section.pm
index c332155..3ef1cf0 100644
--- a/lib/Config/HAProxy/Node/Section.pm
+++ b/lib/Config/HAProxy/Node/Section.pm
@@ -4,6 +4,18 @@ use warnings;
4use parent 'Config::HAProxy::Node'; 4use parent 'Config::HAProxy::Node';
5use Carp; 5use Carp;
6 6
7=head1 NAME
8
9Config::HAProxy::Node::Section - HAProxy configuration section
10
11=head1 DESCRIPTION
12
13Objects of this class represent a C<section> in the HAProxy configuration file.
14A section is a statement that can contain sub-statements. The following
15statements form sections: B<global>, B<defaults>, B<frontend>, and B<backend>.
16
17=cut
18
7sub new { 19sub new {
8 my $class = shift; 20 my $class = shift;
9 my $self = $class->SUPER::new(@_); 21 my $self = $class->SUPER::new(@_);
@@ -11,8 +23,51 @@ sub new {
11 return $self; 23 return $self;
12} 24}
13 25
26=head1 ATTRIBUTES
27
28=head2 is_section
29
30Always true.
31
32=cut
33
14sub is_section { 1 } 34sub is_section { 1 }
15 35
36=head1 METHODS
37
38=head2 kw
39
40Returns the configuration keyword.
41
42=head2 argv
43
44Returns the list of arguments to the configuration keyword.
45
46=head2 arg
47
48 $s = $node->arg($n)
49
50Returns the B<$n>th argument.
51
52=head2 orig
53
54Returns original line as it appeared in the configuration file.
55
56=head2 locus
57
58Returns the location of this statement in the configuration file (the
59B<Text::Locus> object).
60
61=head2 append_node
62
63 $section->append_node(@nodes);
64
65Takes a list of objects of B<Config::HAProxy::Node> derived classes as
66arguments. Adds these objects after the last node in the subtree in this
67section.
68
69=cut
70
16sub append_node { 71sub append_node {
17 my $self = shift; 72 my $self = shift;
18 my $n = @{$self->{_tree}}; 73 my $n = @{$self->{_tree}};
@@ -24,6 +79,15 @@ sub append_node {
24 } @_; 79 } @_;
25} 80}
26 81
82=head2 append_node_nonempty
83
84 $section->append_node_nonempty(@nodes);
85
86Same as B<append_node>, but adds new nodes after the last non-empty
87node in the subtree.
88
89=cut
90
27sub append_node_nonempty { 91sub append_node_nonempty {
28 my $self = shift; 92 my $self = shift;
29 my $n = $#{$self->{_tree}}; 93 my $n = $#{$self->{_tree}};
@@ -32,7 +96,15 @@ sub append_node_nonempty {
32 } 96 }
33 $self->insert_node($n+1, @_); 97 $self->insert_node($n+1, @_);
34} 98}
35 99
100=head2 insert_node
101
102 $section->insert_node($idx, @nodes);
103
104Inserts B<@nodes> after subnode in position B<$idx> (0-based).
105
106=cut
107
36sub insert_node { 108sub insert_node {
37 my $self = shift; 109 my $self = shift;
38 my $n = shift; 110 my $n = shift;
@@ -48,6 +120,14 @@ sub insert_node {
48 } 120 }
49} 121}
50 122
123=head2 delete_node
124
125 $section->delete_node($i);
126
127Deletes B<$i>th subnode from the B<$section>.
128
129=cut
130
51sub delete_node { 131sub delete_node {
52 my ($self, $n) = @_; 132 my ($self, $n) = @_;
53 splice @{$self->{_tree}}, $n, 1; 133 splice @{$self->{_tree}}, $n, 1;
@@ -57,6 +137,18 @@ sub delete_node {
57 $self->root->mark_dirty; 137 $self->root->mark_dirty;
58} 138}
59 139
140=head2 tree
141
142 @nodes = $section->tree;
143
144Returns subnodes as a list of B<Config::HAProxy::Node> derived objects.
145
146 $node = $section->tree($i);
147
148Returns B<$i>th subnode from the B<$section>.
149
150=cut
151
60sub tree { 152sub tree {
61 my ($self, $n) = @_; 153 my ($self, $n) = @_;
62 if ($n) { 154 if ($n) {
@@ -66,6 +158,15 @@ sub tree {
66 return @{shift->{_tree}} 158 return @{shift->{_tree}}
67}; 159};
68 160
161=head2 ends_in_empty
162
163 $bool = $section->ends_in_empty
164
165Returns true if the last node in the list of sub-nodes in B<$section> is
166an empty node.
167
168=cut
169
69sub ends_in_empty { 170sub ends_in_empty {
70 my $self = shift; 171 my $self = shift;
71 while ($self->is_section) { 172 while ($self->is_section) {
@@ -110,6 +211,50 @@ my %match = (
110 } 211 }
111); 212);
112 213
214=head2 select
215
216 @nodes = $section->select(%cond);
217
218Returns nodes from B<$section> that match conditions in B<%cond>. Valid
219conditions are:
220
221=over 4
222
223=item B<name =E<gt>> I<$s>
224
225Node matches if its keyword (B<kw>) equals I<$s>.
226
227=item B<arg =E<gt>> B<{ n =E<gt>> I<$n>, B<v> =E<gt> I<$s> B<}>
228
229Node mathches if its I<$n>th argument equals I<$s>.
230
231=item B<section =E<gt>> I<$bool>
232
233Node matches if it is (or is not, if I<$bool> is false) a section.
234
235=item B<statement =E<gt>> I<$bool>
236
237Node matches if it is (not) a simple statement.
238
239=item B<comment =E<gt>> I<$bool>
240
241Node matches if it is (not) a comment.
242
243=back
244
245Multiple conditions are checked in the order of their appearance in the
246argument list and are joined by the short-circuit logical C<and>.
247
248For example, to return all B<frontend> statements:
249
250 @fe = $section->select(name => 'frontend');
251
252To return the frontend named C<in>:
253
254 ($fe) = $section->select( name => 'frontend',
255 arg => { n => 0, v => 'in' } );
256
257=cut
113 258
114sub select { 259sub select {
115 my $self = shift; 260 my $self = shift;
@@ -138,6 +283,12 @@ sub _test_node {
138 return 1; 283 return 1;
139} 284}
140 285
286=head1 SEE ALSO
287
288B<Config::HAProxy::Node>, B<Config::HAProxy>, B<Text::Locus>.
289
290=cut
291
1411; 2921;
142 293
143 294
diff --git a/lib/Config/HAProxy/Node/Statement.pm b/lib/Config/HAProxy/Node/Statement.pm
index abf0e50..305c529 100644
--- a/lib/Config/HAProxy/Node/Statement.pm
+++ b/lib/Config/HAProxy/Node/Statement.pm
@@ -1,6 +1,51 @@
1package Config::HAProxy::Node::Statement; 1package Config::HAProxy::Node::Statement;
2use parent 'Config::HAProxy::Node'; 2use parent 'Config::HAProxy::Node';
3 3
4=head1 NAME
5
6Config::HAProxy::Node::Statement - simple statement node in HAProxy tree
7
8=head1 DESCRIPTION
9
10Objects of this class represent simple statements in HAProxy configuration
11file. A C<simple statement> is any statement excepting: B<global>, B<defaults>,
12B<frontend>, and B<backend>.
13
14=head1 METHODS
15
16=head2 is_statement
17
18Returns true.
19
20=head2 kw
21
22Returns the configuration keyword.
23
24=head2 argv
25
26Returns the list of arguments to the configuration keyword.
27
28=head2 arg
29
30 $s = $node->arg($n)
31
32Returns the B<$n>th argument.
33
34=head2 orig
35
36Returns original line as it appeared in the configuration file.
37
38=head2 locus
39
40Returns the location of this statement in the configuration file (the
41B<Text::Locus> object).
42
43=head1 SEE ALSO
44
45B<Config::HAProxy::Node>, B<Config::HAProxy>, B<Text::Locus>.
46
47=cut
48
4sub is_statement { 1 } 49sub is_statement { 1 }
5 50
61; 511;

Return to:

Send suggestions and report system problems to the System administrator.