package BDB::Wrapper; use 5.006; use strict; use warnings; use BerkeleyDB; use Carp; use File::Spec; use FileHandle; use Exporter; use AutoLoader qw(AUTOLOAD); our $VERSION = '0.42'; our @ISA = qw(Exporter AutoLoader); our %EXPORT_TAGS = ( 'all' => [ qw() ] ); our @EXPORT_OK = ( @{ $EXPORT_TAGS{'all'} } ); # From BerkeleyDB.pm 0.43 our @EXPORT = qw( DB_AFTER DB_AGGRESSIVE DB_ALREADY_ABORTED DB_APPEND DB_APPLY_LOGREG DB_APP_INIT DB_ARCH_ABS DB_ARCH_DATA DB_ARCH_LOG DB_ARCH_REMOVE DB_ASSOC_CREATE DB_ASSOC_IMMUTABLE_KEY DB_AUTO_COMMIT DB_BEFORE DB_BTREE DB_BTREEMAGIC DB_BTREEOLDVER DB_BTREEVERSION DB_BUFFER_SMALL DB_CACHED_COUNTS DB_CDB_ALLDB DB_CHECKPOINT DB_CHKSUM DB_CHKSUM_SHA1 DB_CKP_INTERNAL DB_CLIENT DB_CL_WRITER DB_COMMIT DB_COMPACT_FLAGS DB_CONSUME DB_CONSUME_WAIT DB_CREATE DB_CURLSN DB_CURRENT DB_CURSOR_BULK DB_CURSOR_TRANSIENT DB_CXX_NO_EXCEPTIONS DB_DATABASE_LOCK DB_DATABASE_LOCKING DB_DEGREE_2 DB_DELETED DB_DELIMITER DB_DIRECT DB_DIRECT_DB DB_DIRECT_LOG DB_DIRTY_READ DB_DONOTINDEX DB_DSYNC_DB DB_DSYNC_LOG DB_DUP DB_DUPCURSOR DB_DUPSORT DB_DURABLE_UNKNOWN DB_EID_BROADCAST DB_EID_INVALID DB_ENCRYPT DB_ENCRYPT_AES DB_ENV_APPINIT DB_ENV_AUTO_COMMIT DB_ENV_CDB DB_ENV_CDB_ALLDB DB_ENV_CREATE DB_ENV_DATABASE_LOCKING DB_ENV_DBLOCAL DB_ENV_DIRECT_DB DB_ENV_DIRECT_LOG DB_ENV_DSYNC_DB DB_ENV_DSYNC_LOG DB_ENV_FAILCHK DB_ENV_FATAL DB_ENV_HOTBACKUP DB_ENV_LOCKDOWN DB_ENV_LOCKING DB_ENV_LOGGING DB_ENV_LOG_AUTOREMOVE DB_ENV_LOG_INMEMORY DB_ENV_MULTIVERSION DB_ENV_NOLOCKING DB_ENV_NOMMAP DB_ENV_NOPANIC DB_ENV_NO_OUTPUT_SET DB_ENV_OPEN_CALLED DB_ENV_OVERWRITE DB_ENV_PRIVATE DB_ENV_RECOVER_FATAL DB_ENV_REF_COUNTED DB_ENV_REGION_INIT DB_ENV_REP_CLIENT DB_ENV_REP_LOGSONLY DB_ENV_REP_MASTER DB_ENV_RPCCLIENT DB_ENV_RPCCLIENT_GIVEN DB_ENV_STANDALONE DB_ENV_SYSTEM_MEM DB_ENV_THREAD DB_ENV_TIME_NOTGRANTED DB_ENV_TXN DB_ENV_TXN_NOSYNC DB_ENV_TXN_NOT_DURABLE DB_ENV_TXN_NOWAIT DB_ENV_TXN_SNAPSHOT DB_ENV_TXN_WRITE_NOSYNC DB_ENV_USER_ALLOC DB_ENV_YIELDCPU DB_EVENT_NOT_HANDLED DB_EVENT_NO_SUCH_EVENT DB_EVENT_PANIC DB_EVENT_REG_ALIVE DB_EVENT_REG_PANIC DB_EVENT_REP_CLIENT DB_EVENT_REP_DUPMASTER DB_EVENT_REP_ELECTED DB_EVENT_REP_ELECTION_FAILED DB_EVENT_REP_JOIN_FAILURE DB_EVENT_REP_MASTER DB_EVENT_REP_MASTER_FAILURE DB_EVENT_REP_NEWMASTER DB_EVENT_REP_PERM_FAILED DB_EVENT_REP_STARTUPDONE DB_EVENT_WRITE_FAILED DB_EXCL DB_EXTENT DB_FAILCHK DB_FAST_STAT DB_FCNTL_LOCKING DB_FILEOPEN DB_FILE_ID_LEN DB_FIRST DB_FIXEDLEN DB_FLUSH DB_FORCE DB_FORCESYNC DB_FOREIGN_ABORT DB_FOREIGN_CASCADE DB_FOREIGN_CONFLICT DB_FOREIGN_NULLIFY DB_FREELIST_ONLY DB_FREE_SPACE DB_GETREC DB_GET_BOTH DB_GET_BOTHC DB_GET_BOTH_LTE DB_GET_BOTH_RANGE DB_GET_RECNO DB_GID_SIZE DB_HANDLE_LOCK DB_HASH DB_HASHMAGIC DB_HASHOLDVER DB_HASHVERSION DB_HOTBACKUP_IN_PROGRESS DB_IGNORE_LEASE DB_IMMUTABLE_KEY DB_INCOMPLETE DB_INIT_CDB DB_INIT_LOCK DB_INIT_LOG DB_INIT_MPOOL DB_INIT_REP DB_INIT_TXN DB_INORDER DB_JAVA_CALLBACK DB_JOINENV DB_JOIN_ITEM DB_JOIN_NOSORT DB_KEYEMPTY DB_KEYEXIST DB_KEYFIRST DB_KEYLAST DB_LAST DB_LOCKDOWN DB_LOCKMAGIC DB_LOCKVERSION DB_LOCK_ABORT DB_LOCK_CHECK DB_LOCK_CONFLICT DB_LOCK_DEADLOCK DB_LOCK_DEFAULT DB_LOCK_DUMP DB_LOCK_EXPIRE DB_LOCK_FREE_LOCKER DB_LOCK_GET DB_LOCK_GET_TIMEOUT DB_LOCK_INHERIT DB_LOCK_MAXLOCKS DB_LOCK_MAXWRITE DB_LOCK_MINLOCKS DB_LOCK_MINWRITE DB_LOCK_NORUN DB_LOCK_NOTEXIST DB_LOCK_NOTGRANTED DB_LOCK_NOTHELD DB_LOCK_NOWAIT DB_LOCK_OLDEST DB_LOCK_PUT DB_LOCK_PUT_ALL DB_LOCK_PUT_OBJ DB_LOCK_PUT_READ DB_LOCK_RANDOM DB_LOCK_RECORD DB_LOCK_REMOVE DB_LOCK_RIW_N DB_LOCK_RW_N DB_LOCK_SET_TIMEOUT DB_LOCK_SWITCH DB_LOCK_TIMEOUT DB_LOCK_TRADE DB_LOCK_UPGRADE DB_LOCK_UPGRADE_WRITE DB_LOCK_YOUNGEST DB_LOGCHKSUM DB_LOGC_BUF_SIZE DB_LOGFILEID_INVALID DB_LOGMAGIC DB_LOGOLDVER DB_LOGVERSION DB_LOGVERSION_LATCHING DB_LOG_AUTOREMOVE DB_LOG_AUTO_REMOVE DB_LOG_BUFFER_FULL DB_LOG_CHKPNT DB_LOG_COMMIT DB_LOG_DIRECT DB_LOG_DISK DB_LOG_DSYNC DB_LOG_INMEMORY DB_LOG_IN_MEMORY DB_LOG_LOCKED DB_LOG_NOCOPY DB_LOG_NOT_DURABLE DB_LOG_NO_DATA DB_LOG_PERM DB_LOG_RESEND DB_LOG_SILENT_ERR DB_LOG_VERIFY_BAD DB_LOG_VERIFY_CAF DB_LOG_VERIFY_DBFILE DB_LOG_VERIFY_ERR DB_LOG_VERIFY_FORWARD DB_LOG_VERIFY_INTERR DB_LOG_VERIFY_PARTIAL DB_LOG_VERIFY_VERBOSE DB_LOG_VERIFY_WARNING DB_LOG_WRNOSYNC DB_LOG_ZERO DB_MAX_PAGES DB_MAX_RECORDS DB_MPOOL_CLEAN DB_MPOOL_CREATE DB_MPOOL_DIRTY DB_MPOOL_DISCARD DB_MPOOL_EDIT DB_MPOOL_EXTENT DB_MPOOL_FREE DB_MPOOL_LAST DB_MPOOL_NEW DB_MPOOL_NEW_GROUP DB_MPOOL_NOFILE DB_MPOOL_NOLOCK DB_MPOOL_PRIVATE DB_MPOOL_TRY DB_MPOOL_UNLINK DB_MULTIPLE DB_MULTIPLE_KEY DB_MULTIVERSION DB_MUTEXDEBUG DB_MUTEXLOCKS DB_MUTEX_ALLOCATED DB_MUTEX_LOCKED DB_MUTEX_LOGICAL_LOCK DB_MUTEX_PROCESS_ONLY DB_MUTEX_SELF_BLOCK DB_MUTEX_SHARED DB_MUTEX_THREAD DB_NEEDSPLIT DB_NEXT DB_NEXT_DUP DB_NEXT_NODUP DB_NOCOPY DB_NODUPDATA DB_NOERROR DB_NOLOCKING DB_NOMMAP DB_NOORDERCHK DB_NOOVERWRITE DB_NOPANIC DB_NORECURSE DB_NOSERVER DB_NOSERVER_HOME DB_NOSERVER_ID DB_NOSYNC DB_NOTFOUND DB_NO_AUTO_COMMIT DB_ODDFILESIZE DB_OK_BTREE DB_OK_HASH DB_OK_QUEUE DB_OK_RECNO DB_OLD_VERSION DB_OPEN_CALLED DB_OPFLAGS_MASK DB_ORDERCHKONLY DB_OVERWRITE DB_OVERWRITE_DUP DB_PAD DB_PAGEYIELD DB_PAGE_LOCK DB_PAGE_NOTFOUND DB_PANIC_ENVIRONMENT DB_PERMANENT DB_POSITION DB_POSITIONI DB_PREV DB_PREV_DUP DB_PREV_NODUP DB_PRINTABLE DB_PRIORITY_DEFAULT DB_PRIORITY_HIGH DB_PRIORITY_LOW DB_PRIORITY_UNCHANGED DB_PRIORITY_VERY_HIGH DB_PRIORITY_VERY_LOW DB_PRIVATE DB_PR_HEADERS DB_PR_PAGE DB_PR_RECOVERYTEST DB_QAMMAGIC DB_QAMOLDVER DB_QAMVERSION DB_QUEUE DB_RDONLY DB_RDWRMASTER DB_READ_COMMITTED DB_READ_UNCOMMITTED DB_RECNO DB_RECNUM DB_RECORDCOUNT DB_RECORD_LOCK DB_RECOVER DB_RECOVER_FATAL DB_REGION_ANON DB_REGION_INIT DB_REGION_MAGIC DB_REGION_NAME DB_REGISTER DB_REGISTERED DB_RENAMEMAGIC DB_RENUMBER DB_REPFLAGS_MASK DB_REPMGR_ACKS_ALL DB_REPMGR_ACKS_ALL_AVAILABLE DB_REPMGR_ACKS_ALL_PEERS DB_REPMGR_ACKS_NONE DB_REPMGR_ACKS_ONE DB_REPMGR_ACKS_ONE_PEER DB_REPMGR_ACKS_QUORUM DB_REPMGR_CONF_2SITE_STRICT DB_REPMGR_CONF_ELECTIONS DB_REPMGR_CONNECTED DB_REPMGR_DISCONNECTED DB_REPMGR_ISPEER DB_REPMGR_PEER DB_REP_ACK_TIMEOUT DB_REP_ANYWHERE DB_REP_BULKOVF DB_REP_CHECKPOINT_DELAY DB_REP_CLIENT DB_REP_CONF_AUTOINIT DB_REP_CONF_BULK DB_REP_CONF_DELAYCLIENT DB_REP_CONF_INMEM DB_REP_CONF_LEASE DB_REP_CONF_NOAUTOINIT DB_REP_CONF_NOWAIT DB_REP_CONNECTION_RETRY DB_REP_CREATE DB_REP_DEFAULT_PRIORITY DB_REP_DUPMASTER DB_REP_EGENCHG DB_REP_ELECTION DB_REP_ELECTION_RETRY DB_REP_ELECTION_TIMEOUT DB_REP_FULL_ELECTION DB_REP_FULL_ELECTION_TIMEOUT DB_REP_HANDLE_DEAD DB_REP_HEARTBEAT_MONITOR DB_REP_HEARTBEAT_SEND DB_REP_HOLDELECTION DB_REP_IGNORE DB_REP_ISPERM DB_REP_JOIN_FAILURE DB_REP_LEASE_EXPIRED DB_REP_LEASE_TIMEOUT DB_REP_LOCKOUT DB_REP_LOGREADY DB_REP_LOGSONLY DB_REP_MASTER DB_REP_NEWMASTER DB_REP_NEWSITE DB_REP_NOBUFFER DB_REP_NOTPERM DB_REP_OUTDATED DB_REP_PAGEDONE DB_REP_PAGELOCKED DB_REP_PERMANENT DB_REP_REREQUEST DB_REP_STARTUPDONE DB_REP_UNAVAIL DB_REVSPLITOFF DB_RMW DB_RPCCLIENT DB_RPC_SERVERPROG DB_RPC_SERVERVERS DB_RUNRECOVERY DB_SALVAGE DB_SA_SKIPFIRSTKEY DB_SA_UNKNOWNKEY DB_SECONDARY_BAD DB_SEQUENCE_OLDVER DB_SEQUENCE_VERSION DB_SEQUENTIAL DB_SEQ_DEC DB_SEQ_INC DB_SEQ_RANGE_SET DB_SEQ_WRAP DB_SEQ_WRAPPED DB_SET DB_SET_LOCK_TIMEOUT DB_SET_LTE DB_SET_RANGE DB_SET_RECNO DB_SET_REG_TIMEOUT DB_SET_TXN_NOW DB_SET_TXN_TIMEOUT DB_SHALLOW_DUP DB_SNAPSHOT DB_SPARE_FLAG DB_STAT_ALL DB_STAT_CLEAR DB_STAT_LOCK_CONF DB_STAT_LOCK_LOCKERS DB_STAT_LOCK_OBJECTS DB_STAT_LOCK_PARAMS DB_STAT_MEMP_HASH DB_STAT_MEMP_NOERROR DB_STAT_NOERROR DB_STAT_SUBSYSTEM DB_ST_DUPOK DB_ST_DUPSET DB_ST_DUPSORT DB_ST_IS_RECNO DB_ST_OVFL_LEAF DB_ST_RECNUM DB_ST_RELEN DB_ST_TOPLEVEL DB_SURPRISE_KID DB_SWAPBYTES DB_SYSTEM_MEM DB_TEMPORARY DB_TEST_ELECTINIT DB_TEST_ELECTSEND DB_TEST_ELECTVOTE1 DB_TEST_ELECTVOTE2 DB_TEST_ELECTWAIT1 DB_TEST_ELECTWAIT2 DB_TEST_POSTDESTROY DB_TEST_POSTLOG DB_TEST_POSTLOGMETA DB_TEST_POSTOPEN DB_TEST_POSTRENAME DB_TEST_POSTSYNC DB_TEST_PREDESTROY DB_TEST_PREOPEN DB_TEST_PRERENAME DB_TEST_RECYCLE DB_TEST_SUBDB_LOCKS DB_THREAD DB_THREADID_STRLEN DB_TIMEOUT DB_TIME_NOTGRANTED DB_TRUNCATE DB_TXNMAGIC DB_TXNVERSION DB_TXN_ABORT DB_TXN_APPLY DB_TXN_BACKWARD_ROLL DB_TXN_BULK DB_TXN_CKP DB_TXN_FAMILY DB_TXN_FORWARD_ROLL DB_TXN_LOCK DB_TXN_LOCK_2PL DB_TXN_LOCK_MASK DB_TXN_LOCK_OPTIMIST DB_TXN_LOCK_OPTIMISTIC DB_TXN_LOG_MASK DB_TXN_LOG_REDO DB_TXN_LOG_UNDO DB_TXN_LOG_UNDOREDO DB_TXN_LOG_VERIFY DB_TXN_NOSYNC DB_TXN_NOT_DURABLE DB_TXN_NOWAIT DB_TXN_OPENFILES DB_TXN_POPENFILES DB_TXN_PRINT DB_TXN_REDO DB_TXN_SNAPSHOT DB_TXN_SYNC DB_TXN_TOKEN_SIZE DB_TXN_UNDO DB_TXN_WAIT DB_TXN_WRITE_NOSYNC DB_UNKNOWN DB_UNREF DB_UPDATE_SECONDARY DB_UPGRADE DB_USERCOPY_GETDATA DB_USERCOPY_SETDATA DB_USE_ENVIRON DB_USE_ENVIRON_ROOT DB_VERB_CHKPOINT DB_VERB_DEADLOCK DB_VERB_FILEOPS DB_VERB_FILEOPS_ALL DB_VERB_RECOVERY DB_VERB_REGISTER DB_VERB_REPLICATION DB_VERB_REPMGR_CONNFAIL DB_VERB_REPMGR_MISC DB_VERB_REP_ELECT DB_VERB_REP_LEASE DB_VERB_REP_MISC DB_VERB_REP_MSGS DB_VERB_REP_SYNC DB_VERB_REP_SYSTEM DB_VERB_REP_TEST DB_VERB_WAITSFOR DB_VERIFY DB_VERIFY_BAD DB_VERIFY_FATAL DB_VERIFY_PARTITION DB_VERSION_FAMILY DB_VERSION_FULL_STRING DB_VERSION_MAJOR DB_VERSION_MINOR DB_VERSION_MISMATCH DB_VERSION_PATCH DB_VERSION_RELEASE DB_VERSION_STRING DB_VRFY_FLAGMASK DB_WRITECURSOR DB_WRITELOCK DB_WRITEOPEN DB_WRNOSYNC DB_XA_CREATE DB_XIDDATASIZE DB_YIELDCPU DB_debug_FLAG DB_user_BEGIN LOGREC_ARG LOGREC_DATA LOGREC_DB LOGREC_DBOP LOGREC_DBT LOGREC_Done LOGREC_HDR LOGREC_LOCKS LOGREC_OP LOGREC_PGDBT LOGREC_PGDDBT LOGREC_PGLIST LOGREC_POINTER LOGREC_TIME ); =head1 NAME BDB::Wrapper Wrapper module for BerkeleyDB.pm for easy usage of it. This will make it easy to use BerkeleyDB.pm. You can protect bdb file from the concurrent access and you can use BerkeleyDB.pm with less difficulty. This module is used on http://www.accessup.org/ and is developed based on the requirement. Attention: If you use this module for the specified Berkeley DB file, please use this module for all access to the bdb. By it, you can control lock and strasaction of bdb files. BDB_HOMEs are created under /tmp/bdb_home in default option. Japanese: http://www.accessup.org/pj/6_B4C9CDFDBFCDA4B5A4F3/13/list.html English: http://en.accessup.org/pe/Administrator/19/list.html =cut =head1 Example of basic usage =cut =pod #!/usr/bin/perl -w package test_bdb; use strict; use BDB::Wrapper; my $pro=new test_bdb; $pro->run(); sub new(){ my $self={}; return bless $self; } sub run(){ my $self=shift; $self->init_vars(); $self->demo(); } sub init_vars(){ my $self=shift; $self->{'bdb'}='/tmp/test.bdb'; $self->{'bdbw'}=new BDB::Wrapper; } sub demo(){ my $self=shift; if(my $dbh=$self->{'bdbw'}->create_write_dbh($self->{'bdb'})){ ############### # This is not must job but it will help to avoid unexpected result caused by unexpected process killing local $SIG{'INT'}; local $SIG{'TERM'}; local $SIG{'QUIT'}; $SIG{'INT'}=$SIG{'TERM'}=$SIG{'QUIT'}=sub {$dbh->db_close();}; ########### if($dbh && $dbh->db_put('name', 'value')==0){ } else{ $dbh->db_close() if $dbh; die 'Failed to put to '.$self->{'bdb'}; } $dbh->db_close() if $dbh; } if(my $dbh=$self->{'bdbw'}->create_read_dbh($self->{'bdb'})){ my $value; if($dbh->db_get('name', $value)==0){ print 'Name='.$name.' value='.$value."\n"; } $dbh->db_close(); } } =cut =head1 Example of using transaction =cut =pod # Transaction Usage #!/usr/bin/perl -w package bdb_write; use strict; use BDB::Wrapper; my $pro = new bdb_write; $pro->run(); sub new(){ my $self={}; return bless $self; } sub run(){ my $self=shift; $self->{'bdbw'}=new BDB::Wrapper; # If you want to create bdb_home with transaction log under /home/txn_data/bdb_home/$BDBFILENAME/ my ($dbh, $env)=$self->{'bdbw'}->create_write_dbh({'bdb'=>'/tmp/bdb_write.bdb', 'transaction'=>'/home/txn_data'}); my $txn = $env->txn_begin(undef, DB_TXN_NOWAIT); my $cnt=0; for($i=0;$i<1000;$i++){ $dbh->db_put($i, $i*rand()); $cnt=$i; if($cnt && $cnt%100==0){ $txn->txn_commit(); $txn = $env->txn_begin(undef, DB_TXN_NOWAIT); } } $txn->txn_commit(); $env->txn_checkpoint(1,1,0); $dbh->db_close(); chmod 0666, '/tmp/bdb_write.bdb'; print "Content-type:text/html\n\n"; print $cnt."\n"; } =cut =head1 methods =head2 new Creates an object of BDB::Wrapper If you set {'ram'=>1}, you can use /dev/shm/bdb_home for storing locking file for BDB instead of /tmp/bdb_home/. 1 is default value. If you set {'no_lock'=>1}, the control of concurrent access will not be used. So the lock files are also not created. 0 is default value. If you set {'cache'=>$CACHE_SIZE}, you can allocate cache memory of the specified bytes for using bdb files. The value can be overwritten by the cache value of create_write_dbh undef is default value. If you set {'wait'=>wait_seconds}, you can specify the seconds in which dead lock will be removed. 11 is default value. If you set {'transaction'=>transaction_root_dir}, all dbh object will be created in transaction mode unless you don\'t specify transaction root dir in each method. 11 is default value. =cut sub new(){ my $self={}; my $class=shift; my $op_ref=shift; $self->{'lock_root'}='/tmp'; $self->{'no_lock'}=0; $self->{'Flags'}=''; $self->{'wait'}= 22; while(my ($key, $value)=each %{$op_ref}){ if($key eq 'ram'){ if($value){ $self->{'lock_root'}='/dev/shm'; } } elsif($key eq 'cache'){ $self->{'Cachesize'}=$value if(defined($value)); } elsif($key eq 'Cachesize'){ $self->{'Cachesize'}=$value if(defined($value)); } elsif($key eq 'no_lock'){ if($value){ $self->{'no_lock'}++; } } elsif($key eq 'wait'){ $self->{'wait'}=$value; } elsif($key eq 'transaction'){ $self->{'transaction'}=$value; if($self->{'transaction'} && $self->{'transaction'}!~ m!^/.!){ croak("transaction parameter must be valid directory name."); } if($self->{'transaction'}){ $self->{'lock_root'}=$self->{'transaction'}; } } else{ my $error='Invalid option: key='.$key; if($value){ $error.=', value='.$value; } Carp::croak($error); } } return bless $self; } 1; __END__ =head2 create_env Creates Environment for BerkeleyDB create_env({'bdb'=>$bdb, 'no_lock='>0(default) or 1, 'cache'=>undef(default) or integer, 'error_log_file'=>undef or $error_log_file, 'transaction'=> 0==undef or $transaction_root_dir }); no_lock and cache will overwrite the value specified in new but used only in this env =cut sub create_env(){ my $self=shift; my $op=shift; my $bdb=File::Spec->rel2abs($op->{'bdb'}) || return; my $no_lock=$op->{'no_lock'} || $self->{'no_lock'} || 0; my $transaction=$undef; $self->{'error_log_file'}=$op->{'errore_log_file'}; if(exists($op->{'transaction'})){ $transaction=$op->{'transaction'}; } else{ $transaction=$self->{'transaction'}; } if($transaction && $transaction!~ m!^/.!){ croak("transaction parameter must be valid directory name."); } my $cache=$op->{'cache'} || $self->{'Cachesize'} || undef; my $env; my $Flags; if($transaction){ if($transaction=~ m!^/.!){ $Flags=DB_INIT_LOCK |DB_INIT_LOG | DB_INIT_TXN | DB_CREATE | DB_INIT_MPOOL; } else{ croak("transaction parameter must be valid directory name."); } } elsif($no_lock){ $Flags=DB_CREATE | DB_INIT_MPOOL; } else{ $Flags=DB_INIT_CDB | DB_CREATE | DB_INIT_MPOOL; } my $lock_flag; my $home_dir=$self->get_bdb_home({'bdb'=>$bdb, 'transaction'=>$transaction}); $home_dir=~ s!\.[^/\.\s]+$!!; unless(-d $home_dir){ $self->rmkdir($home_dir); } $lock_flag=DB_LOCK_OLDEST unless($no_lock); if($cache){ $env = new BerkeleyDB::Env { -Cachesize => $cache, -Flags => $Flags, -Home => $home_dir, -LockDetect => $lock_flag, -Mode => 0666, -ErrFile => $self->{'error_log_file'} }; } else{ $env = new BerkeleyDB::Env { -Flags => $Flags, -Home => $home_dir, -LockDetect => $lock_flag, -Mode => 0666, -ErrFile => $self->{'error_log_file'} }; } # DB_CREATE is necessary for ccdb # Home is necessary for locking return $env; } # { DB_DATA_DIR => "/home/databases", DB_LOG_DIR => "/home/logs", DB_TMP_DIR => "/home/tmp" =head2 create_dbh Not recommened method. Please use create_read_dbh() or create_write_dbh(). Creates database handler for BerkeleyDB This will be obsolete due to too much simplicity, so please don\'t use. =cut sub create_dbh(){ my $self=shift; my $bdb=File::Spec->rel2abs(shift); my $op=shift; return $self->create_write_dbh($bdb,$op); } =head2 create_hash_ref Not recommended method. Please use create_write_dbh(). Creates database handler for BerkeleyDB This will be obsolete due to too much simplicity, so please don\'t use. =cut sub create_hash_ref(){ my $self=shift; my $bdb=File::Spec->rel2abs(shift); my $op=shift; return $self->create_write_hash_ref($bdb, $op); } =head2 create_write_dbh This returns database handler for writing or ($database_handler, $env) depeinding on the request. $self->create_write_dbh({'bdb'=>$bdb, 'cache'=>undef(default) or integer, 'hash'=>0 or 1, 'dont_try'=>0 or 1, 'no_lock'=>0(default) or 1, 'sort_code_ref'=>$sort_code_reference, 'sort' or 'sort_num'=>0 or 1, 'transaction'=> 0==undef or $transaction_root_dir, 'reverse_cmp'=>0 or 1, 'reverse' or 'reverse_num'=>0 or 1 }); In the default mode, BDB file will be created as Btree; If you set 'hash' 1, Hash BDB will be created. If you set 'dont_try' 1, this module won\'t try to unlock BDB if it detects the situation in which deadlock may be occuring. If you set sort_code_ref some code reference, you can set subroutine for sorting for Btree. If you set sort or sort_num 1, you can use sub {$_[0] <=> $_[1]} for sort_code_ref. If you set reverse or reverse_num 1, you can use sub {$_[1] <=> $_[0]} for sort_code_ref. If you set reverse_cmp 1, you can use sub {$_[1] cmp $_[0]} for sort_code_ref. If you set transaction for storing transaction log, transaction will be used and ($bdb_handler, $transaction_handler) will be returned. =cut sub create_write_dbh(){ my $self=shift; my $bdb=shift; my $op=''; if($bdb && ref($bdb) eq 'HASH'){ $op=$bdb; $bdb=$op->{'bdb'}; } else{ $op=shift; $op->{'bdb'}=$bdb; } $op->{'bdb'}=File::Spec->rel2abs($op->{'bdb'}); my $transaction = undef; my $hash=0; my $dont_try=0; my $sort_code_ref=undef; if(ref($op) eq 'HASH'){ $hash=$op->{'hash'} || 0; $dont_try=$op->{'dont_try'} || 0; if(exists($op->{'transaction'})){ $transaction = $op->{'transaction'}; } else{ $transaction = $self->{'transaction'}; } if($transaction && $transaction!~ m!^/.!){ croak("transaction parameter must be valid directory name."); } if($op->{'reverse'} || $op->{'reverse_num'}){ $sort_code_ref=sub {$_[1] <=> $_[0]}; } elsif($op->{'reverse_cmp'}){ $sort_code_ref=sub {$_[1] cmp $_[0]}; } elsif($op->{'sort'} || $op->{'sort_num'}){ $sort_code_ref=sub {$_[0] <=> $_[1]}; } else{ $sort_code_ref=$op->{'sort_code_ref'}; } } else{ $hash=$op || 0; $dont_try=shift || 0; $sort_code_ref=shift; } my $env; if($op->{'no_env'}){ $env=undef; } else{ $env=$self->create_env({'bdb'=>$op->{'bdb'}, 'cache'=>$op->{'cache'}, 'no_lock'=>$op->{'no_lock'}, 'transaction'=>$transaction}); } my $bdb_dir=$op->{'bdb'}; $bdb_dir=~ s!/[^/]+$!!; my $dbh; if($no_lock){ $self->rmkdir($bdb_dir); if($hash){ $dbh =new BerkeleyDB::Hash { -Filename => $op->{'bdb'}, -Flags => DB_CREATE, -Mode => 0666, -Env => $env }; } else{ $dbh =new BerkeleyDB::Btree { -Filename => $op->{'bdb'}, -Flags => DB_CREATE, -Mode => 0666, -Env => $env, -Compare => $sort_code_ref }; } } else{ $SIG{ALRM} = sub { die "timeout"}; eval{ alarm($self->{'wait'}); $self->rmkdir($bdb_dir); if($hash){ $dbh =new BerkeleyDB::Hash { -Filename => $op->{'bdb'}, -Flags => DB_CREATE, -Mode => 0666, -Env => $env }; } else{ $dbh =new BerkeleyDB::Btree { -Filename => $op->{'bdb'}, -Flags => DB_CREATE, -Mode => 0666, -Env => $env, -Compare => $sort_code_ref }; } alarm(0); }; unless($dont_try){ if($@){ if($@ =~ /timeout/){ $op->{'dont_try'}=1; $dont_try=1; my $home_dir=$self->get_bdb_home({'bdb'=>$bdb}); system('rm -rf '.$home_dir) if ($home_dir=~ m!^(?:/tmp|/dev/shm)! && -d $home_dir); if(ref($op) eq 'HASH'){ $op->{'dont_try'}=1; return $self->create_write_dbh($op); } else{ return $self->create_write_dbh($bdb, $dont_try, $sort_code_ref); } } else{ alarm(0); } } } } if(!$dbh){ { local $|=0; print "Content-type:text/html\n\nFailed to create write dbh for "; print $op->{'bdb'}.'
'."\n"; print "Please inform this error to this site's administrator."; exit; } } else{ if(wantarray){ return ($dbh, $env); } else{ return $dbh; } } } =head2 create_read_dbh This returns database handler for reading or ($database_handler, $env) depeinding on the request. $self->create_read_dbh({ 'bdb'=>$bdb, 'hash'=>0 or 1, 'dont_try'=>0 or 1, 'sort_code_ref'=>$sort_code_reference, 'sort' or 'sort_num'=>0 or 1, 'reverse_cmp'=>0 or 1, 'reverse' or 'reverse_num'=>0 or 1, 'transaction'=> 0==undef or $transaction_root_dir }); In the default mode, BDB file will be created as Btree; If you set 'hash' 1, Hash BDB will be created. If you set 'dont_try' 1, this module won\'t try to unlock BDB if it detects the situation in which deadlock may be occuring. If you set sort_code_ref some code reference, you can set subroutine for sorting for Btree. If you set sort or sort_num 1, you can use sub {$_[0] <=> $_[1]} for sort_code_ref. If you set reverse or reverse_num 1, you can use sub {$_[1] <=> $_[0]} for sort_code_ref. If you set reverse_cmp 1, you can use sub {$_[1] cmp $_[0]} for sort_code_ref. =cut sub create_read_dbh(){ my $self=shift; my $bdb=shift; my $op=''; my $transaction=undef; if($bdb && ref($bdb) eq 'HASH'){ $op=$bdb; $bdb=$op->{'bdb'}; } else{ $op=shift; $op->{'bdb'}=$bdb; } $op->{'bdb'}=File::Spec->rel2abs($op->{'bdb'}); my $hash=0; my $dont_try=0; my $sort_code_ref=undef; if(ref($op) eq 'HASH'){ if(exists($op->{'transaction'})){ $transaction=$op->{'transaction'}; } else{ $transaction=$self->{'transaction'}; } if($transaction && $transaction!~ m!^/.!){ croak("transaction parameter must be valid directory name."); } $hash=$op->{'hash'} || 0; $dont_try=$op->{'dont_try'} || 0; if($op->{'reverse'} || $op->{'reverse_num'}){ $sort_code_ref=sub {$_[1] <=> $_[0]}; } elsif($op->{'reverse_cmp'}){ $sort_code_ref=sub {$_[1] cmp $_[0]}; } elsif($op->{'sort'} || $op->{'sort_num'}){ $sort_code_ref=sub {$_[0] <=> $_[1]}; } elsif($op->{'sort_code_ref'}){ $sort_code_ref=$op->{'sort_code_ref'}; } } else{ $hash=$op || 0; $dont_try=shift || 0; $sort_code_ref=shift; } my $env=''; if($op->{'use_env'} || $transaction){ $env=$self->create_env({'bdb'=>$op->{'bdb'}, 'cache'=>$op->{'cache'}, 'no_lock'=>$op->{'no_lock'}, 'transaction'=>$transaction}); } else{ $env=undef; } my $dbh; $SIG{ALRM} = sub { die "timeout"}; eval{ alarm($self->{'wait'}); if($hash){ $dbh =new BerkeleyDB::Hash { -Env=>$env, -Filename => $op->{'bdb'}, -Flags => DB_RDONLY }; } else{ $dbh =new BerkeleyDB::Btree { -Env=>$env, -Filename => $op->{'bdb'}, -Flags => DB_RDONLY, -Compare => $sort_code_ref }; } alarm(0); }; unless($dont_try){ if($@){ if($@ =~ /timeout/){ $op->{'dont_try'}=1; $dont_try=1; $self->clear_bdb_home({'bdb'=>$op->{'bdb'}, 'transaction'=>$transaction}); if(ref($op) eq 'HASH'){ return $self->create_read_dbh($op->{'bdb'}, $op); } else{ return $self->create_read_dbh($op->{'bdb'}, $hash, $dont_try, $sort_code_ref); } } else{ alarm(0); } } } if(!$dbh){ return; } else{ if(wantarray){ return ($dbh, $env); } else{ return $dbh; } } } =head2 create_write_hash_ref Not recommended method. Please use create_write_dbh() instead of this method. This will creates hash for writing. $self->create_write_hash_ref({'bdb'=>$bdb, 'hash'=>0 or 1, 'dont_try'=>0 or 1, 'sort_code_ref'=>$sort_code_reference, 'sort' or 'sort_num'=>0 or 1, 'reverse_cmp'=>0 or 1, 'reverse' or 'reverse_num'=>0 or 1 }); In the default mode, BDB file will be created as Btree. If you set 'hash' 1, Hash BDB will be created. If you set 'dont_try' 1, this module won\'t try to unlock BDB if it detects the situation in which deadlock may be occuring. If you set sort_code_ref some code reference, you can set subroutine for sorting for Btree. If you set sort or sort_num 1, you can use sub {$_[0] <=> $_[1]} for sort_code_ref. If you set reverse or reverse_num 1, you can use sub {$_[1] <=> $_[0]} for sort_code_ref. If you set reverse_cmp 1, you can use sub {$_[1] cmp $_[0]} for sort_code_ref. =cut sub create_write_hash_ref(){ my $self=shift; my $bdb=shift; my $op=''; if($bdb && ref($bdb) eq 'HASH'){ $op=$bdb; $bdb=$op->{'bdb'}; } else{ $op=shift; } $bdb=File::Spec->rel2abs($bdb); my $hash=0; my $dont_try=0; my $sort_code_ref=undef; if(ref($op) eq 'HASH'){ $hash=$op->{'hash'} || 0; $dont_try=$op->{'dont_try'} || 0; if($op->{'reverse'} || $op->{'reverse_num'}){ $sort_code_ref=sub {$_[1] <=> $_[0]}; } elsif($op->{'reverse_cmp'}){ $sort_code_ref=sub {$_[1] cmp $_[0]}; } elsif($op->{'sort'} || $op->{'sort_num'}){ $sort_code_ref=sub {$_[0] <=> $_[1]}; } else{ $sort_code_ref=$op->{'sort_code_ref'}; } } else{ $hash=$op || 0; $dont_try=shift || 0; $sort_code_ref=shift; } my $type='BerkeleyDB::Btree'; if($hash){ $type='BerkeleyDB::Hash'; } my $env; if($self->{'op'}->{'no_env'}){ $env=undef; } else{ $env=$self->create_env({'bdb'=>$bdb}); } my $bdb_dir=$bdb; $bdb_dir=~ s!/[^/]+$!!; local $SIG{ALRM} = sub { die "timeout"}; my %hash; eval{ alarm($self->{'wait'}); $self->rmkdir($bdb_dir); if($sort_code_ref && !$hash){ tie %hash, $type, -Env=>$env, -Filename => $bdb, -Mode => 0666, -Flags => DB_CREATE, -Compare => $sort_code_ref; } else{ tie %hash, $type, -Env=>$env, -Filename => $bdb, -Mode => 0666, -Flags => DB_CREATE; } alarm(0); }; unless($dont_try){ if($@){ if($@ =~ /timeout/){ $op->{'dont_try'}=1; $dont_try=1; my $home_dir=$self->get_bdb_home({'bdb'=>$bdb}); system('rm -rf '.$home_dir) if ($home_dir=~ m!^(?:/tmp|/dev/shm)!); if(ref($op) eq 'HASH'){ return $self->create_write_hash_ref($bdb, $op); } else{ return $self->create_write_hash_ref($bdb, $hash, $dont_try, $sort_code_ref); } } else{ alarm(0); } } } return \%hash; } =head2 create_read_hash_ref Not recommended method. Please use create_read_dbh and cursor(). This will creates database handler for reading. $self->create_read_hash_ref({ 'bdb'=>$bdb, 'hash'=>0 or 1, 'dont_try'=>0 or 1, 'sort_code_ref'=>$sort_code_reference, 'sort' or 'sort_num'=>0 or 1, 'reverse_cmp'=>0 or 1, 'reverse' or 'reverse_num'=>0 or 1 }); In the default mode, BDB file will be created as Btree. If you set 'hash' 1, Hash BDB will be created. If you set 'dont_try' 1, this module won\'t try to unlock BDB if it detects the situation in which deadlock may be occuring. If you set sort_code_ref some code reference, you can set subroutine for sorting for Btree. If you set sort or sort_num 1, you can use sub {$_[0] <=> $_[1]} for sort_code_ref. If you set reverse or reverse_num 1, you can use sub {$_[1] <=> $_[0]} for sort_code_ref. If you set reverse_cmp 1, you can use sub {$_[1] cmp $_[0]} for sort_code_ref. If you set use_env 1, you can use environment for this method. =cut sub create_read_hash_ref(){ my $self=shift; my $bdb=shift; my $op=''; if($bdb && ref($bdb) eq 'HASH'){ $op=$bdb; $bdb=$op->{'bdb'}; } else{ $op=shift; } $bdb=File::Spec->rel2abs($bdb); my $hash=0; my $dont_try=0; my $sort_code_ref=undef; if(ref($op) eq 'HASH'){ $hash=$op->{'hash'} || 0; $dont_try=$op->{'dont_try'} || 0; if($op->{'reverse'} || $op->{'reverse_num'}){ $sort_code_ref=sub {$_[1] <=> $_[0]}; } elsif($op->{'reverse_cmp'}){ $sort_code_ref=sub {$_[1] cmp $_[0]}; } elsif($op->{'sort'} || $op->{'sort_num'}){ $sort_code_ref=sub {$_[0] <=> $_[1]}; } else{ $sort_code_ref=$op->{'sort_code_ref'}; } } else{ # Obsolete $hash=$op || 0; $dont_try=shift || 0; $sort_code_ref=shift; } my $type='BerkeleyDB::Btree'; if($hash){ $type='BerkeleyDB::Hash'; } my $env=''; if($op->{'use_env'}){ $env=$self->create_env({'bdb'=>$bdb}); } else{ $env=undef; } my %hash; local $SIG{ALRM} = sub { die "timeout"}; eval{ alarm($self->{'wait'}); if($sort_code_ref && !$hash){ tie %hash, $type, -Env=>$env, -Filename => $bdb, -Flags => DB_RDONLY, -Compare => $sort_code_ref; } else{ tie %hash, $type, -Env=>$env, -Filename => $bdb, -Flags => DB_RDONLY; } alarm(0); }; unless($dont_try){ if($@){ if($@ =~ /timeout/){ $op->{'dont_try'}=1; $dont_try=1; my $home_dir=$self->get_bdb_home($bdb); system('rm -rf '.$home_dir) if($home_dir=~ m!^(?:/tmp|/dev/shm)!); if(ref($op) eq 'HASH'){ return $self->create_read_hash_ref($bdb, $op); } else{ return $self->create_read_hash_ref($bdb, $hash, $dont_try, $sort_code_ref); } } else{ alarm(0); } } } return \%hash; } =head2 rmkdir Code from CGI::Accessup. This creates the specified directory recursively. rmkdir($dir); =cut sub rmkdir(){ my $self=shift; my $path=shift; my $force=shift; if($path){ $path=~ s!^\s+|\s+$!!gs; if($path=~ m![^/\.]!){ my $target=''; if($path=~ s!^([\./]+)!!){ $target=$1; } while($path=~ s!^([^/]+)/?!!){ $target.=$1; if($force && -f $target){ unlink $target; } unless(-d $target){ mkdir($target,0777) || Carp::carp("Failed to create ".$target); # for avoiding umask to mkdir chmod 0777, $target || Carp::carp("Failed to chmod ".$target);; } $target.='/'; } return 1; } } return 0; } =head2 get_bdb_home This will return bdb_home. You may need the information for recovery and so on. get bdb_home({ 'bdb'=>$bdb, 'transaction'=>$transaction }); OR get_bdb_home($bdb); =cut sub get_bdb_home(){ my $self=shift; my $op=shift; my $bdb=''; my $transaction=undef; my $lock_root=$self->{'lock_root'}; if($op && ref($op) eq 'HASH'){ $bdb=$op->{'bdb'} || return; if(exists($op->{'transaction'})){ $transaction=$op->{'transaction'}; } else{ $transaction=$self->{'transaction'}; } } else{ $bdb=File::Spec->rel2abs($op) || return; $transaction=$self->{'transaction'}; } if($transaction && $transaction!~ m!^/.!){ croak("transaction parameter must be valid directory name."); } if($transaction){ $lock_root=$transaction; } $bdb=~ s!\.bdb$!!i; return $lock_root.'/bdb_home'.$bdb; } =head2 clear_bdb_home This will clear bdb_home. clear_bdb_home({ 'bdb'=>$bdb, 'transaction' => 0==undef or $transaction_root_dir }); OR clear_bdb_home($bdb); =cut sub clear_bdb_home(){ my $self=shift; my $op=shift; my $bdb=''; my $transaction=undef; my $lock_root=$self->{'lock_root'}; if($op && ref($op) eq 'HASH'){ $bdb=$op->{'bdb'} || return; if(exists($op->{'transaction'})){ $transaction=$op->{'transaction'}; } else{ $transaction=$self->{'transaction'}; } if($transaction && $transaction!~ m!^/.!){ croak("transaction parameter must be valid directory name."); } if($transaction){ $lock_root=$transaction; } } else{ $bdb=File::Spec->rel2abs($op) || return; } $bdb=~ s!\.bdb$!!i; my $dir=$lock_root.'/bdb_home'.$bdb; my $dh; opendir($dh, $dir); if($dh){ while (my $file = readdir $dh){ if(-f $dir.'/'.$file){ unlink $dir.'/'.$file; } } closedir $dh; rmdir $dir; } } =head2 record_error This will record error message to /tmp/bdb_error.log if you don\'t specify error_log_file record_error({ 'msg'=>$error_message, 'error_log_file'=>$error_log_file }); OR record_error($error_msg) =cut sub record_error(){ my $self=shift; my $op=shift || return; my $msg=''; my $error_log_file=''; if($op && ref($op) eq 'HASH'){ $msg=$op->{'msg'}; $error_log_file=$op->{'error_log_file'}; } else{ $msg=$op; } if(!$error_log_file){ if($self->{'error_log_file'}){ $error_log_file=$self->{'error_log_file'}; } else{ $error_log_file='/tmp/bdb_error.log'; } } if(my $fh=new FileHandle('>> '.$error_log_file)){ my ($in_sec,$in_min,$in_hour,$in_mday,$in_mon,$in_year,$in_wday)=localtime(CORE::time()); $in_mon++; $in_year+=1900; $in_mon='0'.$in_mon if($in_mon<10); $in_mday='0'.$in_mday if($in_mday<10); $in_hour='0'.$in_hour if($in_hour<10); $in_min='0'.$in_min if($in_min<10); $in_sec='0'.$in_sec if($in_sec<10); print $fh $in_year.'/'.$in_mon.'/'.$in_mday.' '.$in_hour.':'.$in_min.':'.$in_sec."\t".$msg."\n"; $fh->close(); } }