lucy-user mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From Marvin Humphrey <mar...@rectangular.com>
Subject Re: [lucy-user] Indexer introspection -- has commit already been called?
Date Thu, 08 Sep 2011 21:36:31 GMT
On Thu, Sep 08, 2011 at 11:47:36AM -0700, Ashley Pond V wrote:
> I have a Moose class that is using attribute traits to automatically
> bundle up a lot of ordinary but complex KinoSearch/Lucy behavior.
> Something blocking me from automating the indexer -> add_doc x N ->
> commit cycle is that there seems to be no way (from the Perl
> interface) to get an indexer to say whether it has already been
> committed or not. The idea being the meta object has indexers,
> searchers, and the schema embedded in it so it knows how to compose
> all kinds of things like add_doc. For it to do it sanely it must know
> its current indexers state for every meta->add_doc call so it can
> reuse its indexer or instantiate a new one.

Sounds vaguely similar to the code in LucyX::Simple, so maybe check that out
if you're looking for ideas.
 
> Is there a way (or a best practice if there is more than one) for
> getting an index to give its status? It appears that ->commit clears
> the index lock so I suppose the short form for knowing if an indexer
> hasn't been committed is to see if it still has a lock. But there is
> more than one kind of lock and it also seems short on perl-side
> introspection so I'm guessing it's the wrong way to go.

You could check for the lock with something like this:

    my $folder = Lucy::Store::FSFolder->new( 
        path => '/path/to/index', 
    );
    my $lock_factory = Lucy::Store::LockFactory->new(
        folder => $folder,
        host   => $hostname,
    );
    my $write_lock = $lock_factory->make_lock(
        name     => 'write',
        timeout  => 1000,
        interval => 100,
    );
    my $locked = $write_lock->is_locked;

However, it seems to me that a better solution for your specific problem is to
subclass Indexer and use an inside-out field to track its state.

This code sample adds a method, $indexer->committed, which returns true after
$indexer->commit has been called:
    
    package MyIndexer;
    use base qw( Lucy::Index::Indexer );

    our %committed;
    
    sub new {
        my $self = shift->SUPER::new(@_);
        $committed{$self} = 0;
    }

    sub commit {
        my $self = shift;
        $self->SUPER::commit(@_);
        $committed{$self} = 1;
    }

    sub DESTROY {
        my $self = shift;
        delete $committed{$self};
        $self->SUPER::DESTROY;
    }

    sub committed {
        my $self = shift;
        return $committed{$self};
    }

More sophisticated tracking could be accomplished by storing something other
than a boolean value.

Hope this helps,

Marvin Humphrey


Mime
View raw message