Result:
found more than 668 distributions - search limited to the first 2001 files matching your query
( run in 2.275 )
DBIx-MyParse
view release on metacpan or search on metacpan
lib/DBIx/MyParse/Query.pm view on Meta::CPAN
=back
=head2 C<"SQLCOM_LOCK_TABLES"> and C<"SQLCOM_UNLOCK_TABLES">
You can use C<getTables()> to get a list of the tables being locked. Calling C<getOptions()> returns a list of lock
types so that the first lock type in the list corresponds to the first table and so on in a one-to-one relationship.
=head2 C<"SQLCOM_DROP_TABLE">, C<"SQLCOM_TRUNCATE"> and C<"SQLCOM_RENAME_TABLE">
For C<"SQLCOM_DROP_TABLE"> and C<"SQLOM_TRUNCATE">, use C<getTables()> to obtain a reference to an array of
DBIx-NinjaORM
view release on metacpan or search on metacpan
lib/DBIx/NinjaORM.pm view on Meta::CPAN
skip_cache => 1,
) // die 'Book with ISBN 9781449303587 does not exist';
=item * lock (default: 0)
By default, the underlying row is not locked when retrieving an object via
C<new()>. Setting C<lock> to 1 forces the ORM to bypass the cache if any, and
to lock the rows in the database as it retrieves them.
my $object = My::Model::Book->new(
{ isbn => '9781449303587' },
lib/DBIx/NinjaORM.pm view on Meta::CPAN
if defined( $args{'query_extensions'}->{'joined_fields'} );
# We need to make an exception for lock=1 when using SQLite, since
# SQLite doesn't support FOR UPDATE.
# Per http://sqlite.org/cvstrac/wiki?p=UnsupportedSql, the entire
# database is locked when updating any bit of it, so we can simply
# ignore the locking request here.
my $lock = '';
if ( $args{'lock'} )
{
my $database_type = $dbh->{'Driver'}->{'Name'} || '';
lib/DBIx/NinjaORM.pm view on Meta::CPAN
"Performing pre-locking query:\n%s\nValues:\n%s",
$query,
\@query_values,
) if $args{'show_queries'};
my $locked_ids;
try
{
local $dbh->{'RaiseError'} = 1;
$locked_ids = $dbh->selectall_arrayref(
$query,
{
Columns => [ 1 ],
},
@query_values
lib/DBIx/NinjaORM.pm view on Meta::CPAN
\@query_values,
);
croak "Failed select: $_";
};
if ( !defined( $locked_ids ) || ( scalar( @$locked_ids ) == 0 ) )
{
return [];
}
$where = sprintf(
'WHERE %s.%s IN ( %s )',
$quoted_table_name,
$quoted_primary_key_name,
join( ', ', ( ('?') x scalar( @$locked_ids ) ) ),
);
$where_values = [ [ map { $_->[0] } @$locked_ids ] ];
$lock = '';
}
# Prepare the query elements.
my $query = sprintf(
DBIx-OnlineDDL
view release on metacpan or search on metacpan
lib/DBIx/OnlineDDL/Helper/SQLite.pm view on Meta::CPAN
# Disable /x flag to allow for whitespace within string, but turn it on for newlines
# and comments.
return $error =~ m<
# Locks
(?-x:database( table)? is locked)|
# Connections
(?-x:attempt to [\w\s]+ on inactive database handle)|
# Queries
DBIx-ParseError-MySQL
view release on metacpan or search on metacpan
lib/DBIx/ParseError/MySQL.pm view on Meta::CPAN
(?-x:Query execution was interrupted(?!, maximum statement execution time exceeded))|
# Initial connection failure
(?-x:Bad handshake)|
(?-x:Too many connections)|
(?-x:Host '\S+' is blocked because of many connection errors)|
(?-x:Can't get hostname for your address)|
(?-x:Can't connect to (?:local )?MySQL server)|
# Packet corruption
(?-x:Got a read error from the connection pipe)|
DBIx-Path
view release on metacpan or search on metacpan
lib/DBIx/Path.pm view on Meta::CPAN
no strict 'refs';
*{$field}=sub { $_[0]->{$field} }
}
{
my $locked=0;
sub _lock {
my($me, $type)=@_;
$locked++;
if($locked == 1 and $me->{hooks}{lock}) {
$me->{hooks}{lock}->($me->{dbh}, $type);
}
}
sub _unlock {
my($me, $type)=@_;
if($locked == 1) {
$me->{hooks}{unlock}->($me->{dbh}, $type) if $me->{hooks}{unlock};
}
elsif($locked == 0) {
croak "DBIx::Path: PANIC: Key won't fit in lock";
}
$locked--;
}
END {
if($locked) {
warn "DBIx::Path: WARNING: Program may have exited with lock(s) still held";
}
}
}
DBIx-QueryByName
view release on metacpan or search on metacpan
lib/DBIx/QueryByName/SthPool.pm view on Meta::CPAN
while (1) {
# Normally, if traffic between the client and the database
# server is interupted (cable cut, whatever), the client will
# timeout after 1min (observed on osx). But it has been
# observed on some setups (client on linux, server blocked by
# drop rule in firewall) that the client hang forever in
# execute(). The following code is a workaround:
#
# my $did_timeout = 0;
# eval {
DBIx-QuickDB
view release on metacpan or search on metacpan
lib/DBIx/QuickDB/Pool.pm view on Meta::CPAN
for my $name (readdir($dh)) {
my $full = "$dir/$name";
# Quarantines sit outside the canonical cache path (see
# _remove_or_quarantine). Retry their removal on every pass: the
# transient Windows file lock that blocked deletion may have cleared.
if ($name =~ m/\.STALE-/) {
remove_tree_robust($full) if -d $full;
next;
}
lib/DBIx/QuickDB/Pool.pm view on Meta::CPAN
# An expired SQLite source may still have DBI handles retained by
# application/test code. On Windows those handles prevent unlinking
# the database file. Close every matching handle before removal.
disconnect_dbi_handles($full);
# If removal remains blocked, moving the tree out of its canonical
# path keeps a later build from seeing partially-removed SQLite
# schema/data. Either way, invalidate the external markers: expiry
# was explicitly requested, and build_db() will refuse to build on
# any stubborn tree that could not be quarantined.
$self->_remove_or_quarantine($full);
DBIx-QuickORM
view release on metacpan or search on metacpan
t/AI/fork_sth_guards.t view on Meta::CPAN
like(dies { $sth->ready }, qr/different process than the one that created it/, "ready croaks in a non-owner process");
like(dies { $sth->result }, qr/different process than the one that created it/, "result croaks in a non-owner process");
like(dies { $sth->next }, qr/different process than the one that created it/, "next croaks in a non-owner process");
# The guard blocked all reads, so nothing reaped the child. Do it here.
waitpid($pid, 0);
};
subtest forked_write_child_error_does_not_throw_from_destructor => sub {
# A forked write sets on_finish, which makes cancel_on_destroy false: the
DBIx-Schema-Changelog
view release on metacpan or search on metacpan
examples/changelog/changelog-002-tables.yml view on Meta::CPAN
type: uuid
- name: msg_user
type: uuid
- default: 0
length: 1
name: locked
type: bit
- default: now()
name: last_read
type: timestamp
name: msg_session_members
DBIx-Simple-Class
view release on metacpan or search on metacpan
t/01-dbix-simple-class-schema-mysql.t view on Meta::CPAN
$dbix->query('DROP TABLE IF EXISTS `groups`');
$dbix->query(<<'TAB');
CREATE TABLE IF NOT EXISTS groups(
id INTEGER PRIMARY KEY AUTO_INCREMENT,
group_name VARCHAR(12),
`is blocked` INT,
data TEXT
) DEFAULT CHARSET=utf8 COLLATE=utf8_bin
TAB
DBIx-Struct
view release on metacpan or search on metacpan
NoUser->throw("User is not logged in or does not exist") unless defined $session;
# get client's row
my $client = $session->Client;
# strip microseconds part
$client->filter_timestamp;
# throw exception if client is blocked
BlkUser->throw if $client->state eq 'blocked';
# set expire date
$session->expire(\"now() + interval '2 day'");
# update session
$session->update;
# get usd client's balance from client_balance
DBIx-TextIndex
view release on metacpan or search on metacpan
lib/DBIx/TextIndex.pm view on Meta::CPAN
_log("field$fno ", scalar keys %{$self->{TERM_DOCS_VINT}->[$fno]},
" distinct terms\n") if $PA;
my $s_sth;
# SQLite chokes with "database table is locked" unless s_sth
# is finished before i_sth->execute
unless ($self->{DBD_TYPE} eq 'SQLite') {
$s_sth = $self->{INDEX_DBH}->prepare(
$self->{DB}->inverted_select(
$self->{INVERTED_TABLES}->[$fno] ) );
DBIx-TryAgain
view release on metacpan or search on metacpan
lib/DBIx/TryAgain.pm view on Meta::CPAN
my $dbh = DBI->connect(... dbi params.. { RootClass => "DBIx::TryAgain" } ) or die $DBI::errstr;
$dbh->try_again_algorithm('fibonacci');
$dbh->try_again_max_retries(5);
$dbh->try_again_on_messages([ qr/database is locked/i ]);
$dbh->try_again_on_prepare(1);
=head1 DESCRIPTION
This is a subclass of DBI which simply tries to execute a query
again whenever the error string matches a given set of patterns.
By default the only pattern is qr[database is locked], which is
what is returned by SQLite when the database is locked.
There is a delay between retries. Setting try_again_algorithm
to 'constant', 'linear', 'fibonacci', or 'exponential' causes
the corresponding algorithm to be used. The first five
values for these algorithsm are :
DBIx-TxnPool
view release on metacpan or search on metacpan
lib/DBIx/TxnPool.pm view on Meta::CPAN
The size of pool when a commit method will be called when feeding reaches the same size.
=item block_signals B<(Optional)>
An arrayref of signals (strings) which should be blocked in slippery places for
this I<pool>. Defaults are [ qw( TERM INT ) ]. You can change globaly this list
by setting: C<< $DBIx::TxnPool::BlockSignals = [ qw( TERM INT ALARM ... ) ] >>.
For details to see here L</"SIGNAL HANDLING">
=item max_repeated_deadlocks B<(Optional)>
DBIx-Web
view release on metacpan or search on metacpan
lib/DBIx/Web.pod view on Meta::CPAN
=item varLoad (?lock) -> self object
C<Persistent Variables>.
Loads variables into C<-var>.
Default lock level is LOCK_SH.
File will be locked until C<end> call.
=item varLock (?lock) -> success
C<Persistent Variables>.
Locks variables file.
Default is LOCK_EX.
File will be locked until C<end> call.
=item varStore () -> self
C<Persistent Variables>.
Stores C<-var> into variables file.
LOCK_EX is used.
File will be locked until C<end> call.
=item w32adhi () -> Active Directory Host Info object
C<User Identification>.
DBIx-Wrapper
view release on metacpan or search on metacpan
lib/DBIx/Wrapper/Changes.pm view on Meta::CPAN
=over 4
=item Fixed tests using SQLite
SQLite sometimes fails with a "database locked" error if the db
file is opened more than once. This may be because File::Temp is
locking the file.
See RT 76411 (L<https://rt.cpan.org/Public/Bug/Display.html?id=76411>)
DBM-Deep
view release on metacpan or search on metacpan
lib/DBM/Deep/Storage.pm view on Meta::CPAN
Take a lock usable for reading.
=item * unlock( $obj )
Releases the last lock taken. If this is the outermost lock, then the
object is actually unlocked.
=back
=cut
DB_File-Lock
view release on metacpan or search on metacpan
This module provides a wrapper for the DB_File module, adding locking.
When you need locking, simply use this module in place of DB_File and
add an extra argument onto the tie command specifying if the file should
be locked for reading or writing.
The alternative is to write code like:
open(LOCK, "<$db_filename.lock") or die;
flock(LOCK, LOCK_SH) or die;
Also realize that when acquiring two locks at the same time, a deadlock
situation can be caused.
You can enter a deadlock situation if two processes simultaneously try to
acquire locks on two separate databases. Each has locked only one of
the databases, and cannot continue without locking the second. Yet this
will never be freed because it is locked by the other process. If your
processes all ask for their DB files in the same order, this situation
cannot occur.
=head1 OTHER LOCKING MODULES
DB_File
view release on metacpan or search on metacpan
get_av|5.006000|5.003007|p
getc|5.003007||Viu
get_c_backtrace|5.021001||Vi
get_c_backtrace_dump|5.021001||V
get_context|5.006000|5.006000|nu
getc_unlocked|5.003007||Viu
get_cv|5.006000|5.003007|p
get_cvn_flags|5.009005|5.003007|p
get_cvs|5.011000|5.003007|p
getcwd_sv|5.007002|5.007002|
get_db_sub|||iu
PERL_MALLOC_WRAP|5.009002|5.009002|Vn
PerlMem_calloc|5.006000||Viu
PerlMem_free|5.005000||Viu
PerlMem_free_lock|5.006000||Viu
PerlMem_get_lock|5.006000||Viu
PerlMem_is_locked|5.006000||Viu
PerlMem_malloc|5.005000||Viu
PERL_MEMORY_DEBUG_HEADER_SIZE|5.019009||Viu
PerlMemParse_calloc|5.006000||Viu
PerlMemParse_free|5.006000||Viu
PerlMemParse_free_lock|5.006000||Viu
PerlMemParse_get_lock|5.006000||Viu
PerlMemParse_is_locked|5.006000||Viu
PerlMemParse_malloc|5.006000||Viu
PerlMemParse_realloc|5.006000||Viu
PerlMem_realloc|5.005000||Viu
PerlMemShared_calloc|5.006000||Viu
PerlMemShared_free|5.006000||Viu
PerlMemShared_free_lock|5.006000||Viu
PerlMemShared_get_lock|5.006000||Viu
PerlMemShared_is_locked|5.006000||Viu
PerlMemShared_malloc|5.006000||Viu
PerlMemShared_realloc|5.006000||Viu
PERL_MG_UFUNC|5.007001||Viu
Perl_modf|5.006000|5.006000|n
PERL_MULTICONCAT_HEADER_SIZE|5.027006||Viu
putc|5.003007||Viu
put_charclass_bitmap_innards|5.021004||Viu
put_charclass_bitmap_innards_common|5.023008||Viu
put_charclass_bitmap_innards_invlist|5.023008||Viu
put_code_point|5.021004||Viu
putc_unlocked|5.003007||Viu
putenv|5.005000||Viu
put_range|5.019009||Viu
putw|5.003007||Viu
pv_display|5.006000|5.003007|p
pv_escape|5.009004|5.003007|p
DJabberd
view release on metacpan or search on metacpan
doc/rfc3921-notes.txt view on Meta::CPAN
Upon receiving initial presence from the user, the contact's server
MUST deliver the user's presence stanza to the full JIDs
(<contact@example.org/resource>) associated with all of the contact's
available resources, but only if the user is in the contact's roster
with a subscription state of "to" or "both" and the contact has not
blocked inbound presence notifications from the user's bare or full
JID (as defined under Blocking Inbound Presence Notifications
(Section 10.10)).
If the user's server receives a presence stanza of type "error" in
response to the initial presence that it sent to a contact on behalf
doc/rfc3921-notes.txt view on Meta::CPAN
Saint-Andre Standards Track [Page 17]
RFC 3921 XMPP IM October 2004
has not blocked outbound presence notifications, and (3) from whom
the server has not received a presence error during the user's
session (as well as to any of the user's other available resources).
If the presence stanza has a 'type' attribute set to a value of
"unavailable", the user's server MUST broadcast the full XML of that
doc/rfc3921-notes.txt view on Meta::CPAN
resource may become unavailable unexpectedly or may be timed out by
the server. If one of the user's resources becomes unavailable for
any reason (either gracefully or ungracefully), the user's server
MUST broadcast unavailable presence to all contacts (1) that are in
the user's roster with a subscription type of "from" or "both", (2)
to whom the user has not blocked outbound presence, and (3) from whom
the server has not received a presence error during the user's
session; the user's server MUST also send that unavailable presence
stanza to any of the user's other available resources, as well as to
any entities to which the user has sent directed presence during the
user's session for that resource (if the user has not yet sent
doc/rfc3921-notes.txt view on Meta::CPAN
values, the server MUST return to the client a <bad-request/> stanza
error.)
The <item/> element MAY contain one or more child elements that
enable an entity to specify more granular control over which kinds of
stanzas are to be blocked (i.e., rather than blocking all stanzas).
The allowable child elements are:
o <message/> -- blocks incoming message stanzas
o <iq/> -- blocks incoming IQ stanzas
o <presence-in/> -- blocks incoming presence notifications
doc/rfc3921-notes.txt view on Meta::CPAN
As a result of creating and applying the foregoing list, the user
will not receive any communications from, nor send any stanzas to,
any other users.
10.14. Blocked Entity Attempts to Communicate with User
If a blocked entity attempts to send message or presence stanzas to
the user, the user's server SHOULD silently drop the stanza and MUST
NOT return an error to the sending entity.
doc/rfc3921-notes.txt view on Meta::CPAN
Saint-Andre Standards Track [Page 83]
RFC 3921 XMPP IM October 2004
If a blocked entity attempts to send an IQ stanza of type "get" or
"set" to the user, the user's server MUST return to the sending
entity a <service-unavailable/> stanza error, since this is the
standard error code sent from a client that does not understand the
namespace of an IQ get or set. IQ stanzas of other types SHOULD be
silently dropped by the server.
Example: Blocked entity attempts to send IQ get:
<iq type='get'
to='romeo@example.net'
from='tybalt@example.com/pda'
id='probing1'>
<query xmlns='jabber:iq:version'/>
</iq>
Example: Server returns error to blocked entity:
<iq type='error'
from='romeo@example.net'
to='tybalt@example.com/pda'
id='probing1'>
DLM-Client
view release on metacpan or search on metacpan
lib/DLM/Client.pm view on Meta::CPAN
if ( DLM::Client::lock_resource( 'LOCK_NAME', LKM_EXMODE, 0, $lock_id) == 0 ){
print "Locked\n";
}
if ( DLM::Client::unlock_resource($lock_id) == 0 ) {
print "Unlocked\n";
}
=head1 DESCRIPTION
DLM::Client is a direct binding to linux distributed lock manager (DLM is part of the Linux kernel from version 2.6.19) from RedHat.
lib/DLM/Client.pm view on Meta::CPAN
0 is returned if the call completed successfully. If not, -1 is returned and $! is set to one of the
following:
EINVAL An invalid parameter was passed to the call (eg bad lock mode or flag)
ENOMEM A (kernel) memory allocation failed
EAGAIN LKF_NOQUEUE was requested and the lock could not be granted
EBUSY The lock is currently being locked or converted
EFAULT The userland buffer could not be read/written by the kernel (this indicates a library problem)
=head2 unlock_resource($lockid);
Unlocks the resource.
lib/DLM/Client.pm view on Meta::CPAN
=head3 Return codes:
0 is returned if the call completed successfully. If not, -1 is returned and errno is set to one of the
following:
EINVAL An invalid parameter was passed to the call (eg bad lock mode or flag)
EINPROGRESS The lock is already being unlocked
EBUSY The lock is currently being locked or converted
=head2 Example
my $lockid;
my $status = lock_resource("mylock", LKM_EXMODE, 0, $lockid);
DMS-Parser-XS
view release on metacpan or search on metacpan
get_av|5.006000|5.003007|p
getc|5.003007||Viu
get_c_backtrace|5.021001||Vi
get_c_backtrace_dump|5.021001||V
get_context|5.006000|5.006000|nu
getc_unlocked|5.003007||Viu
get_cv|5.006000|5.003007|p
get_cvn_flags|5.009005|5.003007|p
get_cvs|5.011000|5.003007|p
getcwd_sv|5.007002|5.007002|
get_db_sub|||iu
PERL_MALLOC_WRAP|5.009002|5.009002|Vn
PerlMem_calloc|5.006000||Viu
PerlMem_free|5.005000||Viu
PerlMem_free_lock|5.006000||Viu
PerlMem_get_lock|5.006000||Viu
PerlMem_is_locked|5.006000||Viu
PerlMem_malloc|5.005000||Viu
PERL_MEMORY_DEBUG_HEADER_SIZE|5.019009||Viu
PerlMemParse_calloc|5.006000||Viu
PerlMemParse_free|5.006000||Viu
PerlMemParse_free_lock|5.006000||Viu
PerlMemParse_get_lock|5.006000||Viu
PerlMemParse_is_locked|5.006000||Viu
PerlMemParse_malloc|5.006000||Viu
PerlMemParse_realloc|5.006000||Viu
PerlMem_realloc|5.005000||Viu
PerlMemShared_calloc|5.006000||Viu
PerlMemShared_free|5.006000||Viu
PerlMemShared_free_lock|5.006000||Viu
PerlMemShared_get_lock|5.006000||Viu
PerlMemShared_is_locked|5.006000||Viu
PerlMemShared_malloc|5.006000||Viu
PerlMemShared_realloc|5.006000||Viu
PERL_MG_UFUNC|5.007001||Viu
Perl_modf|5.006000|5.006000|n
PERL_MULTICONCAT_HEADER_SIZE|5.027006||Viu
putc|5.003007||Viu
put_charclass_bitmap_innards|5.021004||Viu
put_charclass_bitmap_innards_common|5.023008||Viu
put_charclass_bitmap_innards_invlist|5.023008||Viu
put_code_point|5.021004||Viu
putc_unlocked|5.003007||Viu
putenv|5.005000||Viu
put_range|5.019009||Viu
putw|5.003007||Viu
pv_display|5.006000|5.003007|p
pv_escape|5.009004|5.003007|p
DMS-XS-Parser
view release on metacpan or search on metacpan
get_av|5.006000|5.003007|p
getc|5.003007||Viu
get_c_backtrace|5.021001||Vi
get_c_backtrace_dump|5.021001||V
get_context|5.006000|5.006000|nu
getc_unlocked|5.003007||Viu
get_cv|5.006000|5.003007|p
get_cvn_flags|5.009005|5.003007|p
get_cvs|5.011000|5.003007|p
getcwd_sv|5.007002|5.007002|
get_db_sub|||iu
PERL_MALLOC_WRAP|5.009002|5.009002|Vn
PerlMem_calloc|5.006000||Viu
PerlMem_free|5.005000||Viu
PerlMem_free_lock|5.006000||Viu
PerlMem_get_lock|5.006000||Viu
PerlMem_is_locked|5.006000||Viu
PerlMem_malloc|5.005000||Viu
PERL_MEMORY_DEBUG_HEADER_SIZE|5.019009||Viu
PerlMemParse_calloc|5.006000||Viu
PerlMemParse_free|5.006000||Viu
PerlMemParse_free_lock|5.006000||Viu
PerlMemParse_get_lock|5.006000||Viu
PerlMemParse_is_locked|5.006000||Viu
PerlMemParse_malloc|5.006000||Viu
PerlMemParse_realloc|5.006000||Viu
PerlMem_realloc|5.005000||Viu
PerlMemShared_calloc|5.006000||Viu
PerlMemShared_free|5.006000||Viu
PerlMemShared_free_lock|5.006000||Viu
PerlMemShared_get_lock|5.006000||Viu
PerlMemShared_is_locked|5.006000||Viu
PerlMemShared_malloc|5.006000||Viu
PerlMemShared_realloc|5.006000||Viu
PERL_MG_UFUNC|5.007001||Viu
Perl_modf|5.006000|5.006000|n
PERL_MULTICONCAT_HEADER_SIZE|5.027006||Viu
putc|5.003007||Viu
put_charclass_bitmap_innards|5.021004||Viu
put_charclass_bitmap_innards_common|5.023008||Viu
put_charclass_bitmap_innards_invlist|5.023008||Viu
put_code_point|5.021004||Viu
putc_unlocked|5.003007||Viu
putenv|5.005000||Viu
put_range|5.019009||Viu
putw|5.003007||Viu
pv_display|5.006000|5.003007|p
pv_escape|5.009004|5.003007|p
DNS-BL
view release on metacpan or search on metacpan
lib/DNS/BL/cmds/connect/db.pm view on Meta::CPAN
=head1 DESCRIPTION
This module implements the connection to a DB backend where C<DNS::BL>
data will be stored. On each call to this class' methods, a hash will
be C<tie()>d and then C<untie()>d. This guarantees that the underlying
DB structure will be unlocked and available for other commands that
may, for instance, replace or manipulate the hash "from under us".
The following methods are implemented by this module:
=over
DNS-Unbound
view release on metacpan or search on metacpan
easyxs/ppport.h view on Meta::CPAN
get_av|5.006000|5.003007|p
getc|5.003007||Viu
get_c_backtrace|5.021001||Vi
get_c_backtrace_dump|5.021001||V
get_context|5.006000|5.006000|nu
getc_unlocked|5.003007||Viu
get_cv|5.006000|5.003007|p
get_cvn_flags|5.009005|5.003007|p
get_cvs|5.011000|5.003007|p
getcwd_sv|5.007002|5.007002|
get_db_sub|||iu
easyxs/ppport.h view on Meta::CPAN
PERL_MALLOC_WRAP|5.009002|5.009002|Vn
PerlMem_calloc|5.006000||Viu
PerlMem_free|5.005000||Viu
PerlMem_free_lock|5.006000||Viu
PerlMem_get_lock|5.006000||Viu
PerlMem_is_locked|5.006000||Viu
PerlMem_malloc|5.005000||Viu
PERL_MEMORY_DEBUG_HEADER_SIZE|5.019009||Viu
PerlMemParse_calloc|5.006000||Viu
PerlMemParse_free|5.006000||Viu
PerlMemParse_free_lock|5.006000||Viu
PerlMemParse_get_lock|5.006000||Viu
PerlMemParse_is_locked|5.006000||Viu
PerlMemParse_malloc|5.006000||Viu
PerlMemParse_realloc|5.006000||Viu
PerlMem_realloc|5.005000||Viu
PerlMemShared_calloc|5.006000||Viu
PerlMemShared_free|5.006000||Viu
PerlMemShared_free_lock|5.006000||Viu
PerlMemShared_get_lock|5.006000||Viu
PerlMemShared_is_locked|5.006000||Viu
PerlMemShared_malloc|5.006000||Viu
PerlMemShared_realloc|5.006000||Viu
PERL_MG_UFUNC|5.007001||Viu
Perl_modf|5.006000|5.006000|n
PERL_MULTICONCAT_HEADER_SIZE|5.027006||Viu
easyxs/ppport.h view on Meta::CPAN
putc|5.003007||Viu
put_charclass_bitmap_innards|5.021004||Viu
put_charclass_bitmap_innards_common|5.023008||Viu
put_charclass_bitmap_innards_invlist|5.023008||Viu
put_code_point|5.021004||Viu
putc_unlocked|5.003007||Viu
putenv|5.005000||Viu
put_range|5.019009||Viu
putw|5.003007||Viu
pv_display|5.006000|5.003007|p
pv_escape|5.009004|5.003007|p
DSlib
view release on metacpan or search on metacpan
lib/DS/TypeSpec.pm view on Meta::CPAN
sub field_names {
my( $self, $fields ) = @_;
return keys %{$self->{fields}};
}
sub keys_locked {
my( $self, $keys_locked ) = @_;
my $result = 1;
if( $keys_locked ) {
$self->{keys_locked} = $keys_locked ? 1 : 0;
} else {
$keys_locked = $self->{keys_locked};
}
return $result;
}
sub values_readonly {
DTA-CAB
view release on metacpan or search on metacpan
CAB/Queue/File.pm view on Meta::CPAN
## Package DTA::CAB::Queue::File::Locked
package DTA::CAB::Queue::File::Locked;
use Fcntl qw(:flock);
our @ISA = qw(DTA::CAB::Queue::File);
sub _locked {
my $subname = shift;
my $supersub = DTA::CAB::Queue::File->can($subname);
die(__PACKAGE__, "::_locked(): no superclass subroutine for '$subname'") if (!$supersub);
return sub {
my (@rc);
flock($_[0]{queue},LOCK_EX) if ($_[0]{queue});
if (wantarray) {
@rc = $supersub->(@_);
CAB/Queue/File.pm view on Meta::CPAN
flock($_[0]{queue},LOCK_UN) if ($_[0]{queue});
return wantarray ? @rc : $rc[0];
};
}
*enq = _locked('enq');
*deq = _locked('deq');
*peek = _locked('peek');
*reset = _locked('reset');
#*close = _locked('close');
1; ##-- be happy
__END__
DTL-Fast
view release on metacpan or search on metacpan
timetheese/tpl/stackoverflow_homepage.html view on Meta::CPAN
</div>
</div>
<div class="question-summary narrow" id="question-summary-15327979">
<div onclick="window.location.href='/questions/15327979/ajaxcontroltoolkit-dll-constantly-getting-locked-for-checkout'" class="cp">
<div class="votes">
<div class="mini-counts">0</div>
<div>votes</div>
</div>
<div class="status unanswered">
timetheese/tpl/stackoverflow_homepage.html view on Meta::CPAN
<div>views</div>
</div>
</div>
<div class="summary">
<h3><a href="/questions/15327979/ajaxcontroltoolkit-dll-constantly-getting-locked-for-checkout" class="question-hyperlink" title="We reference the AjaxControlToolkit.dll in our ASP.net 4.0 Web Site project. Recently we started getting an erro...
<div class="tags t-aspûnet t-visual-studio-2010 t-tfs2010">
<a href="/questions/tagged/asp.net" class="post-tag" title="show questions tagged 'asp.net'" rel="tag">asp.net</a> <a href="/questions/tagged/visual-studio-2010" class="post-tag" title="show questions tagged 'visual-studio-2010'" rel="tag...
</div>
<div class="started">
<a href="/questions/15327979/ajaxcontroltoolkit-dll-constantly-getting-locked-for-checkout" class="started-link"><span title="2013-03-10 21:38:06Z" class="relativetime">14m ago</span></a>
<a href="/users/1624069/frank-thomas">Frank Thomas</a> <span class="reputation-score" title="reputation score" dir="ltr">808</span>
</div>
</div>
</div>
Daemon-Generic
view release on metacpan or search on metacpan
lib/Daemon/Generic.pm view on Meta::CPAN
print "Configuration looks okay\n" if $do eq 'check';
my $pidfile = $self->{gd_pidfile};
my $killed = 0;
my $locked = 0;
if (-e $pidfile) {
if ($locked = lock($pidfile, undef, 'nonblocking')) {
# old process is dead
if ($do eq 'status') {
print "$self->{gd_progname} dead\n";
exit 1;
}
lib/Daemon/Generic.pm view on Meta::CPAN
my $oldpid = read_file($pidfile);
chomp($oldpid);
if ($oldpid) {
if ($do eq 'stop' or $do eq 'restart') {
$killed = $self->gd_kill($oldpid);
$locked = lock($pidfile);
if ($do eq 'stop') {
unlink($pidfile);
exit;
}
} elsif ($do eq 'reload') {
lib/Daemon/Generic.pm view on Meta::CPAN
} elsif ($do eq 'start' || $do eq 'debug') {
print "\u$self->{gd_progname} is already running (pid $oldpid)\n";
exit; # according to LSB, this is no error
}
} else {
$self->gd_error("Pid file $pidfile is invalid but locked, exiting\n");
}
}
} else {
$locked = lock($pidfile, undef, 'nonblocking')
or die "Could not lock pid file $pidfile: $!";
}
if ($do eq 'reload' || $do eq 'stop' || $do eq 'check' || ($do eq 'restart' && ! $killed)) {
print "No $self->{gd_progname} running\n";
lib/Daemon/Generic.pm view on Meta::CPAN
$self->gd_check($pidfile);
exit
}
unless ($do eq 'reload' || $do eq 'restart' || $do eq 'start' || $do eq 'debug') {
$self->gd_other_cmd($do, $locked);
}
unless ($self->{gd_foreground} || $do eq 'debug') {
$self->gd_daemonize;
}
$locked or lock($pidfile, undef, 'nonblocking')
or die "Could not lock PID file $pidfile: $!";
write_file($pidfile, "$$\n");
print STDERR "Starting up...\n";
Daemon-Shutdown
view release on metacpan or search on metacpan
lib/Daemon/Shutdown/Monitor/smbstatus.pm view on Meta::CPAN
Monitor samba file locks
=head1 DESCRIPTION
Uses C<smbstatus> to look for locked files every "loop_sleep". If no files are locked,
the flag "trigger_pending" is set. If a further "trigger_time" seconds
pass and all disks are still in a spun down state, the trigger is sent back to the parent
process (return 1).
=head1 METHODS
( run in 2.275 seconds using v1.01-cache-2.11-cpan-800906f7e73 )