struct TrackerMinerFS

struct TrackerMinerFS;

Abstract miner implementation to get data from the filesystem.

TrackerMinerFSClass

typedef struct {
	TrackerMinerClass parent;

	gboolean (* process_file)             (TrackerMinerFS       *fs,
	                                       GFile                *file,
	                                       TrackerSparqlBuilder *builder,
	                                       GCancellable         *cancellable);
	gboolean (* ignore_next_update_file)  (TrackerMinerFS       *fs,
	                                       GFile                *file,
	                                       TrackerSparqlBuilder *builder,
	                                       GCancellable         *cancellable);
	void     (* finished)                 (TrackerMinerFS       *fs);
	gboolean (* process_file_attributes)  (TrackerMinerFS       *fs,
	                                       GFile                *file,
	                                       TrackerSparqlBuilder *builder,
	                                       GCancellable         *cancellable);
	gboolean (* writeback_file)           (TrackerMinerFS       *fs,
	                                       GFile                *file,
	                                       GStrv                 rdf_types,
	                                       GPtrArray            *results);
} TrackerMinerFSClass;

Prototype for the abstract class, process_file must be implemented in the deriving class in order to actually extract data.

tracker_miner_fs_add_directory_without_parent ()

void                tracker_miner_fs_add_directory_without_parent
                                                        (TrackerMinerFS *fs,
                                                         GFile *file);

Tells the miner-fs that the given GFile corresponds to a directory which was created in the store without a specific parent object. In this case, when regenerating internal caches, an extra query will be done so that these elements are taken into account.

Since 0.10

tracker_miner_fs_check_directory ()

void                tracker_miner_fs_check_directory    (TrackerMinerFS *fs,
                                                         GFile *file,
                                                         gboolean check_parents);

Tells the filesystem miner to check and index a directory, this file must be part of the usual crawling directories of TrackerMinerFS. See tracker_miner_fs_directory_add().

Since 0.10

tracker_miner_fs_check_directory_with_priority ()

void                tracker_miner_fs_check_directory_with_priority
                                                        (TrackerMinerFS *fs,
                                                         GFile *file,
                                                         gint priority,
                                                         gboolean check_parents);

Tells the filesystem miner to check and index a directory at a given priority, this file must be part of the usual crawling directories of TrackerMinerFS. See tracker_miner_fs_directory_add().

Since 0.10

tracker_miner_fs_check_file ()

void                tracker_miner_fs_check_file         (TrackerMinerFS *fs,
                                                         GFile *file,
                                                         gboolean check_parents);

Tells the filesystem miner to check and index a file, this file must be part of the usual crawling directories of TrackerMinerFS. See tracker_miner_fs_directory_add().

Since 0.10

tracker_miner_fs_check_file_with_priority ()

void                tracker_miner_fs_check_file_with_priority
                                                        (TrackerMinerFS *fs,
                                                         GFile *file,
                                                         gint priority,
                                                         gboolean check_parents);

Tells the filesystem miner to check and index a file at a given priority, this file must be part of the usual crawling directories of TrackerMinerFS. See tracker_miner_fs_directory_add().

Since 0.10

tracker_miner_fs_directory_add ()

void                tracker_miner_fs_directory_add      (TrackerMinerFS *fs,
                                                         GFile *file,
                                                         gboolean recurse);

Tells the filesystem miner to inspect a directory.

Since 0.8

tracker_miner_fs_directory_remove ()

gboolean            tracker_miner_fs_directory_remove   (TrackerMinerFS *fs,
                                                         GFile *file);

Removes a directory from being inspected by fs. Note that only directory watches are removed.

Since 0.8

tracker_miner_fs_directory_remove_full ()

gboolean            tracker_miner_fs_directory_remove_full
                                                        (TrackerMinerFS *fs,
                                                         GFile *file);

Removes a directory from being inspected by fs, and removes all associated metadata of the directory (and its contents) from the store.

Since 0.10

tracker_miner_fs_file_notify ()

void                tracker_miner_fs_file_notify        (TrackerMinerFS *fs,
                                                         GFile *file,
                                                         const GError *error);

Notifies fs that all processing on file has been finished, if any error happened during file data processing, it should be passed in error, else that parameter will contain NULL to reflect success.

Since 0.8

tracker_miner_fs_force_mtime_checking ()

void                tracker_miner_fs_force_mtime_checking
                                                        (TrackerMinerFS *fs,
                                                         GFile *directory);

Tells fs to force mtime checking (regardless of the global mtime check configuration) on the given directory.

Since 0.12

tracker_miner_fs_force_recheck ()

void                tracker_miner_fs_force_recheck      (TrackerMinerFS *fs);

tracker_miner_fs_get_indexing_tree ()

TrackerIndexingTree * tracker_miner_fs_get_indexing_tree
                                                        (TrackerMinerFS *fs);

Returns the TrackerIndexingTree which determines what files/directories are indexed by fs

tracker_miner_fs_get_initial_crawling ()

gboolean            tracker_miner_fs_get_initial_crawling
                                                        (TrackerMinerFS *fs);

tracker_miner_fs_get_mtime_checking ()

gboolean            tracker_miner_fs_get_mtime_checking (TrackerMinerFS *fs);

Since 0.10

tracker_miner_fs_get_parent_urn ()

const gchar *       tracker_miner_fs_get_parent_urn     (TrackerMinerFS *fs,
                                                         GFile *file);

If file is currently being processed by fs, this function will return the parent folder URN if any. This function is useful to set the nie:belongsToContainer relationship. The processing order of TrackerMinerFS guarantees that a folder has been already fully processed for indexing before any children is processed, so most usually this function should return non-NULL.

Since 0.8

tracker_miner_fs_get_throttle ()

gdouble             tracker_miner_fs_get_throttle       (TrackerMinerFS *fs);

Gets the current throttle value. see tracker_miner_fs_set_throttle().

Since 0.8

tracker_miner_fs_get_urn ()

const gchar *       tracker_miner_fs_get_urn            (TrackerMinerFS *fs,
                                                         GFile *file);

If the item exists in the store, this function retrieves the URN for a GFile being currently processed.

If file is not being currently processed by fs, or doesn't exist in the store yet, NULL will be returned.

Since 0.8

tracker_miner_fs_has_items_to_process ()

gboolean            tracker_miner_fs_has_items_to_process
                                                        (TrackerMinerFS *fs);

Since 0.10

tracker_miner_fs_query_urn ()

gchar *             tracker_miner_fs_query_urn          (TrackerMinerFS *fs,
                                                         GFile *file);

If the item exists in the store, this function retrieves the URN of the given GFile

If file doesn't exist in the store yet, NULL will be returned.

Since 0.10

tracker_miner_fs_set_initial_crawling ()

void                tracker_miner_fs_set_initial_crawling
                                                        (TrackerMinerFS *fs,
                                                         gboolean do_initial_crawling);

tracker_miner_fs_set_mtime_checking ()

void                tracker_miner_fs_set_mtime_checking (TrackerMinerFS *fs,
                                                         gboolean mtime_checking);

Tells the miner-fs that during the crawling phase, directory mtime checks should or shouldn't be performed against the database to make sure we have the most up to date version of the file being checked at the time. Setting this to FALSE can dramatically improve the start up the crawling of the fs.

The down side is that using this consistently means that some files on the disk may be out of date with files in the database.

The main purpose of this function is for systems where a fs is running the entire time and where it is very unlikely that a file could be changed outside between startup and shutdown of the process using this API.

The default if not set directly is that mtime_checking is TRUE.

Since 0.10

tracker_miner_fs_set_throttle ()

void                tracker_miner_fs_set_throttle       (TrackerMinerFS *fs,
                                                         gdouble throttle);

Tells the filesystem miner to throttle its operations. a value of 0 means no throttling at all, so the miner will perform operations at full speed, 1 is the slowest value.

Since 0.8

tracker_miner_fs_writeback_file ()

void                tracker_miner_fs_writeback_file     (TrackerMinerFS *fs,
                                                         GFile *file,
                                                         GStrv rdf_types,
                                                         GPtrArray *results);

Tells the filesystem miner to writeback a file.

Since 0.10.20

tracker_miner_fs_writeback_notify ()

void                tracker_miner_fs_writeback_notify   (TrackerMinerFS *fs,
                                                         GFile *file,
                                                         const GError *error);

Notifies fs that all writing back on file has been finished, if any error happened during file data processing, it should be passed in error, else that parameter will contain NULL to reflect success.

Since 0.10.20

The "initial-crawling" property

  "initial-crawling"         gboolean              : Read / Write

Whether to perform initial crawling or not.

Default value: TRUE

The "mtime-checking" property

  "mtime-checking"           gboolean              : Read / Write / Construct

Whether to perform mtime checks during initial crawling or not.

Default value: TRUE

The "processing-pool-ready-limit" property

  "processing-pool-ready-limit" guint                 : Read / Write / Construct

Maximum number of SPARQL updates that can be merged in a single connection to the store.

Allowed values: >= 1

Default value: 1

The "processing-pool-wait-limit" property

  "processing-pool-wait-limit" guint                 : Read / Write / Construct

Maximum number of files that can be concurrently processed by the upper layer.

Allowed values: >= 1

Default value: 1

The "throttle" property

  "throttle"                 gdouble               : Read / Write

Modifier for the indexing speed, 0 is max speed.

Allowed values: [0,1]

Default value: 0

The "finished" signal

void                user_function                      (TrackerMinerFS *miner_fs,
                                                        gdouble         elapsed,
                                                        guint           directories_found,
                                                        guint           directories_ignored,
                                                        guint           files_found,
                                                        guint           files_ignored,
                                                        gpointer        user_data)                : Run Last

The ::finished signal is emitted when miner_fs has finished all pending processing.

Since 0.8

The "ignore-next-update-file" signal

gboolean            user_function                      (TrackerMinerFS       *miner_fs,
                                                        GFile                *file,
                                                        TrackerSparqlBuilder *builder,
                                                        GCancellable         *cancellable,
                                                        gpointer              user_data)        : Run Last

The ::ignore-next-update-file signal is emitted whenever a file should be marked as to ignore on next update, and it's metadata prepared for that.

builder is the TrackerSparqlBuilder where all sparql updates to be performed for file will be appended.

Since 0.8

The "process-file" signal

gboolean            user_function                      (TrackerMinerFS       *miner_fs,
                                                        GFile                *file,
                                                        TrackerSparqlBuilder *builder,
                                                        GCancellable         *cancellable,
                                                        gpointer              user_data)        : Run Last

The ::process-file signal is emitted whenever a file should be processed, and it's metadata extracted.

builder is the TrackerSparqlBuilder where all sparql updates to be performed for file will be appended.

This signal allows both synchronous and asynchronous extraction, in the synchronous case cancellable can be safely ignored. In either case, on successful metadata extraction, implementations must call tracker_miner_fs_file_notify() to indicate that processing has finished on file, so the miner can execute the SPARQL updates and continue processing other files.

Since 0.8

The "process-file-attributes" signal

gboolean            user_function                      (TrackerMinerFS       *miner_fs,
                                                        GFile                *file,
                                                        TrackerSparqlBuilder *builder,
                                                        GCancellable         *cancellable,
                                                        gpointer              user_data)        : Run Last

The ::process-file-attributes signal is emitted whenever a file should be processed, but only the attribute-related metadata extracted.

builder is the TrackerSparqlBuilder where all sparql updates to be performed for file will be appended. For the properties being updated, the DELETE statements should be included as well.

This signal allows both synchronous and asynchronous extraction, in the synchronous case cancellable can be safely ignored. In either case, on successful metadata extraction, implementations must call tracker_miner_fs_file_notify() to indicate that processing has finished on file, so the miner can execute the SPARQL updates and continue processing other files.

Since 0.10

The "writeback-file" signal

gboolean            user_function                      (TrackerMinerFS *miner_fs,
                                                        GFile          *file,
                                                        GStrv           rdf_types,
                                                        GPtrArray      *results,
                                                        GCancellable   *cancellable,
                                                        gpointer        user_data)        : Run Last

The ::writeback-file signal is emitted whenever a file must be written back

Since 0.10.20