View | Details | Raw Unified | Return to bug 11081
Collapse All | Expand All

(-)a/C4/Installer/PerlDependencies.pm (+15 lines)
Lines 569-574 our $PERL_DEPS = { Link Here
569
        'required' => '0',
569
        'required' => '0',
570
        'min_ver'  => '0.30',
570
        'min_ver'  => '0.30',
571
    },
571
    },
572
    'MooseX::Getopt' => {
573
        'usage'    => 'Command line scripts',
574
        'required' => '0',
575
        'min_ver'  => '0.46',
576
    },
577
    'MooseX::RW' => {
578
        'usage'    => 'Command line scripts',
579
        'required' => '0',
580
        'min_ver'  => '0.003',
581
    },
572
    'String::RewritePrefix' => {
582
    'String::RewritePrefix' => {
573
        'usage'    => 'Core',
583
        'usage'    => 'Core',
574
        'required' => '0',
584
        'required' => '0',
Lines 629-634 our $PERL_DEPS = { Link Here
629
        'required' => '0',
639
        'required' => '0',
630
        'min_ver'  => '2.13',
640
        'min_ver'  => '2.13',
631
    },
641
    },
642
    'AnyEvent::Processor' => {
643
        'usage'    => 'Command line scripts',
644
        'required' => '0',
645
        'min_ver'  => '0.003',
646
    },
632
    'Moose' => {
647
    'Moose' => {
633
        'usage'    => 'Core',
648
        'usage'    => 'Core',
634
        'required' => '0',
649
        'required' => '0',
(-)a/Koha/Indexer/Daemon.pm (+121 lines)
Line 0 Link Here
1
package Koha::Indexer::Daemon;
2
3
use Moose;
4
5
use Modern::Perl;
6
use utf8;
7
use AnyEvent;
8
use Koha::Indexer::Indexing;
9
use C4::Context;
10
11
with 'MooseX::Getopt';
12
13
14
has name => ( is => 'rw', isa => 'Str' );
15
16
17
=attr directory($directory_name)
18
19
Location of the directory where to export biblio/authority records before
20
sending them to Zebra indexer.
21
22
=cut
23
24
has directory => ( is => 'rw', isa => 'Str' );
25
26
27
=attr timeout($seconds)
28
29
Number of seconds between indexing.
30
31
=cut
32
33
has timeout => (
34
    is      => 'rw',
35
    isa     => 'Int',
36
    default => 60,
37
);
38
39
40
=attr verbose(0|1)
41
42
Task verbosity.
43
44
=cut
45
46
has verbose => ( is => 'rw', isa => 'Bool', default => 0 );
47
48
49
50
sub BUILD {
51
    my $self = shift;
52
53
    say "Starting Koha Indexer Daemon";
54
55
    $self->name( C4::Context->config('database') );
56
57
    my $idle = AnyEvent->timer(
58
        after    => $self->timeout,
59
        interval => $self->timeout,
60
        cb       => sub { $self->index_zebraqueue(); }
61
    );
62
    AnyEvent->condvar->recv;
63
}
64
65
66
sub index_zebraqueue {
67
    my $self = shift;
68
69
    my $dbh = C4::Context->dbh();
70
    my $sql = " SELECT COUNT(*), server 
71
                FROM zebraqueue 
72
                WHERE done = 0
73
                GROUP BY server ";
74
    my $sth = $dbh->prepare($sql);
75
    $sth->execute();
76
    my %count = ( biblio => 0, authority => 0 );
77
    while ( my ($count, $server) = $sth->fetchrow ) {
78
        $server =~ s/server//g;
79
        $count{$server} = $count;
80
    }
81
82
    say "[", $self->name, "] Index biblio (", $count{biblio}, ") authority (",
83
        $count{authority}, ")";
84
85
    for my $source (qw/biblio authority/) {
86
        next unless $count{$source};
87
        my $indexer = Koha::Indexer::Indexing->new(
88
            source      => $source,
89
            select      => 'queue',
90
            blocking    => 1,
91
            keep        => 1,
92
            verbose     => $self->verbose,
93
        );
94
        $indexer->directory($self->directory) if $self->directory;
95
        $indexer->run();
96
    }
97
}
98
99
no Moose;
100
__PACKAGE__->meta->make_immutable;
101
1;
102
103
__END__
104
=pod 
105
106
=head1 SYNOPSIS
107
108
 # Index Koha queued biblio/authority records every minute.
109
 # KOHA_CONF environment variable is used to find which Koha
110
 # instance to use.
111
 # Records are exported from Koha DB into files located in
112
 # the current directory
113
 my $daemon = Koha::Indexer::Daemon->new();
114
115
 my $daemon = Koha::Indexer::Daemon->new(
116
    timeout   => 20,
117
    directory => '/home/koha/mylib/tmp',
118
    verbose   => 1 );
119
120
=cut
121
(-)a/Koha/Indexer/Indexing.pm (+190 lines)
Line 0 Link Here
1
package Koha::Indexer::Indexing;
2
3
use Moose;
4
5
use Modern::Perl;
6
use utf8;
7
use Carp;
8
use Koha::Indexer::RecordReader;
9
use Koha::Indexer::RecordWriter;
10
use AnyEvent::Processor::Conversion;
11
use File::Path;
12
use IO::File;
13
use C4::Context;
14
15
16
with 'MooseX::Getopt';
17
18
19
has source => (
20
    is      => 'rw',
21
    isa     => 'Koha::RecordType',
22
    default => 'biblio'
23
);
24
25
has select => (
26
    is       => 'rw',
27
    isa      => 'Koha::RecordSelect',
28
    required => 1,
29
    default  => 'all',
30
);
31
32
has directory => (
33
    is      => 'rw',
34
    isa     => 'Str',
35
    default => './koha-index',
36
);
37
38
has keep => ( is => 'rw', isa => 'Bool', default => 0 );
39
40
has verbose => ( is => 'rw', isa => 'Bool', default => 0 );
41
42
has help => (
43
    is      => 'rw',
44
    isa     => 'Bool',
45
    default => 0,
46
    traits  => [ 'NoGetopt' ],
47
);
48
49
has blocking => (
50
    is      => 'rw',
51
    isa     => 'Bool',
52
    default => 0,
53
    traits  => [ 'NoGetopt' ],
54
);
55
56
57
=method run
58
59
Runs the indexing task.
60
61
=cut
62
63
sub run {
64
    my $self = shift;
65
66
    # Is it a full indexing of all Koha DB records?
67
    my $is_full_indexing = $self->select =~ /all/i;
68
69
    # Is it biblio indexing (if not it's authority)
70
    my $is_biblio_indexing = $self->source =~ /biblio/i;
71
72
    # STEP 1: All biblio records are exported in a directory
73
74
    unless ( -d $self->directory ) {
75
        mkdir $self->directory
76
            or die "Unable to create directory: " . $self->directory;
77
    }
78
    my $from_dir = $self->directory . "/" . $self->source;
79
    mkdir $from_dir;
80
    for my $dir ( ( "$from_dir/update", "$from_dir/delete") ) {
81
        rmtree( $dir ) if -d $dir;
82
        mkdir $dir;
83
    }
84
85
    # DOM indexing? otherwise GRS-1
86
    my $is_dom = $self->source eq 'biblio'
87
                 ? 'zebra_bib_index_mode'
88
                 : 'zebra_auth_index_mode';
89
    $is_dom = C4::Context->config($is_dom) || '';
90
    $is_dom = $is_dom =~ /dom/i ? 1 : 0;
91
92
    # STEP 1.1: Records to update
93
    say "Exporting records to update" if $self->verbose;
94
    my $exporter = AnyEvent::Processor::Conversion->new(
95
        reader => Koha::Indexer::RecordReader->new(
96
            source => $self->source,
97
            select => $is_full_indexing ? 'all' : 'queue_update',
98
            xml    => '1'
99
        ),
100
        writer => Koha::Indexer::RecordWriter->new(
101
            fh => IO::File->new( "$from_dir/update/records", '>:encoding(utf8)' ),
102
            valid => $is_dom ),
103
        blocking    => $self->blocking,
104
        verbose     => $self->verbose,
105
    );
106
    $exporter->run();
107
108
    # STEP 1.2: Record to delete, if zebraqueue
109
    if ( ! $is_full_indexing ) {
110
        say "Exporting records to delete" if $self->verbose;
111
        $exporter = AnyEvent::Processor::Conversion->new(
112
            reader => Koha::Indexer::RecordReader->new(
113
                source => $self->source,
114
                select => 'queue_delete',
115
                xml    => '1'
116
            ),
117
            writer => Koha::Indexer::RecordWriter->new(
118
                fh => IO::File->new( "$from_dir/delete/records", '>:encoding(utf8)' ),
119
                valid => $is_dom ),
120
            blocking    => $self->blocking,
121
            verbose     => $self->verbose,
122
        );
123
        $exporter->run();
124
    }
125
126
    # STEP 2: Run zebraidx
127
128
    my $cmd;
129
    my $zconfig  = C4::Context->zebraconfig(
130
       $is_biblio_indexing ? 'biblioserver' : 'authorityserver')->{config};
131
    my $db_name  = $is_biblio_indexing ? 'biblios' : 'authorities';
132
    my $cmd_base = "zebraidx -c " . $zconfig;
133
    $cmd_base   .= " -n" if $is_full_indexing; # No shadow: no indexing daemon
134
    $cmd_base   .= $self->verbose ? " -v warning,log" : " -v none";
135
    $cmd_base   .= " -g marcxml";
136
    $cmd_base   .= " -d $db_name";
137
138
    if ( $is_full_indexing ) {
139
        $cmd = "$cmd_base init";
140
        say $cmd if $self->verbose;
141
        system( $cmd );
142
    }
143
144
    $cmd = "$cmd_base update $from_dir/update";
145
    say $cmd if $self->verbose;
146
    system( $cmd );
147
148
    if ( ! $is_full_indexing ) {
149
        $cmd = "$cmd_base adelete $from_dir/delete";
150
        say $cmd if $self->verbose;
151
        system( $cmd );
152
        my $cmd = "$cmd_base commit";
153
        say $cmd if $self->verbose;
154
        system( $cmd );
155
    }
156
157
    rmtree( $self->directory ) unless $self->keep;
158
}
159
160
161
no Moose;
162
__PACKAGE__->meta->make_immutable;
163
164
__END__
165
=pod
166
167
=HEAD1 SYNOPSIS
168
169
 my $indexer = Koha::Indexer->new(
170
   source => 'biblio',
171
   select => 'queue'
172
 );
173
 $indexer->run();
174
175
 my $indexer = Koha::Indexer->new(
176
   source    => 'authority',
177
   select    => 'all',
178
   directory => '/tmp',
179
   verbose   => 1,
180
 );
181
 $indexer->run();
182
183
=HEAD1 DESCRIPTION
184
185
Indexes Koha biblio/authority records, full indexing or queued record indexing.
186
187
=cut
188
189
1;
190
(-)a/Koha/Indexer/RecordReader.pm (+270 lines)
Line 0 Link Here
1
package Koha::Indexer::RecordReader;
2
3
use Moose;
4
5
with 'MooseX::RW::Reader';
6
7
8
use Modern::Perl;
9
use utf8;
10
use Moose::Util::TypeConstraints;
11
use MARC::Record;
12
use MARC::File::XML;
13
use C4::Context;
14
use C4::Biblio;
15
use C4::Items;
16
17
18
subtype 'Koha::RecordType'
19
    => as 'Str',
20
    => where { /biblio|authority/i },
21
    => message { "$_ is not a valid Koha::RecordType (biblio or authority" };
22
23
subtype 'Koha::RecordSelect'
24
    => as 'Str',
25
    => where { /all|queue|queue_update|queue_delete/ },
26
    => message {
27
        "$_ is not a valide Koha::RecordSelect " .
28
        "(all or queue or queue_update or queue_delete)"
29
    };
30
31
32
has source => (
33
    is       => 'rw',
34
    isa      => 'Koha::RecordType',
35
    required => 1,
36
    default  => 'biblio',
37
);
38
39
has select => (
40
    is       => 'rw',
41
    isa      => 'Koha::RecordSelect',
42
    required => 1,
43
    default  => 'all',
44
);
45
46
has xml => ( is => 'rw', isa => 'Bool', default => '0' );
47
48
has sth => ( is => 'rw' );
49
50
# Last returned record biblionumber;
51
has id => ( is => 'rw' );
52
53
# Items extraction required
54
has itemsextraction => ( is => 'rw', isa => 'Bool', default => 0 );
55
56
# Biblio records normalizer, if necessary
57
has normalizer => ( is => 'rw' );
58
59
# Read all records? (or queued records)
60
has allrecords => ( is => 'rw', isa => 'Bool', default => 1 );
61
62
# Mark as done an entry is Zebra queue
63
has sth_queue_done => ( is => 'rw' );
64
65
# Items tag
66
has itemtag => ( is => 'rw' );
67
68
# Las returned record frameworkcode
69
# FIXME: a KohaRecord class should contain this information 
70
has frameworkcode => ( is => 'rw', isa => 'Str' );
71
72
73
sub BUILD {
74
    my $self = shift;
75
    my $dbh  = C4::Context->dbh();
76
77
    # Tag containing items
78
    my ( $itemtag, $itemsubfield ) = GetMarcFromKohaField("items.itemnumber",'');
79
    $self->itemtag($itemtag);
80
81
    # Koha version => items extraction if >= 3.4
82
    my $version = C4::Context::KOHAVERSION();
83
    $self->itemsextraction( $version ge '3.04' );
84
85
    if ( $version ge '3.09' && $self->source =~ /biblio/i &&
86
         C4::Context->preference('IncludeSeeFromInSearches') )
87
    {
88
        require Koha::RecordProcessor;
89
        my $normalizer = Koha::RecordProcessor->new( { filters => 'EmbedSeeFromHeadings' } );
90
        $self->normalizer($normalizer);
91
        # Necessary for as_xml method
92
        MARC::File::XML->default_record_format( C4::Context->preference('marcflavour') );
93
    }
94
95
    my $operation = $self->select =~ /update/i
96
                    ? 'specialUpdate'
97
                    : 'recordDelete';
98
    $self->allrecords( $self->select =~ /all/i ? 1 : 0 );
99
    my $sql =
100
        $self->source =~ /biblio/i
101
            ? $self->allrecords
102
                ? "SELECT NULL, biblionumber FROM biblio"
103
                : "SELECT id, biblio_auth_number FROM zebraqueue
104
                   WHERE server = 'biblioserver'
105
                     AND operation = '$operation' AND done = 0"
106
            : $self->allrecords
107
                ? "SELECT NULL, authid FROM auth_header"
108
                : "SELECT id, biblio_auth_number FROM zebraqueue
109
                   WHERE server = 'authorityserver'
110
                     AND operation = '$operation' AND done = 0";
111
    my $sth = $dbh->prepare( $sql );
112
    $sth->execute();
113
    $self->sth( $sth );
114
115
    unless ( $self->allrecords ) {
116
        $self->sth_queue_done( $dbh->prepare(
117
            "UPDATE zebraqueue SET done=1 WHERE id=?" ) );
118
    }
119
    
120
    __PACKAGE__->meta->add_method( 'get' =>
121
        $self->source =~ /biblio/i
122
            ? $self->xml && !$self->normalizer
123
              ? \&get_biblio_xml
124
              : \&get_biblio_marc
125
            : $self->xml
126
              ? \&get_auth_xml
127
              : \&get_auth_marc
128
    );
129
}
130
131
132
133
sub read {
134
    my $self = shift;
135
    while ( my ($queue_id, $id) = $self->sth->fetchrow ) {
136
        # Suppress entry in zebraqueue table
137
        $self->sth_queue_done->execute($queue_id) if $queue_id;
138
        if ( my $record = $self->get( $id ) ) {
139
            $record = $self->normalizer->process($record) if $self->normalizer;
140
            $self->count($self->count+1);
141
            $self->id( $id );
142
            return $record;
143
        }
144
    }
145
    return 0;
146
}
147
148
149
150
sub get_biblio_xml {
151
    my ( $self, $id ) = @_;
152
    my$dbh = C4::Context->dbh();
153
    my $sth = $dbh->prepare(
154
        "SELECT marcxml FROM biblioitems WHERE biblionumber=? ");
155
    $sth->execute( $id );
156
    my ($marcxml) = $sth->fetchrow;
157
158
    # If biblio isn't found in biblioitems, it is searched in
159
    # deletedbilioitems. Usefull for delete Zebra requests
160
    unless ( $marcxml ) {
161
        $sth = $dbh->prepare(
162
            "SELECT marcxml FROM deletedbiblioitems WHERE biblionumber=? ");
163
        $sth->execute( $id );
164
        ($marcxml) = $sth->fetchrow;
165
    }
166
167
    # Items extraction if Koha v3.4 and above
168
    # FIXME: It slows down drastically biblio records export
169
    if ( $self->itemsextraction ) {
170
        my @items = @{ $dbh->selectall_arrayref(
171
            "SELECT * FROM items WHERE biblionumber=$id",
172
            {Slice => {} } ) };
173
        if (@items){
174
            my $record = MARC::Record->new;
175
            $record->encoding('UTF-8');
176
            my @itemsrecord;
177
            foreach my $item (@items) {
178
                my $record = Item2Marc($item, $id);
179
                push @itemsrecord, $record->field($self->itemtag);
180
            }
181
            $record->insert_fields_ordered(@itemsrecord);
182
            my $itemsxml = $record->as_xml_record();
183
            $marcxml =
184
                substr($marcxml, 0, length($marcxml)-10) .
185
                substr($itemsxml, index($itemsxml, "</leader>\n", 0) + 10);
186
        }
187
    }
188
    return $marcxml;
189
}
190
191
192
# Get biblio record, if the record doesn't exist in biblioitems, it is searched
193
# in deletedbiblioitems.
194
sub get_biblio_marc {
195
    my ( $self, $id ) = @_;
196
197
    my $dbh = C4::Context->dbh();
198
    my $sth = $dbh->prepare(
199
        "SELECT marcxml FROM biblioitems WHERE biblionumber=? ");
200
    $sth->execute( $id );
201
    my ($marcxml) = $sth->fetchrow;
202
203
    unless ( $marcxml ) {
204
        $sth = $dbh->prepare(
205
            "SELECT marcxml FROM deletedbiblioitems WHERE biblionumber=? ");
206
        $sth->execute( $id );
207
        ($marcxml) = $sth->fetchrow;
208
    }
209
210
    $marcxml =~ s/[^\x09\x0A\x0D\x{0020}-\x{D7FF}\x{E000}-\x{FFFD}\x{10000}-\x{10FFFF}]//g;
211
    my $record = MARC::Record->new();
212
    if ($marcxml) {
213
        $record = eval { 
214
            MARC::Record::new_from_xml( $marcxml, "utf8" ) };
215
        if ($@) { warn " problem with: $id : $@ \n$marcxml"; }
216
217
        # Items extraction if Koha v3.4 and above
218
        # FIXME: It slows down drastically biblio records export
219
        if ( $self->itemsextraction ) {
220
            my @items = @{ $dbh->selectall_arrayref(
221
                "SELECT * FROM items WHERE biblionumber=$id",
222
                {Slice => {} } ) };
223
            if (@items){
224
                my @itemsrecord;
225
                foreach my $item (@items) {
226
                    my $record = Item2Marc($item, $id);
227
                    push @itemsrecord, $record->field($self->itemtag);
228
                }
229
                $record->insert_fields_ordered(@itemsrecord);
230
            }
231
        }
232
        return $record;
233
    }
234
    return;
235
}
236
237
238
sub get_auth_xml {
239
    my ( $self, $id ) = @_;
240
241
    my $dbh = C4::Context->dbh();
242
    my $sth = $dbh->prepare(
243
        "select marcxml from auth_header where authid=? "  );
244
    $sth->execute( $id );
245
    my ($xml) = $sth->fetchrow;
246
247
    # If authority isn't found we build a mimimalist record
248
    # Usefull for delete Zebra requests
249
    unless ( $xml ) {
250
        return
251
            "<record 
252
               xmlns:xsi=\"http://www.w3.org/2001/XMLSchema-instance\"
253
               xsi:schemaLocation=\"http://www.loc.gov/MARC21/slim http://www.loc.gov/standards/marcxml/schema/MARC21slim.xsd\"
254
               xmlns=\"http://www.loc.gov/MARC21/slim\">
255
             <leader>                        </leader>
256
             <controlfield tag=\"001\">$id</controlfield>
257
             </record>\n";
258
    }
259
260
    my $new_xml = '';
261
    foreach ( split /\n/, $xml ) {
262
        next if /^<collection|^<\/collection/;
263
        $new_xml .= "$_\n";
264
    }
265
    return $new_xml;
266
}
267
268
269
no Moose;
270
1;
(-)a/Koha/Indexer/RecordWriter.pm (+59 lines)
Line 0 Link Here
1
package Koha::Indexer::RecordWriter;
2
use Moose;
3
4
with 'MooseX::RW::Writer::File';
5
6
7
use Carp;
8
use MARC::Batch;
9
use MARC::Record;
10
use MARC::File::XML;
11
12
13
# Is XML Stream a valid marcxml
14
# By default no => no <collection> </collection>
15
has valid => (
16
    is => 'rw',
17
    isa => 'Bool',
18
    default => 0,
19
);
20
21
22
sub begin {
23
    my $self = shift;
24
    if ( $self->valid ) {
25
        my $fh = $self->fh;
26
        print $fh '<?xml version="1.0" encoding="UTF-8"?>', "\n", '<collection>', "\n";
27
    }
28
}
29
30
31
sub end {
32
    my $self = shift;
33
    my $fh = $self->fh;
34
    if ( $self->valid ) {
35
        print $fh '</collection>', "\n";
36
    }
37
    $fh->flush();
38
}
39
40
41
42
#
43
# Sent record is rather a MARC::Record object or an marcxml string
44
#
45
sub write {
46
    my ($self, $record) = @_;
47
48
    $self->count( $self->count + 1 );
49
50
    my $fh  = $self->fh;
51
    my $xml = ref($record) eq 'MARC::Record'
52
              ? $record->as_xml_record() : $record;
53
    $xml =~ s/<\?xml version="1.0" encoding="UTF-8"\?>\n//g if $self->valid;
54
    print $fh $xml;
55
}
56
57
__PACKAGE__->meta->make_immutable;
58
59
1;
(-)a/misc/bin/koha-index (+80 lines)
Line 0 Link Here
1
#!/usr/bin/perl
2
3
package Main;
4
5
use Modern::Perl;
6
use utf8;
7
use Koha::Indexer::Indexing;
8
use Pod::Usage;
9
10
my $indexer = Koha::Indexer::Indexing->new_with_options();
11
if ( $indexer->help ) {
12
    pod2usage( -verbose => 99 );
13
    exit;
14
}
15
$indexer->run();
16
17
18
__END__
19
20
=pod
21
22
=head1 SYNOPSIS
23
24
 koha-index
25
26
 koha-index --verbose
27
28
 koha-index --source biblio --select queue
29
30
 koha-index --source authority --select all
31
32
 koha-index --select queue --directory /tmp/koha-index-mylib --keep
33
34
=head1 DESCRIPTION
35
36
Index queued biblio/autority record, or reindex the whole DB. Koha standard
37
environment variables must ne set appropriately: KOHA_CONF and PERL5LIB.
38
39
=head1 OPTIONS
40
41
=over
42
43
=item --source
44
45
Select records to be indexed: C<biblio> or C<authority>. If not specified,
46
biblio by default.
47
48
=item --select
49
50
Select record to be indexed: C<all> or C<queue>. If not specified, C<all> is
51
selected. If C<all> is selected, zebra database is reset before indexing.
52
53
=item --directory
54
55
Directory where records to be indexed by Zebra are exported. If not specified,
56
a direcory named C<koha-index> is used, and if necessary created, in the
57
current directory. In this directory, sub-directories are created containing
58
records to be updated or deleted by Zebra. If those subdirectories already
59
exist, they are first emptied. The export directory tree is kept after zebra
60
indexing.
61
62
=item --keep
63
64
Keep the directory, and its content, where biblio/authority records have been
65
exported.
66
67
=item --verbose
68
69
Increase the amount of logging. Normally only warnings and errors from the
70
indexing are shown.
71
72
=back
73
74
=head1 SEE ALSO
75
76
=for :list
77
* L<koha-index-daemon>
78
79
=cut
80
(-)a/misc/bin/koha-index-daemon (-1 / +49 lines)
Line 0 Link Here
0
- 
1
#!/usr/bin/perl
2
3
package Main;
4
5
use Modern::Perl;
6
use utf8;
7
use Koha::Indexer::Daemon;
8
use Pod::Usage;
9
10
Koha::Indexer::Daemon->new_with_options();
11
12
__END__
13
14
=pod
15
16
=head1 SYNOPSIS
17
18
 koha-index-daemon
19
20
 koha-index-daemon --timeout 60
21
22
 koha-index-daemon --timeout 60 --directory /home/mylib/tmp
23
24
=head1 DESCRIPTION
25
26
Examine periodicaly zebraqueue table from a Koha instance and index
27
bilbio/authority records. 
28
29
=head1 OPTIONS
30
31
=over
32
33
=item --timeout
34
35
Specify the daemon timeout in seconds.
36
37
=item --directory
38
39
Directory where to write record exported from Koha DB before sending them to
40
Zebra. Subdirectories are created.
41
42
=back
43
44
=head1 SEE ALSO
45
46
=for :list
47
* L<koha-index>
48
49
=cut

Return to bug 11081