/[Time-Available]/Available.pm
This is repository of my old source code which isn't updated any more. Go to git.rot13.org for current projects!
ViewVC logotype

Diff of /Available.pm

Parent Directory Parent Directory | Revision Log Revision Log | View Patch Patch

revision 1.1.1.1 by dpavlin, Fri Oct 3 14:19:50 2003 UTC revision 1.6 by dpavlin, Sun Oct 5 22:26:54 2003 UTC
# Line 1  Line 1 
1  package Time::Available;  package Time::Available;
2    
3  use 5.008001;  use 5.001;
4  use strict;  use strict;
5  use warnings;  use warnings;
6    
# Line 8  require Exporter; Line 8  require Exporter;
8    
9  our @ISA = qw(Exporter);  our @ISA = qw(Exporter);
10    
 # Items to export into callers namespace by default. Note: do not export  
 # names by default without a very good reason. Use EXPORT_OK instead.  
 # Do not simply export all your public functions/methods/constants.  
   
 # This allows declaration       use Time::Available ':all';  
 # If you do not need this, moving things directly into @EXPORT or @EXPORT_OK  
 # will save memory.  
11  our %EXPORT_TAGS = (  our %EXPORT_TAGS = (
12          'days' => [ qw(          'days' => [ qw(
13                  DAY_MONDAY                  DAY_MONDAY
# Line 27  our %EXPORT_TAGS = ( Line 20  our %EXPORT_TAGS = (
20                  DAY_WEEKDAY                  DAY_WEEKDAY
21                  DAY_WEEKEND                  DAY_WEEKEND
22                  DAY_EVERYDAY                  DAY_EVERYDAY
23          ) ]          ) ],
24            'fmt_interval' => [ qw(fmt_interval) ]
25  );  );
26    
27  our @EXPORT_OK = ( @{ $EXPORT_TAGS{'days'} } );  our @EXPORT_OK = (
28            @{ $EXPORT_TAGS{'days'} },
29            @{ $EXPORT_TAGS{'fmt_interval'} }
30            );
31    
32  our @EXPORT = qw(  our @EXPORT;    # don't export anything by default!
           
 );  
33    
34  our $VERSION = '0.01';  our $VERSION = '0.01';
35    
# Line 68  sub new { Line 63  sub new {
63    
64          # calc start and stop seconds          # calc start and stop seconds
65          my ($hh,$mm,$ss) = split(/:/,$self->{ARGS}->{start},3);          my ($hh,$mm,$ss) = split(/:/,$self->{ARGS}->{start},3);
66            print STDERR "new: start time ",$hh||0,":",$mm||0,":",$ss||0,"\n" if ($debug);
67          my $s = $hh * 3600 || die("need at least hour specified for start time");          my $s = $hh * 3600 || die("need at least hour specified for start time");
68          $s += $mm * 60 if ($mm);          $s += $mm * 60 if ($mm);
69          $s += $ss if ($ss);          $s += $ss if ($ss);
# Line 76  sub new { Line 72  sub new {
72          die("need end time") if (! $self->{ARGS}->{end});          die("need end time") if (! $self->{ARGS}->{end});
73    
74          ($hh,$mm,$ss) = split(/:/,$self->{ARGS}->{end},3);          ($hh,$mm,$ss) = split(/:/,$self->{ARGS}->{end},3);
75            print STDERR "new: end time ",$hh||0,":",$mm||0,":",$ss||0,"\n" if ($debug);
76          $s = $hh * 3600 || die("need at least hour specified for end time");          $s = $hh * 3600 || die("need at least hour specified for end time");
77          $s += $mm * 60 if ($mm);          $s += $mm * 60 if ($mm);
78          $self->{end} = $s;          $self->{end} = $s;
# Line 93  sub new { Line 90  sub new {
90  # this sub (originally from Time::Avail) will return if day is applicable  # this sub (originally from Time::Avail) will return if day is applicable
91  #  #
92    
93  sub _dayOk($$) {  sub _dayOk($) {
94            my $self = shift;
95            my $day = shift || return;
96    
97          my( $dayMask, $day ) = @_;      # get parameters          my $dayMask = $self->{dayMask};
98    
99          my $dayOk = 0;          my $dayOk = 0;
100    
# Line 129  sub _dayOk($$) { Line 128  sub _dayOk($$) {
128  sub uptime {  sub uptime {
129          my $self = shift;          my $self = shift;
130    
131          my $time = shift || die "need uptime timestamp to calcualte uptime";          my $time = shift || die "need uptime timestamp to calculate uptime";
132    
133            # calculate offset -- that is number of seconds since midnight
134            my @lt = gmtime($time);
135    
136            # check if day falls into dayMask
137            return 0 if (! $self->_dayOk($lt[6]) );
138    
139            my $offset = $lt[2];    # hour
140            $offset *= 60;          # convert to minutes
141            $offset += $lt[1];      # minutes
142            $offset *= 60;          # convert to seconds
143            $offset += $lt[0];
144    
145          my $s=0;          my $s=0;
146    
147          my $start = $self->{start};          my $start = $self->{start};
148          my $end = $self->{end};          my $end = $self->{end};
149    
150          print STDERR "start: $start end: $end time: $time\n" if ($debug);          print STDERR "start: $start end: $end time: $offset [$lt[2]:$lt[1]:$lt[0]]\n" if ($debug);
151    
152          if( ( $end > $start ) && ( $time < $end ) ) {          if ( $end > $start ) {
153                  if ($time < $start) {                  if ($offset < $start) {
154                          $s = $end - $start;                          $s = $end - $start;
155                  } else {                  } elsif ($offset < $end) {
156                          $s = $end - $time;                          $s = $end - $offset;
157                  }                  }
158          } elsif( $start > $end ) {      # over midnight          } elsif ( $start > $end ) {     # over midnight
159                  if ( $time < $end ) {                  if ( $offset < $end ) {
160                          if ( $time < $start) {                          if ( $offset < $start) {
161                                  $s = SEC_PER_DAY - $start + $end - $time;                                  $s = SEC_PER_DAY - $start + $end - $offset;
162                          } else {                          } else {
163                                  $s = SEC_PER_DAY - $start + $end;                                  $s = SEC_PER_DAY - $start + $end;
164                          }                          }
165                  } else {                  } else {
166                          if ( $time < $start ) {                          if ( $offset < $start ) {
167                                  $s = SEC_PER_DAY - $start;                                  $s = SEC_PER_DAY - $start;
168                          } else {                          } else {
169                                  $s = SEC_PER_DAY - $time;                                  $s = SEC_PER_DAY - $offset;
170                            }
171                    }
172            }
173                    
174            return $s;
175    }
176    
177    #
178    # this will return number of seconds that service is available if passed
179    # downtime of service
180    #
181    
182    sub downtime {
183            my $self = shift;
184    
185            my $time = shift || die "need downtime timestamp to calculate uptime";
186    
187            # calculate offset -- that is number of seconds since midnight
188            my @lt = gmtime($time);
189    
190            # check if day falls into dayMask
191            return 0 if (! $self->_dayOk($lt[6]) );
192    
193            my $offset = $lt[2];    # hour
194            $offset *= 60;          # convert to minutes
195            $offset += $lt[1];      # minutes
196            $offset *= 60;          # convert to seconds
197            $offset += $lt[0];
198    
199            my $s=0;
200    
201            my $start = $self->{start};
202            my $end = $self->{end};
203    
204            print STDERR "start: $start end: $end time: $offset [$lt[2]:$lt[1]:$lt[0]]\n" if ($debug);
205    
206            if ( $end > $start ) {
207                    if ($offset > $start && $offset <= $end) {
208                            $s = $end - $offset;
209                    } elsif ($offset < $start) {
210                            $s = $end - $start;
211                    }
212            } elsif ( $start > $end ) {     # over midnight
213                    if ( $offset < $end ) {
214                            if ( $offset < $start) {
215                                    $s = $offset;
216                            } else {
217                                    $s = 0;
218                            }
219                    } else {
220                            if ( $offset < $start ) {
221                                    $s = SEC_PER_DAY - $end;
222                            } else {
223                                    $s = SEC_PER_DAY - $end + $start - $offset;
224                          }                          }
225                  }                  }
226          }          }
# Line 163  sub uptime { Line 228  sub uptime {
228          return $s;          return $s;
229  }  }
230    
231    #
232    # this auxillary function will pretty-format interval in [days]d hh:mm:ss
233    #
234    
235    sub fmt_interval {
236            my $s = shift || 0;
237            my $out = "";
238    
239            my $d = int($s/(24*60*60));
240            $s = $s % (24*60*60);
241            my $h = int($s/(60*60));
242            $s = $s % (60*60);
243            my $m = int($s/60);
244            $s = $s % 60;
245            
246            $out .= $d."d " if ($d > 0);
247    
248            $out .= sprintf("%02d:%02d:%02d",$h,$m,$s);
249    
250            return $out;
251    }
252    
253    #
254    # this function will calculate uptime for some interval
255    #
256    
257    sub interval {
258            my $self = shift;
259            my $from = shift || die "need start time for interval";
260            my $to = shift || die "need end time for interval";
261    
262            print STDERR "from:\t$from\t",scalar gmtime($from),"\n" if ($debug);
263            print STDERR "to:\t$to\t",scalar gmtime($to),"\n" if ($debug);
264    
265            my $total = 0;
266    
267            # calc first day availability
268            print STDERR "t:\t$from\t",scalar gmtime($from),"\n" if ($debug);
269            $total += $self->uptime($from);
270    
271            print STDERR "total: $total (first)\n" if ($debug);
272    
273            # add all whole days
274    
275            my $sec_in_day = $self->sec_in_interval;
276            my $day = 86400;        # 24*60*60
277    
278            my $loop_start_time = int($from/$day)*$day + $day;
279            my $loop_end_time = int($to/$day)*$day - $day;
280    
281            print STDERR "loop (start - end): $loop_start_time - $loop_end_time\n" if ($debug);
282    
283            for (my $t = $loop_start_time; $t <= $loop_end_time; $t += $day) {
284                    print STDERR "t:\t$t\t",scalar gmtime($t),"\n" if ($debug);
285                    $total += $sec_in_day if ($self->day_in_interval($t));
286                    print STDERR "total: $total (loop)\n" if ($debug);
287            }
288    
289            # add rest of last day
290            print STDERR "t:\t$to\t",scalar gmtime($to),"\n" if ($debug);
291    
292            $total -= $self->downtime($to);
293            print STDERR "total: $total (final)\n" if ($debug);
294    
295            return $total;
296    }
297    
298    #
299    # this function will check if day falls into interval
300    #
301    
302    sub day_in_interval {
303            my $self = shift;
304    
305            my $time = shift || die "need timestamp to check if day is in interval";
306    
307            my @lt = gmtime($time);
308            return $self->_dayOk($lt[6]);
309    }
310    
311    #
312    # return seconds in defined interval
313    #
314    
315    sub sec_in_interval {
316            my $self = shift;
317    
318            # over midnight?
319            if ($self->{start} > $self->{end}) {
320                    return(86400 - $self->{start} + $self->{end});
321            } else {
322                    return($self->{end} - $self->{start});
323            }
324    }
325    
326  1;  1;
327  __END__  __END__
# Line 191  Time::Available - Perl extension to calc Line 349  Time::Available - Perl extension to calc
349    # calculate availablity in seconds from interval of uptime    # calculate availablity in seconds from interval of uptime
350    print $interval->interval($utime1,$utime2);    print $interval->interval($utime1,$utime2);
351    
352      # pretty print interval data (this will produce output '1d 11:11:11')
353      use Time::Available qw(:fmt_interval);
354      print fmt_interval(126671);
355    
356  =head1 DESCRIPTION  =head1 DESCRIPTION
357    
358  Time::Available is used to calculate availability of some resource if start  Time::Available is used to calculate availability of some resource if start
# Line 207  the following dayMask constants: Line 369  the following dayMask constants:
369  =over 4  =over 4
370    
371  =item *  =item *
372  Time::Avail::DAY_MONDAY  Time::Available::DAY_MONDAY
373    
374  =item *  =item *
375  Time::Avail::DAY_TUESDAY  Time::Available::DAY_TUESDAY
376    
377  =item *  =item *
378  Time::Avail::DAY_WEDNESDAY  Time::Available::DAY_WEDNESDAY
379    
380  =item *  =item *
381  Time::Avail::DAY_THURSDAY  Time::Available::DAY_THURSDAY
382    
383  =item *  =item *
384  Time::Avail::DAY_FRIDAY  Time::Available::DAY_FRIDAY
385    
386  =item *  =item *
387  Time::Avail::DAY_SATURDAY  Time::Available::DAY_SATURDAY
388    
389  =item *  =item *
390  Time::Avail::DAY_SUNDAY  Time::Available::DAY_SUNDAY
391    
392  =item *  =item *
393  Time::Avail::DAY_WEEKDAY  Time::Available::DAY_WEEKDAY
394    
395  =item *  =item *
396  Time::Avail::DAY_WEEKEND  Time::Available::DAY_WEEKEND
397    
398  =item *  =item *
399  Time::Avail::DAY_EVERYDAY  Time::Available::DAY_EVERYDAY
400    
401  =back  =back
402    
# Line 242  FIXME Line 404  FIXME
404    
405  =head2 EXPORT  =head2 EXPORT
406    
407  None by default. If you specify B<:days>, Time::Available will export all  None by default.
408    
409    If you specify B<:days>, Time::Available will export all
410  DAY_* constraints to your enviroment (causing possible pollution of name  DAY_* constraints to your enviroment (causing possible pollution of name
411  space). You have been warned.  space). You have been warned.
412    
413    With B<:fmt_interval> it will include function B<fmt_interval> which will
414    pretty-format interval into [days]d hh:mm:ss.
415    
416    
417  =head1 HISTORY  =head1 HISTORY
418    
# Line 276  calculating of availability of some inte Line 443  calculating of availability of some inte
443  this module was born.  this module was born.
444    
445  More information about this module might be found on  More information about this module might be found on
446  http://www.rot13.org/~dpavlin/perl.html#cpan  http://www.rot13.org/~dpavlin/projects.html#cpan
447    
448  =head1 AUTHOR  =head1 AUTHOR
449    
Legend:
Removed from v.1.1.1.1  
changed lines
  Added in v.1.6
  ViewVC Help
Powered by ViewVC 1.1.26