Yenta/Store/BDBI.pm untested

filter: Statementstmt 0.0% 0 / 117 Branchbran 0.0% 0 / 26 Conditioncond 0.0% 0 / 10 MC/DCmcdc 0.0% 0 / 6 Subroutinesub 0.0% 0 / 15 Podpod 0.0% 0 / 10 totaltotal 0.0% 0 / 184 CC 14 SCAR 32.6
CC
14
Cov
0%
new
72.0
range
20.0
get
12.0
CRAP 25.9
1 # -*- perl -*-
2  
3 # Copyright (c) 2009 AdCopy
4 # Author: Jeff Weisberg
5 # Created: 2009-Mar-30 18:39 (EDT)
6 # Function: interface with Berkeley DB
7 #
8 # $Id$
9  
10 package AC::Yenta::Store::BDBI;
11 use AC::Yenta::Debug 'bdbi';
12 use BerkeleyDB;
13 use POSIX;
14 use Sys::SigAction 'set_sig_handler';
15 use strict;
16  
17 my $TIMEOUT = 30;
18  
19 AC::Yenta::Store::Map->add_backend( bdb => 'AC::Yenta::Store::BDBI' );
20 AC::Yenta::Store::Map->add_backend( berkeley => 'AC::Yenta::Store::BDBI' );
21  
22 my %recovered;
23  
24 sub new {
25 my $class = shift;
26 my $name = shift;
27 my $conf = shift;
28  
29 my $file = $conf->{dbfile};
30 unless( $file ){
31 problem("no dbfile specified for '$name'");
32 return;
33 }
34  
35 my $dir = $file;
36 $dir =~ s|/[^/]+$||;
37  
38 # recover only once per dir
39 my $recov = ( $conf->{recovery} && !$recovered{$dir} );
40 $recovered{$dir} = 1 if $recov;
41  
42 if( $recov ){
43 unlink $_ for glob "$dir/__*";
44 }
45  
46 my $flags = $conf->{readonly} ? 0 : (DB_CREATE| DB_INIT_CDB | DB_INIT_MPOOL);
47  
48 debug("opening Berkeley dir=$dir, file=$file (recov $recov)");
49 my $env = BerkeleyDB::Env->new(
50 -Home => $dir,
51 -Flags => $flags,
52 );
53  
54 # microsecs
55 $env->set_timeout($TIMEOUT * 1_000_000 / 2, DB_SET_LOCK_TIMEOUT) if $env;
56  
57 my $db = BerkeleyDB::Btree->new(
58 -Filename => $file,
59 -Env => $env,
60 -Flags => DB_CREATE,
61 );
62  
63 problem("cannot open db file $file") unless $db;
64  
65 # web server will need access
66 chmod 0666, $file;
67  
68 return bless {
69 dir => $dir,
70 file => $file,
71 db => $db,
72 hasenv => ($env ? 1 : 0),
73 }, $class;
74 }
75  
76 sub get {
77 my $me = shift;
78 my $map = shift;
79 my $sub = shift;
80 my $key = shift;
81  
82 my $v;
83 debug("get $map/$sub/$key");
84  
85 $me->_start();
86 my $r = $me->{db}->db_get( _key($map,$sub,$key), $v );
87 $me->_finish();
88  
89 return if $r; # not found
90  
91 if( wantarray ){
92 return ($v, 1);
93 }
94 return $v;
95 }
96  
97 sub put {
98 my $me = shift;
99 my $map = shift;
100 my $sub = shift;
101 my $key = shift;
102 my $val = shift;
103  
104 debug("put $map/$sub/$key");
105  
106 $me->_start();
107 my $r = $me->{db}->db_put( _key($map,$sub,$key), $val);
108 $me->_finish();
109  
110 return !$r;
111 }
112  
113 sub del {
114 my $me = shift;
115 my $map = shift;
116 my $sub = shift;
117 my $key = shift;
118  
119 $me->_start();
120 $me->{db}->db_del( _key($map,$sub,$key));
121 $me->_finish();
122 }
123  
124 sub sync {
125 my $me = shift;
126  
127 $me->{db}->db_sync();
128 }
129  
130 sub range {
131 my $me = shift;
132 my $map = shift;
133 my $sub = shift;
134 my $key = shift;
135 my $end = shift; # undef => to end of map
136  
137 my ($k, $v, @k);
138 $me->_start();
139 my $cursor = $me->{db}->db_cursor();
140 $k = _key($map,$sub,$key);
141 my $e = _key($map,$sub,$end);
142 $cursor->c_get($k, $v, DB_SET_RANGE);
143  
144 my $MAX = 100;
145 my $max = $MAX;
146  
147 while( !$end || ($k lt $e) ){
148 debug("range $k");
149 last unless $k =~ m|$map/$sub/|;
150 $k =~ s|$map/$sub/||;
151 push @k, { k => $k, v => $v };
152 my $r = $cursor->c_get($k, $v, DB_NEXT);
153 last if $r; # error
154  
155 # cursor locks the db
156 # close+recreate so other processes can proceed
157 unless( $max -- ){
158 $cursor->c_close();
159 $me->_finish();
160 sleep 0;
161 $me->_start();
162 $cursor = $me->{db}->db_cursor();
163 $cursor->c_get($k, $v, DB_SET);
164 $max = $MAX;
165 }
166 }
167 $cursor->c_close();
168 $me->_finish();
169  
170 return @k;
171 }
172  
173 ################################################################
174  
175 sub _sig {
176 print STDERR "bdbi signal @_\n", AC::Error::stack_trace(), "\n";
177 exit(-1);
178 }
179  
180 sub _start {
181 my $me = shift;
182  
183 $me->{alarmold} = alarm($TIMEOUT);
184 return unless $me->{hasenv};
185  
186 # as long as perl handles the signals, everything gets cleaned up
187 # well enough for the locks to be removed
188 for my $sig (qw(INT QUIT KILL TERM ALRM)){
189 $SIG{$sig} ||= \&_sig;
190 }
191 }
192  
193 sub _finish {
194 my $me = shift;
195  
196 alarm($me->{alarmold} || 0);
197 $me->{alarmold} = 0;
198 }
199  
200  
201 sub _key {
202 my $map = shift;
203 my $sub = shift;
204 my $key = shift;
205  
206 return "$map/$sub/$key";
207 }
208  
209 1;