1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
|
/*
* Copyright (C) 2010, Nokia <ivan.frade@nokia.com>
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the
* Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
* Boston, MA 02110-1301, USA.
*/
class Tracker.Sparql.Backend : Connection {
static bool initialized = false;
static Tracker.Sparql.Connection direct = null;
static Tracker.Sparql.Connection bus = null;
static enum Backend {
AUTO,
DIRECT,
BUS
}
private delegate Tracker.Sparql.Connection ModuleInitFunc ();
public Backend (bool direct_only = false) throws Sparql.Error
requires (!initialized) {
if (!Module.supported ()) {
return;
}
try {
load_plugins (direct_only);
} catch (GLib.Error e) {
throw new Sparql.Error.INTERNAL (e.message);
}
initialized = true;
}
public override Cursor query (string sparql, Cancellable? cancellable = null) throws Sparql.Error, IOError
requires (bus != null || direct != null) {
debug ("%s(): '%s'", Log.METHOD, sparql);
if (direct != null) {
return direct.query (sparql, cancellable);
} else {
return bus.query (sparql, cancellable);
}
}
public async override Cursor query_async (string sparql, Cancellable? cancellable = null) throws Sparql.Error, IOError
requires (bus != null || direct != null) {
debug ("%s(): '%s'", Log.METHOD, sparql);
if (direct != null) {
return yield direct.query_async (sparql, cancellable);
} else {
return yield bus.query_async (sparql, cancellable);
}
}
public override void update (string sparql, int priority = GLib.Priority.DEFAULT, Cancellable? cancellable = null) throws Sparql.Error, IOError
requires (bus != null) {
debug ("%s(priority:%d): '%s'", Log.METHOD, priority, sparql);
bus.update (sparql, priority, cancellable);
}
public override GLib.Variant? update_blank (string sparql, int priority = GLib.Priority.DEFAULT, Cancellable? cancellable = null) throws Sparql.Error, IOError
requires (bus != null) {
debug ("%s(priority:%d): '%s'", Log.METHOD, priority, sparql);
return bus.update_blank (sparql, priority, cancellable);
}
public async override void update_async (string sparql, int priority = GLib.Priority.DEFAULT, Cancellable? cancellable = null) throws Sparql.Error, IOError
requires (bus != null) {
debug ("%s(priority:%d): '%s'", Log.METHOD, priority, sparql);
yield bus.update_async (sparql, priority, cancellable);
}
public async override GLib.Variant? update_blank_async (string sparql, int priority = GLib.Priority.DEFAULT, Cancellable? cancellable = null) throws Sparql.Error, IOError
requires (bus != null) {
debug ("%s(priority:%d): '%s'", Log.METHOD, priority, sparql);
return yield bus.update_blank_async (sparql, priority, cancellable);
}
public override void load (File file, Cancellable? cancellable = null) throws Sparql.Error, IOError
requires (bus != null) {
var uri = file.get_uri ();
debug ("%s(): '%s'", Log.METHOD, uri);
bus.load (file, cancellable);
}
public async override void load_async (File file, Cancellable? cancellable = null) throws Sparql.Error, IOError
requires (bus != null) {
var uri = file.get_uri ();
debug ("%s(): '%s'", Log.METHOD, uri);
yield bus.load_async (file, cancellable);
}
public override Cursor? statistics (Cancellable? cancellable = null) throws Sparql.Error, IOError
requires (bus != null) {
debug ("%s()", Log.METHOD);
return bus.statistics (cancellable);
}
public async override Cursor? statistics_async (Cancellable? cancellable = null) throws Sparql.Error, IOError
requires (bus != null) {
debug ("%s()", Log.METHOD);
return yield bus.statistics_async (cancellable);
}
// Plugin loading functions
private bool load_plugins (bool direct_only) throws GLib.Error {
string env_path = Environment.get_variable ("TRACKER_SPARQL_MODULE_PATH");
string path;
if (env_path != null && env_path.length > 0) {
path = env_path;
} else {
path = Config.SPARQL_MODULES_DIR;
}
File dir = File.new_for_path (path);
string dir_path = dir.get_path ();
string env_backend = Environment.get_variable ("TRACKER_SPARQL_BACKEND");
Backend backend = Backend.AUTO;
if (env_backend != null) {
if (env_backend.ascii_casecmp ("direct") == 0) {
backend = Backend.DIRECT;
debug ("Using backend = 'DIRECT'");
} else if (env_backend.ascii_casecmp ("bus") == 0) {
backend = Backend.BUS;
debug ("Using backend = 'BUS'");
} else {
warning ("Environment variable TRACKER_SPARQL_BACKEND set to unknown value '%s'", env_backend);
}
}
if (backend == Backend.AUTO) {
if (direct_only && backend == Backend.AUTO) {
backend = Backend.DIRECT;
debug ("Using backend = 'DIRECT'");
} else {
debug ("Using backend = 'AUTO'");
}
}
if (direct_only && backend == Backend.BUS) {
debug ("Backend set in environment contradicts requested connection type, using environment to override");
}
debug ("Searching for modules in folder '%s' ..", dir_path);
Tracker.Sparql.Connection connection;
switch (backend) {
case backend.AUTO:
string direct_path = Module.build_path (dir_path, "tracker-direct");
direct = load_plugins_from_path (direct_path, false /* required */);
string bus_path = Module.build_path (dir_path, "tracker-bus");
bus = load_plugins_from_path (bus_path, true /* required */);
connection = bus;
break;
case backend.DIRECT:
string direct_path = Module.build_path (dir_path, "tracker-direct");
connection = direct = load_plugins_from_path (direct_path, true /* required */);
break;
case backend.BUS:
string bus_path = Module.build_path (dir_path, "tracker-bus");
connection = bus = load_plugins_from_path (bus_path, true /* required */);
break;
default:
assert_not_reached ();
}
debug ("Finished searching for modules");
return connection != null;
}
private Tracker.Sparql.Connection? load_plugins_from_path (string path, bool required) throws GLib.Error {
try {
File file = File.new_for_path (path);
assert (file != null);
FileInfo info = null;
string attributes = FILE_ATTRIBUTE_STANDARD_NAME + "," +
FILE_ATTRIBUTE_STANDARD_TYPE + "," +
FILE_ATTRIBUTE_STANDARD_CONTENT_TYPE;
info = file.query_info (attributes,
FileQueryInfoFlags.NONE,
null);
string content_type = info.get_content_type ();
string mime = g_content_type_get_mime_type (content_type);
string expected_mime = "application/x-sharedlib";
if (mime != expected_mime) {
throw new IOError.FAILED ("Could not load plugin, mime type was '%s', expected:'%s'",
mime,
expected_mime);
}
Module module = Module.open (path, ModuleFlags.BIND_LOCAL);
if (module == null) {
throw new IOError.FAILED ("Failed to load module from path '%s': %s",
path,
Module.error ());
}
void *function;
if (!module.symbol ("module_init", out function)) {
throw new IOError.FAILED ("Failed to find entry point function '%s' in '%s': %s",
"module_init",
path,
Module.error ());
}
ModuleInitFunc module_init = (ModuleInitFunc) function;
assert (module_init != null);
// We don't want our modules to ever unload
module.make_resident ();
// Call module init function
Tracker.Sparql.Connection c = module_init ();
debug ("Loaded module source: '%s'", module.name ());
return c;
} catch (GLib.Error e) {
if (required) {
// plugin required => error is fatal
throw e;
} else {
return null;
}
}
}
}
|
