tracker_miner_fs_error_quark ()

GQuark
tracker_miner_fs_error_quark (void);

Gives the caller the GQuark used to identify TrackerMinerFS errors in GError structures. The GQuark is used as the domain for the error.

Since: 1.2.

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_data_provider ()

TrackerDataProvider *
tracker_miner_fs_get_data_provider (TrackerMinerFS *fs);

Returns the TrackerDataProvider implementation, which is being used to supply GFile and GFileInfo content to Tracker.

Since: 1.2

tracker_miner_fs_get_throttle ()

gdouble
tracker_miner_fs_get_throttle (TrackerMinerFS *fs);

Gets the current throttle value, see tracker_miner_fs_set_throttle() for more details.

Since: 0.8

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.0 means no throttling at all, so the miner will perform operations at full speed, 1.0 is the slowest value. With a value of 1.0, the fs is typically waiting one full second before handling the next batch of queued items to be processed.

Since: 0.8

tracker_miner_fs_check_file ()

void
tracker_miner_fs_check_file (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_notify_finish ()

void
tracker_miner_fs_notify_finish (TrackerMinerFS *fs,
                                GTask *task,
                                const gchar *sparql,
                                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 sparql should contain correct SPARQL representing the operation in particular.

This function is expected to be called in reaction to all TrackerMinerFS signals

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_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_has_items_to_process ()

gboolean
tracker_miner_fs_has_items_to_process (TrackerMinerFS *fs);

The fs keeps many priority queus for content it is processing. This function returns TRUE if the sum of all (or any) priority queues is more than 0. This includes items deleted, created, updated, moved or being written back.

Since: 0.10

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,
					       GTask                *task);
	void     (* finished)                 (TrackerMinerFS       *fs,
	                                       gdouble               elapsed,
	                                       gint                  directories_found,
	                                       gint                  directories_ignored,
	                                       gint                  files_found,
	                                       gint                  files_ignored);
	gboolean (* process_file_attributes)  (TrackerMinerFS       *fs,
	                                       GFile                *file,
					       GTask                *task);
	void     (* finished_root)            (TrackerMinerFS       *fs,
	                                       GFile                *root,
	                                       gint                  directories_found,
	                                       gint                  directories_ignored,
	                                       gint                  files_found,
	                                       gint                  files_ignored);
	gchar *  (* remove_file)              (TrackerMinerFS       *fs,
	                                       GFile                *file);
	gchar *  (* remove_children)          (TrackerMinerFS       *fs,
	                                       GFile                *file);
	gchar *  (* move_file)                (TrackerMinerFS       *fs,
					       GFile                *source,
	                                       GFile                *dest,
	                                       gboolean              recursive);

	gboolean (* filter_event)             (TrackerMinerFS          *fs,
	                                       TrackerMinerFSEventType  type,
	                                       GFile                   *file,
	                                       GFile                   *source_file);

	/* <Private> */
	gpointer padding[20];
} TrackerMinerFSClass;

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

enum TrackerMinerFSError

Possible errors returned when calling creating new objects based on the TrackerMinerFS type and other APIs available with this class.

Since: 1.2.

enum TrackerMinerFSEventType

The “data-provider” property

  “data-provider”            TrackerDataProvider *

Data provider populating data, e.g. like GFileEnumerator.

Flags: Read / Write / Construct Only

The “processing-pool-ready-limit” property

  “processing-pool-ready-limit” guint

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

Flags: Read / Write / Construct

Allowed values: >= 1

Default value: 1

The “processing-pool-wait-limit” property

  “processing-pool-wait-limit” guint

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

Flags: Read / Write / Construct

Allowed values: >= 1

Default value: 1

The “root” property

  “root”                     GFile *

Top level URI for our indexing tree and file notify clases.

Flags: Read / Write / Construct Only

The “throttle” property

  “throttle”                 gdouble

Modifier for the indexing speed, 0 is max speed.

Flags: Read / Write

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)

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

Flags: Run Last

Since: 0.8

The “finished-root” signal

void
user_function (TrackerMinerFS *miner_fs,
               GFile          *file,
               gpointer        user_data)

The ::finished-crawl signal is emitted when miner_fs has finished finding all resources that need to be indexed with the root location of file . At this point, it's likely many are still in the queue to be added to the database, but this gives some indication that a location is processed.

Flags: Run Last

Since: 1.2

The “move-file” signal

gchar*
user_function (TrackerMinerFS *trackerminerfs,
               GFile          *arg1,
               GFile          *arg2,
               gboolean        arg3,
               gpointer        user_data)

Flags: Run Last

The “process-file” signal

gboolean
user_function (TrackerMinerFS *miner_fs,
               GFile          *file,
               GTask          *builder,
               gpointer        user_data)

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_notify_finish() to indicate that processing has finished on file , so the miner can execute the SPARQL updates and continue processing other files.

Flags: Run Last

Since: 0.8

The “process-file-attributes” signal

gboolean
user_function (TrackerMinerFS *miner_fs,
               GFile          *file,
               GTask          *builder,
               gpointer        user_data)

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_notify_finish() to indicate that processing has finished on file , so the miner can execute the SPARQL updates and continue processing other files.

Flags: Run Last

Since: 0.10

The “remove-children” signal

gchar*
user_function (TrackerMinerFS *trackerminerfs,
               GFile          *arg1,
               gpointer        user_data)

Flags: Run Last

The “remove-file” signal

gchar*
user_function (TrackerMinerFS *miner_fs,
               GFile          *file,
               gpointer        user_data)

The ::remove-file signal will be emitted on files that need removal according to the miner configuration (either the files themselves are deleted, or the directory/contents no longer need inspection according to miner configuration and their location.

This operation is always assumed to be recursive, the children_only argument will be TRUE if for any reason the topmost directory needs to stay (e.g. moved from a recursively indexed directory tree to a non-recursively indexed location).

The builder argument can be used to provide additional SPARQL deletes and updates necessary around the deletion of those items. If the return value of this signal is TRUE, builder is expected to contain all relevant deletes for this operation.

If the return value of this signal is FALSE, the miner will apply its default behavior, which is deleting all triples that correspond to the affected URIs.

Flags: Run Last

Since: 1.8