?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
lib: removed dead code from Bookmark parser
[barry/progweb.git] / desktop / src / os22.cc
blobb6899c84370841bc7e58be47ec24c0ec33d5ff67
1 ///
2 /// \file os22.cc
3 /// Wrapper class for opensync 0.22 syncing behaviour
4 ///
5
6 /*
7 Copyright (C) 2009-2012, Net Direct Inc. (http://www.netdirect.ca/)
8
9 Used code from msynctool (GPL v2+) as a guide to the API,
10 and copied some of its status messages and one function directly:
11 static const char *OSyncChangeType2String(OSyncChangeType c);
12 Copyright (C) 2004-2005 Armin Bauer <armin.bauer@opensync.org>
13
14 This program is free software; you can redistribute it and/or modify
15 it under the terms of the GNU General Public License as published by
16 the Free Software Foundation; either version 2 of the License, or
17 (at your option) any later version.
18
19 This program is distributed in the hope that it will be useful,
20 but WITHOUT ANY WARRANTY; without even the implied warranty of
21 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
22
23 See the GNU General Public License in the COPYING file at the
24 root directory of this project for more details.
25 */
26
27 #include "os22.h"
28 #include "osprivatebase.h"
29 #include "osconv22.h"
30 #include <barry/vsmartptr.h>
31 #include <iostream>
32 #include <sstream>
33 #include <memory>
34 #include <glib.h>
35
36 // use relative paths to backtrack enough to specify only 0.22 includes
37 #include <../opensync-1.0/opensync/opensync.h>
38 #include <../opensync-1.0/osengine/engine.h>
39
40 using namespace std;
41
42 namespace OpenSync {
43
44 typedef Barry::vLateSmartPtr<OSyncEngine, void(*)(OSyncEngine*)> EngineHandle;
45
46 class OpenSync22Private
47 {
48 public:
49 // function pointers
50 const char* (*osync_get_version)();
51 OSyncEnv* (*osync_env_new)();
52 void (*osync_env_free)(OSyncEnv *env);
53 void (*osync_env_set_option)(OSyncEnv *env,
54 const char *name, const char *value);
55 osync_bool (*osync_env_finalize)(OSyncEnv *env,
56 OSyncError **error);
57 int (*osync_env_num_plugins)(OSyncEnv *env);
58 OSyncPlugin* (*osync_env_nth_plugin)(OSyncEnv *env, int nth);
59 const char* (*osync_plugin_get_name)(OSyncPlugin *plugin);
60 void (*osync_error_free)(OSyncError **error);
61 const char* (*osync_error_print)(OSyncError **error);
62 osync_bool (*osync_env_initialize)(OSyncEnv *env,
63 OSyncError **error);
64 int (*osync_env_num_groups)(OSyncEnv *env);
65 OSyncGroup* (*osync_env_nth_group)(OSyncEnv *env, int nth);
66 const char* (*osync_group_get_name)(OSyncGroup *group);
67 OSyncGroup* (*osync_env_find_group)(OSyncEnv *env,
68 const char *name);
69 int (*osync_group_num_members)(OSyncGroup *group);
70 OSyncMember* (*osync_group_nth_member)(OSyncGroup *group,
71 int nth);
72 long long int (*osync_member_get_id)(OSyncMember *member);
73 const char* (*osync_member_get_pluginname)(
74 OSyncMember *member);
75 OSyncFormatEnv* (*osync_conv_env_new)(OSyncEnv *env);
76 void (*osync_conv_env_free)(OSyncFormatEnv *env);
77 int (*osync_conv_num_objtypes)(OSyncFormatEnv *env);
78 OSyncObjType* (*osync_conv_nth_objtype)(OSyncFormatEnv *env,
79 int nth);
80 int (*osync_conv_num_objformats)(
81 OSyncObjType *type);
82 OSyncObjFormat* (*osync_conv_nth_objformat)(OSyncObjType *type,
83 int nth);
84 const char* (*osync_objformat_get_name)(
85 OSyncObjFormat *format);
86 const char* (*osync_objtype_get_name)(OSyncObjType *type);
87 OSyncGroup* (*osync_group_new)(OSyncEnv *env);
88 void (*osync_group_set_name)(OSyncGroup *group,
89 const char *name);
90 osync_bool (*osync_group_save)(OSyncGroup *group,
91 OSyncError **error);
92 osync_bool (*osync_group_delete)(OSyncGroup *group,
93 OSyncError **error);
94 OSyncMember* (*osync_member_new)(OSyncGroup *group);
95 osync_bool (*osync_member_instance_plugin)(
96 OSyncMember *member,
97 const char *pluginname,
98 OSyncError **error);
99 osync_bool (*osync_member_save)(OSyncMember *member,
100 OSyncError **error);
101 OSyncMember* (*osync_member_from_id)(OSyncGroup *group,
102 int id);
103 osync_bool (*osync_member_need_config)(OSyncMember *member,
104 OSyncConfigurationTypes *type,
105 OSyncError **error);
106 osync_bool (*osync_member_get_config_or_default)(
107 OSyncMember *member,
108 char **data, int *size,
109 OSyncError **error);
110 void (*osync_member_set_config)(OSyncMember *member,
111 const char *data, int size);
112 osync_bool (*osengine_mapping_ignore_supported)(
113 OSyncEngine *engine,
114 OSyncMapping *mapping);
115 osync_bool (*osengine_mapping_check_timestamps)(
116 OSyncEngine *engine,
117 OSyncMapping *mapping,
118 OSyncError **error);
119 OSyncChange* (*osengine_mapping_nth_change)(
120 OSyncMapping *mapping, int nth);
121 void (*osengine_mapping_solve)(OSyncEngine *engine,
122 OSyncMapping *mapping,
123 OSyncChange *change);
124 void (*osengine_mapping_duplicate)(
125 OSyncEngine *engine,
126 OSyncMapping *dupe_mapping);
127 osync_bool (*osengine_mapping_ignore_conflict)(
128 OSyncEngine *engine,
129 OSyncMapping *mapping,
130 OSyncError **error);
131 osync_bool (*osengine_mapping_solve_latest)(
132 OSyncEngine *engine,
133 OSyncMapping *mapping,
134 OSyncError **error);
135 const char* (*osync_change_get_uid)(OSyncChange *change);
136 osync_bool (*osengine_init)(OSyncEngine *engine,
137 OSyncError **error);
138 OSyncMember* (*osync_change_get_member)(OSyncChange *change);
139 int (*osync_change_get_datasize)(
140 OSyncChange *change);
141 OSyncEngine* (*osengine_new)(OSyncGroup *group,
142 OSyncError **error);
143 void (*osengine_free)(OSyncEngine *engine);
144 void (*osengine_finalize)(OSyncEngine *engine);
145 osync_bool (*osengine_sync_and_block)(OSyncEngine *engine,
146 OSyncError **error);
147 void (*osengine_set_memberstatus_callback)(
148 OSyncEngine *engine,
149 void (* function) (OSyncMemberUpdate *,
150 void *),
151 void *user_data);
152 void (*osengine_set_changestatus_callback)(
153 OSyncEngine *engine,
154 void (* function) (OSyncEngine *,
155 OSyncChangeUpdate *,
156 void *),
157 void *user_data);
158 void (*osengine_set_enginestatus_callback)(
159 OSyncEngine *engine,
160 void (* function) (OSyncEngine *,
161 OSyncEngineUpdate *,
162 void *),
163 void *user_data);
164 void (*osengine_set_mappingstatus_callback)(
165 OSyncEngine *engine,
166 void (* function) (OSyncMappingUpdate *,
167 void *),
168 void *user_data);
169 void (*osengine_set_conflict_callback)(
170 OSyncEngine *engine,
171 void (* function) (OSyncEngine *,
172 OSyncMapping *,
173 void *),
174 void *user_data);
175 int (*osengine_mapping_num_changes)(
176 OSyncMapping *mapping);
177 OSyncChangeType (*osync_change_get_changetype)(
178 OSyncChange *change);
179 char* (*osync_change_get_printable)(
180 OSyncChange *change);
181 void (*osync_group_set_objtype_enabled)(
182 OSyncGroup *group,
183 const char *objtypestr,
184 osync_bool enabled);
185
186 // data pointers
187 OSyncEnv *env;
188
189 Converter22 converter;
190
191 OpenSync22Private(OpenSync22 &api)
192 : env(0)
193 , converter(api)
194 {
195 }
196 };
197
198 class SyncConflict22Private : public SyncConflictPrivateBase
199 {
200 OpenSync22Private *m_priv;
201 OSyncEngine *m_engine;
202 OSyncMapping *m_mapping;
203
204 public:
205 SyncConflict22Private(OpenSync22Private *priv,
206 OSyncEngine *engine, OSyncMapping *mapping);
207 ~SyncConflict22Private();
208
209 virtual bool IsAbortSupported() const;
210 virtual bool IsIgnoreSupported() const;
211 virtual bool IsKeepNewerSupported() const;
212
213 virtual void Select(int change_id); // takes id of SyncChange object
214 virtual void Abort(); // not supported in 0.22
215 virtual void Duplicate();
216 virtual void Ignore();
217 virtual void KeepNewer();
218
219 void AppendChanges(std::vector<SyncChange> &list);
220 };
221
222 struct CallbackBundle22
223 {
224 OpenSync22Private *m_priv;
225 SyncStatus *m_status;
226
227 CallbackBundle22(OpenSync22Private *priv, SyncStatus &status)
228 : m_priv(priv)
229 , m_status(&status)
230 {
231 }
232 };
233
234 void member_status(OSyncMemberUpdate *, void *);
235 void entry_status(OSyncEngine *, OSyncChangeUpdate *, void *);
236 void engine_status(OSyncEngine *, OSyncEngineUpdate *,void *);
237 void mapping_status(OSyncMappingUpdate *, void *);
238 void conflict_handler(OSyncEngine *, OSyncMapping *, void *);
239
240
241 /////////////////////////////////////////////////////////////////////////////
242 // Static helper functions
243
244 static const char *OSyncChangeType2String(OSyncChangeType c)
245 {
246 switch (c) {
247 case CHANGE_ADDED: return "ADDED";
248 case CHANGE_UNMODIFIED: return "UNMODIFIED";
249 case CHANGE_DELETED: return "DELETED";
250 case CHANGE_MODIFIED: return "MODIFIED";
251 default:
252 case CHANGE_UNKNOWN: return "?";
253 }
254 }
255
256 /////////////////////////////////////////////////////////////////////////////
257 // SyncConflict22Private member functions
258
259 SyncConflict22Private::SyncConflict22Private(OpenSync22Private *priv,
260 OSyncEngine *engine, OSyncMapping *mapping)
261 : m_priv(priv)
262 , m_engine(engine)
263 , m_mapping(mapping)
264 {
265 }
266
267 SyncConflict22Private::~SyncConflict22Private()
268 {
269 }
270
271 bool SyncConflict22Private::IsAbortSupported() const
272 {
273 return false; // Abort not explicitly supported in 0.22
274 }
275
276 bool SyncConflict22Private::IsIgnoreSupported() const
277 {
278 return m_priv->osengine_mapping_ignore_supported(m_engine, m_mapping);
279 }
280
281 bool SyncConflict22Private::IsKeepNewerSupported() const
282 {
283 return m_priv->osengine_mapping_check_timestamps(m_engine, m_mapping, NULL);
284 }
285
286 void SyncConflict22Private::Select(int change_id)
287 {
288 OSyncChange *change = m_priv->osengine_mapping_nth_change(m_mapping, change_id);
289 if( !change ) {
290 throw std::runtime_error("Bad change_id, or error getting nth change object.");
291 }
292
293 m_priv->osengine_mapping_solve(m_engine, m_mapping, change);
294 }
295
296 void SyncConflict22Private::Abort()
297 {
298 throw std::logic_error("Conflict::Abort() not supported in 0.22");
299 }
300
301 void SyncConflict22Private::Duplicate()
302 {
303 m_priv->osengine_mapping_duplicate(m_engine, m_mapping);
304 }
305
306 void SyncConflict22Private::Ignore()
307 {
308 if( !IsIgnoreSupported() )
309 throw std::logic_error("Ignore not supported, yet Ignore() called.");
310
311 OSyncError *error = NULL;
312 if( !m_priv->osengine_mapping_ignore_conflict(m_engine, m_mapping, &error)) {
313 ostringstream oss;
314 oss << "Conflict not ignored: "
315 << m_priv->osync_error_print(&error);
316 m_priv->osync_error_free(&error);
317 throw std::runtime_error(oss.str());
318 }
319 }
320
321 void SyncConflict22Private::KeepNewer()
322 {
323 if( !IsKeepNewerSupported() )
324 throw std::logic_error("Keep Newer not supported, yet KeepNewer() called.");
325
326 OSyncError *error = NULL;
327 if( !m_priv->osengine_mapping_solve_latest(m_engine, m_mapping, &error)) {
328 ostringstream oss;
329 oss << "Conflict not resolved: "
330 << m_priv->osync_error_print(&error);
331 m_priv->osync_error_free(&error);
332 throw std::runtime_error(oss.str());
333 }
334 }
335
336 void SyncConflict22Private::AppendChanges(std::vector<SyncChange> &list)
337 {
338 for( int i = 0; i < m_priv->osengine_mapping_num_changes(m_mapping); i++ ) {
339 OSyncChange *change = m_priv->osengine_mapping_nth_change(m_mapping, i);
340 if( m_priv->osync_change_get_changetype(change) != CHANGE_UNKNOWN ) {
341
342 SyncChange entry;
343
344 char *printable = m_priv->osync_change_get_printable(change);
345 if( printable ) {
346 entry.printable_data = printable;
347 g_free(printable);
348 }
349
350 OSyncMember *member = m_priv->osync_change_get_member(change);
351
352 entry.id = i;
353 entry.member_id = m_priv->osync_member_get_id(member);
354 entry.plugin_name = m_priv->osync_member_get_pluginname(member);
355 entry.uid = m_priv->osync_change_get_uid(change);
356
357 // add to list
358 list.push_back(entry);
359 }
360 }
361 }
362
363
364 /////////////////////////////////////////////////////////////////////////////
365 // Callback functions
366
367 void member_status(OSyncMemberUpdate *status, void *cbdata)
368 {
369 CallbackBundle22 *cb = (CallbackBundle22*) cbdata;
370
371 try {
372 ostringstream oss;
373 bool error_event = false;
374 bool valid = true;
375
376 oss << "Member "
377 << cb->m_priv->osync_member_get_id(status->member)
378 << " ("
379 << cb->m_priv->osync_member_get_pluginname(status->member)
380 << ")";
381
382 switch( status->type )
383 {
384 case MEMBER_CONNECTED:
385 oss << " just connected";
386 break;
387 case MEMBER_DISCONNECTED:
388 oss << " just disconnected";
389 break;
390 case MEMBER_SENT_CHANGES:
391 oss << " just sent all changes";
392 break;
393 case MEMBER_COMMITTED_ALL:
394 oss << " committed all changes";
395 break;
396 case MEMBER_CONNECT_ERROR:
397 oss << " had an error while connecting: "
398 << cb->m_priv->osync_error_print(&status->error);
399 break;
400 case MEMBER_GET_CHANGES_ERROR:
401 oss << " had an error while getting changes: "
402 << cb->m_priv->osync_error_print(&status->error);
403 error_event = true;
404 break;
405 case MEMBER_SYNC_DONE_ERROR:
406 oss << " had an error while calling sync done: "
407 << cb->m_priv->osync_error_print(&status->error);
408 error_event = true;
409 break;
410 case MEMBER_DISCONNECT_ERROR:
411 oss << " had an error while disconnecting: "
412 << cb->m_priv->osync_error_print(&status->error);
413 error_event = true;
414 break;
415 case MEMBER_COMMITTED_ALL_ERROR:
416 oss << " had an error while commiting changes: "
417 << cb->m_priv->osync_error_print(&status->error);
418 error_event = true;
419 break;
420 default:
421 valid = false;
422 break;
423 }
424
425 // call the status handler
426 if( oss.str().size() && valid ) {
427 cb->m_status->MemberStatus(
428 cb->m_priv->osync_member_get_id(status->member),
429 cb->m_priv->osync_member_get_pluginname(status->member),
430 oss.str(), error_event);
431 }
432 }
433 catch( std::exception &e ) {
434 cb->m_status->ReportError(
435 string("member_status error: ") + e.what());
436 }
437 catch( ... ) {
438 cb->m_status->ReportError(
439 "Unknown exception caught in member_status()");
440 }
441
442 }
443
444 void entry_status(OSyncEngine *engine, OSyncChangeUpdate *status, void *cbdata)
445 {
446 CallbackBundle22 *cb = (CallbackBundle22*) cbdata;
447
448 try {
449 ostringstream oss;
450
451 OSyncMember *member = cb->m_priv->osync_change_get_member(status->change);
452 bool error_event = false;
453
454 switch( status->type )
455 {
456 case CHANGE_RECEIVED_INFO:
457 oss << "Received an entry "
458 << cb->m_priv->osync_change_get_uid(status->change)
459 << " without data from member "
460 << status->member_id
461 << " ("
462 << cb->m_priv->osync_member_get_pluginname(member)
463 << "). "
464 << "Changetype "
465 << OSyncChangeType2String(cb->m_priv->osync_change_get_changetype(status->change));
466 break;
467 case CHANGE_RECEIVED:
468 oss << "Received an entry "
469 << cb->m_priv->osync_change_get_uid(status->change)
470 << " with data of size "
471 << cb->m_priv->osync_change_get_datasize(status->change)
472 << " from member "
473 << status->member_id
474 << " ("
475 << cb->m_priv->osync_member_get_pluginname(member)
476 << "). Changetype "
477 << OSyncChangeType2String(cb->m_priv->osync_change_get_changetype(status->change));
478 break;
479 case CHANGE_SENT:
480 oss << "Sent an entry "
481 << cb->m_priv->osync_change_get_uid(status->change)
482 << " of size "
483 << cb->m_priv->osync_change_get_datasize(status->change)
484 << " to member "
485 << status->member_id
486 << " ("
487 << cb->m_priv->osync_member_get_pluginname(member)
488 << "). Changetype "
489 << OSyncChangeType2String(cb->m_priv->osync_change_get_changetype(status->change));
490 break;
491 case CHANGE_WRITE_ERROR:
492 error_event = true;
493 oss << "Error writing entry "
494 << cb->m_priv->osync_change_get_uid(status->change)
495 << " to member "
496 << status->member_id
497 << " ("
498 << cb->m_priv->osync_member_get_pluginname(member)
499 << "): "
500 << cb->m_priv->osync_error_print(&status->error);
501 break;
502 case CHANGE_RECV_ERROR:
503 error_event = true;
504 oss << "Error reading entry "
505 << cb->m_priv->osync_change_get_uid(status->change)
506 << " from member "
507 << status->member_id
508 << " ("
509 << cb->m_priv->osync_member_get_pluginname(member)
510 << "): "
511 << cb->m_priv->osync_error_print(&(status->error));
512 break;
513 }
514
515 // call the status handler
516 if( oss.str().size() ) {
517 cb->m_status->EntryStatus(oss.str(), error_event);
518 }
519 }
520 catch( std::exception &e ) {
521 cb->m_status->ReportError(
522 string("entry_status error:") + e.what());
523 }
524 catch( ... ) {
525 cb->m_status->ReportError(
526 "Unknown exception caught in entry_status()");
527 }
528 }
529
530 void engine_status(OSyncEngine *engine, OSyncEngineUpdate *status, void *cbdata)
531 {
532 CallbackBundle22 *cb = (CallbackBundle22*) cbdata;
533
534 try {
535 ostringstream oss;
536 bool error_event = false;
537
538 switch( status->type )
539 {
540 case ENG_PREV_UNCLEAN:
541 oss << "The previous synchronization was unclean. Slow-syncing.";
542 break;
543 case ENG_ENDPHASE_CON:
544 oss << "All clients connected or error";
545 break;
546 case ENG_END_CONFLICTS:
547 oss << "All conflicts have been reported";
548 break;
549 case ENG_ENDPHASE_READ:
550 oss << "All clients sent changes or error";
551 break;
552 case ENG_ENDPHASE_WRITE:
553 oss << "All clients have written";
554 break;
555 case ENG_ENDPHASE_DISCON:
556 oss << "All clients have disconnected";
557 break;
558 case ENG_SYNC_SUCCESSFULL:
559 oss << "The sync was successful";
560 break;
561 case ENG_ERROR:
562 oss << "The sync failed: "
563 << cb->m_priv->osync_error_print(&status->error);
564 error_event = true;
565 break;
566 }
567
568 // call the status handler
569 if( oss.str().size() )
570 cb->m_status->EngineStatus(oss.str(),
571 error_event,
572 status->type == ENG_PREV_UNCLEAN);
573 }
574 catch( std::exception &e ) {
575 cb->m_status->ReportError(
576 string("engine_status error: ") + e.what());
577 }
578 catch( ... ) {
579 cb->m_status->ReportError(
580 "Unknown exception caught in engine_status()");
581 }
582 }
583
584 void mapping_status(OSyncMappingUpdate *status, void *cbdata)
585 {
586 CallbackBundle22 *cb = (CallbackBundle22*) cbdata;
587
588 try {
589 ostringstream oss;
590 bool error_event = false;
591
592 switch( status->type )
593 {
594 case MAPPING_SOLVED:
595 oss << "Mapping solved";
596 break;
597 case MAPPING_SYNCED:
598 oss << "Mapping Synced";
599 break;
600 case MAPPING_WRITE_ERROR:
601 error_event = true;
602 oss << "Mapping Write Error: "
603 << cb->m_priv->osync_error_print(&status->error);
604 break;
605 }
606
607 // call the status handler
608 if( oss.str().size() )
609 cb->m_status->MappingStatus(oss.str(), error_event);
610 }
611 catch( std::exception &e ) {
612 cb->m_status->ReportError(
613 string("mapping_status error: ") + e.what());
614 }
615 catch( ... ) {
616 cb->m_status->ReportError(
617 "Unknown exception caught in mapping_status()");
618 }
619 }
620
621 void conflict_handler(OSyncEngine *engine, OSyncMapping *mapping, void *cbdata)
622 {
623 CallbackBundle22 *cb = (CallbackBundle22*) cbdata;
624
625 try {
626 // build the SyncConflict object
627 SyncConflict22Private scp(cb->m_priv, engine, mapping);
628 SyncConflict conflict(scp);
629
630 // append all conflicting changes as vector objects in the same
631 // order as the opensync library mapping
632 scp.AppendChanges(conflict);
633
634 // call the status handler
635 cb->m_status->HandleConflict(conflict);
636 }
637 catch( std::exception &e ) {
638 cb->m_status->ReportError(
639 string("Conflict not resolved. ") + e.what());
640 }
641 catch( ... ) {
642 cb->m_status->ReportError(
643 "Unknown exception caught in conflict_handler()");
644 }
645 }
646
647
648 /////////////////////////////////////////////////////////////////////////////
649 // OpenSync22 - public members
650
651 bool OpenSync22::symbols_loaded = false;
652
653 OpenSync22::OpenSync22()
654 {
655 if( !Open("libosengine.so.0") )
656 throw DlError("Can't dlopen libosengine.so.0");
657
658 // the symbol table is now thoroughly polluted...
659 symbols_loaded = true;
660
661 // store locally in case of constructor exception in LoadSym
662 std::auto_ptr<OpenSync22Private> p(new OpenSync22Private(*this));
663
664 // load all required symbols...
665 // we don't need to use try/catch here, since the base
666 // class destructor will clean up for us if LoadSym() throws
667 LoadSym(p->osync_get_version, "osync_get_version");
668 LoadSym(p->osync_env_new, "osync_env_new");
669 LoadSym(p->osync_env_free, "osync_env_free");
670 LoadSym(p->osync_env_set_option, "osync_env_set_option");
671 LoadSym(p->osync_env_finalize, "osync_env_finalize");
672 LoadSym(p->osync_env_num_plugins, "osync_env_num_plugins");
673 LoadSym(p->osync_env_nth_plugin, "osync_env_nth_plugin");
674 LoadSym(p->osync_plugin_get_name, "osync_plugin_get_name");
675 LoadSym(p->osync_error_free, "osync_error_free");
676 LoadSym(p->osync_error_print, "osync_error_print");
677 LoadSym(p->osync_env_initialize, "osync_env_initialize");
678 LoadSym(p->osync_env_num_groups, "osync_env_num_groups");
679 LoadSym(p->osync_env_nth_group, "osync_env_nth_group");
680 LoadSym(p->osync_group_get_name, "osync_group_get_name");
681 LoadSym(p->osync_env_find_group, "osync_env_find_group");
682 LoadSym(p->osync_group_num_members, "osync_group_num_members");
683 LoadSym(p->osync_group_nth_member, "osync_group_nth_member");
684 LoadSym(p->osync_member_get_id, "osync_member_get_id");
685 LoadSym(p->osync_member_get_pluginname, "osync_member_get_pluginname");
686 LoadSym(p->osync_conv_env_new, "osync_conv_env_new");
687 LoadSym(p->osync_conv_env_free, "osync_conv_env_free");
688 LoadSym(p->osync_conv_num_objtypes, "osync_conv_num_objtypes");
689 LoadSym(p->osync_conv_nth_objtype, "osync_conv_nth_objtype");
690 LoadSym(p->osync_conv_num_objformats, "osync_conv_num_objformats");
691 LoadSym(p->osync_conv_nth_objformat, "osync_conv_nth_objformat");
692 LoadSym(p->osync_objformat_get_name, "osync_objformat_get_name");
693 LoadSym(p->osync_objtype_get_name, "osync_objtype_get_name");
694 LoadSym(p->osync_group_new, "osync_group_new");
695 LoadSym(p->osync_group_set_name, "osync_group_set_name");
696 LoadSym(p->osync_group_save, "osync_group_save");
697 LoadSym(p->osync_group_delete, "osync_group_delete");
698 LoadSym(p->osync_member_new, "osync_member_new");
699 LoadSym(p->osync_member_instance_plugin,"osync_member_instance_plugin");
700 LoadSym(p->osync_member_save, "osync_member_save");
701 LoadSym(p->osync_member_from_id, "osync_member_from_id");
702 LoadSym(p->osync_member_need_config, "osync_member_need_config");
703 LoadSym(p->osync_member_get_config_or_default,
704 "osync_member_get_config_or_default");
705 LoadSym(p->osync_member_set_config, "osync_member_set_config");
706 LoadSym(p->osengine_mapping_ignore_supported,
707 "osengine_mapping_ignore_supported");
708 LoadSym(p->osengine_mapping_check_timestamps,
709 "osengine_mapping_check_timestamps");
710 LoadSym(p->osengine_mapping_nth_change, "osengine_mapping_nth_change");
711 LoadSym(p->osengine_mapping_solve, "osengine_mapping_solve");
712 LoadSym(p->osengine_mapping_duplicate, "osengine_mapping_duplicate");
713 LoadSym(p->osengine_mapping_ignore_conflict,
714 "osengine_mapping_ignore_conflict");
715 LoadSym(p->osengine_mapping_solve_latest,
716 "osengine_mapping_solve_latest");
717 LoadSym(p->osync_change_get_uid, "osync_change_get_uid");
718 LoadSym(p->osengine_init, "osengine_init");
719 LoadSym(p->osync_change_get_member, "osync_change_get_member");
720 LoadSym(p->osync_change_get_datasize, "osync_change_get_datasize");
721 LoadSym(p->osengine_new, "osengine_new");
722 LoadSym(p->osengine_free, "osengine_free");
723 LoadSym(p->osengine_finalize, "osengine_finalize");
724 LoadSym(p->osengine_sync_and_block, "osengine_sync_and_block");
725 LoadSym(p->osengine_set_memberstatus_callback,
726 "osengine_set_memberstatus_callback");
727 LoadSym(p->osengine_set_changestatus_callback,
728 "osengine_set_changestatus_callback");
729 LoadSym(p->osengine_set_enginestatus_callback,
730 "osengine_set_enginestatus_callback");
731 LoadSym(p->osengine_set_mappingstatus_callback,
732 "osengine_set_mappingstatus_callback");
733 LoadSym(p->osengine_set_conflict_callback,
734 "osengine_set_conflict_callback");
735 LoadSym(p->osengine_mapping_num_changes,
736 "osengine_mapping_num_changes");
737 LoadSym(p->osync_change_get_changetype, "osync_change_get_changetype");
738 LoadSym(p->osync_change_get_printable, "osync_change_get_printable");
739 LoadSym(p->osync_group_set_objtype_enabled,
740 "osync_group_set_objtype_enabled");
741
742 // do common initialization of opensync environment
743 SetupEnvironment(p.get());
744
745 // this pointer is ours now
746 m_priv = p.release();
747 }
748
749 OpenSync22::~OpenSync22()
750 {
751 // clean up opensync environment, closing plugins, etc.
752 if( m_priv->env ) {
753 m_priv->osync_env_finalize(m_priv->env, NULL);
754 m_priv->osync_env_free(m_priv->env);
755 }
756
757 // free private class data
758 delete m_priv;
759 m_priv = 0;
760 }
761
762 void OpenSync22::SetupEnvironment(OpenSync22Private *p)
763 {
764 // we are fully responsible for this pointer, since
765 // we run inside the constructor... only on success
766 // will responsibility be transferred to the destructor
767 p->env = p->osync_env_new();
768 if( !p->env )
769 throw std::runtime_error("Error allocating opensync 0.22 environment");
770
771 p->osync_env_set_option(p->env, "GROUPS_DIRECTORY", NULL);
772 p->osync_env_set_option(p->env, "LOAD_GROUPS", "TRUE");
773 p->osync_env_set_option(p->env, "LOAD_PLUGINS", "TRUE");
774 p->osync_env_set_option(p->env, "LOAD_FORMATS", "TRUE");
775
776 OSyncError *error = NULL;
777 if( !p->osync_env_initialize(p->env, &error) ) {
778 // grab error message
779 std::runtime_error err(m_priv->osync_error_print(&error));
780
781 // cleanup
782 p->osync_error_free(&error);
783 p->osync_env_free(m_priv->env);
784
785 // throw
786 throw err;
787 }
788 }
789
790 const char* OpenSync22::GetVersion() const
791 {
792 return m_priv->osync_get_version();
793 }
794
795 const char* OpenSync22::GetEngineName() const
796 {
797 return "0.22";
798 }
799
800 void OpenSync22::GetPluginNames(string_list_type &plugins)
801 {
802 // start fresh
803 plugins.clear();
804
805 OSyncPlugin *p;
806 for( int i = 0; i < m_priv->osync_env_num_plugins(m_priv->env); i++) {
807 p = m_priv->osync_env_nth_plugin(m_priv->env, i);
808 plugins.push_back(m_priv->osync_plugin_get_name(p));
809 }
810 }
811
812 void OpenSync22::GetFormats(format_list_type &formats)
813 {
814 // start fresh
815 formats.clear();
816
817 // cycle through all object types and simulate a 0.4x-like
818 // list based on the attached formats
819
820 OSyncFormatEnv *fenv = m_priv->osync_conv_env_new(m_priv->env);
821 if( !fenv ) {
822 throw std::runtime_error("GetFormats(): Unable to load format environment in GetFormats (22)");
823 }
824
825 for( int i = 0; i < m_priv->osync_conv_num_objtypes(fenv); i++ ) {
826 OSyncObjType *type = m_priv->osync_conv_nth_objtype(fenv, i);
827
828 for( int i = 0; i < m_priv->osync_conv_num_objformats(type); i++ ) {
829 OSyncObjFormat *format = m_priv->osync_conv_nth_objformat(type, i);
830 const char *objformat_name = m_priv->osync_objformat_get_name(format);
831
832 if( !formats.Find(objformat_name) ) {
833 Format new_format;
834 new_format.name = objformat_name;
835 new_format.object_type = m_priv->osync_objtype_get_name(type);
836 formats.push_back(new_format);
837 }
838 }
839 }
840
841 m_priv->osync_conv_env_free(fenv);
842 }
843
844 void OpenSync22::GetGroupNames(string_list_type &groups)
845 {
846 // start fresh
847 groups.clear();
848
849 OSyncGroup *g;
850 for( int i = 0; i < m_priv->osync_env_num_groups(m_priv->env); i++ ) {
851 g = m_priv->osync_env_nth_group(m_priv->env, i);
852 groups.push_back(m_priv->osync_group_get_name(g));
853 }
854 }
855
856 void OpenSync22::GetMembers(const std::string &group_name,
857 member_list_type &members)
858 {
859 // start fresh
860 members.clear();
861
862 OSyncGroup *group = m_priv->osync_env_find_group(m_priv->env, group_name.c_str());
863 if( !group ) {
864 throw std::runtime_error("GetMembers(): Unable to find group with name: " + group_name);
865 }
866
867 for( int i = 0; i < m_priv->osync_group_num_members(group); i++ ) {
868 OSyncMember *member = m_priv->osync_group_nth_member(group, i);
869
870 Member new_member;
871
872 new_member.group_name = group_name;
873 new_member.id = m_priv->osync_member_get_id(member);
874 new_member.plugin_name = m_priv->osync_member_get_pluginname(member);
875
876 // we are switching opensync's long long int ID to
877 // our long... to double check they are equal after
878 // the conversion
879 if( new_member.id != m_priv->osync_member_get_id(member) ) {
880 throw std::logic_error("GetMembers(): OpenSync's member ID is too large to fit in OpenSyncAPI (22)");
881 }
882
883 // add to member list
884 members.push_back(new_member);
885 }
886 }
887
888 void OpenSync22::AddGroup(const std::string &group_name)
889 {
890 if( m_priv->osync_env_find_group(m_priv->env, group_name.c_str()) )
891 throw std::runtime_error("AddGroup(): Group already exists: " + group_name);
892
893 OSyncGroup *group = m_priv->osync_group_new(m_priv->env);
894 m_priv->osync_group_set_name(group, group_name.c_str());
895
896 OSyncError *error = NULL;
897 if( !m_priv->osync_group_save(group, &error) ) {
898 // grab error message
899 std::runtime_error err(string("AddGroup(): Unable to save group: ") + m_priv->osync_error_print(&error));
900
901 // cleanup
902 m_priv->osync_error_free(&error);
903
904 throw err;
905 }
906 }
907
908 void OpenSync22::DeleteGroup(const std::string &group_name)
909 {
910 OSyncGroup *group = m_priv->osync_env_find_group(m_priv->env, group_name.c_str());
911 if( !group )
912 throw std::runtime_error("DeleteGroup(): Group not found: " + group_name);
913
914 OSyncError *error = NULL;
915 if( !m_priv->osync_group_delete(group, &error) ) {
916 std::runtime_error err(string("DeleteGroup(): Unable to delete group: ") + m_priv->osync_error_print(&error));
917 m_priv->osync_error_free(&error);
918 throw err;
919 }
920 }
921
922 Converter& OpenSync22::GetConverter()
923 {
924 return m_priv->converter;
925 }
926
927 long OpenSync22::AddMember(const std::string &group_name,
928 const std::string &plugin_name,
929 const std::string &member_name)
930 {
931 OSyncGroup *group = m_priv->osync_env_find_group(m_priv->env, group_name.c_str());
932 if( !group )
933 throw std::runtime_error("AddMember(): Group not found: " + group_name);
934
935 OSyncMember *member = m_priv->osync_member_new(group);
936
937 OSyncError *error = NULL;
938 if( !m_priv->osync_member_instance_plugin(member, plugin_name.c_str(), &error) ) {
939 std::runtime_error err(string("AddMember(): Unable to connect plugin with member ") + member_name + "/" + plugin_name + ": " + m_priv->osync_error_print(&error));
940 m_priv->osync_error_free(&error);
941 throw err;
942 }
943
944 if( !m_priv->osync_member_save(member, &error) ) {
945 std::runtime_error err(string("AddMember(): Unable to save member ") + member_name + "/" + plugin_name + ": " + m_priv->osync_error_print(&error));
946 m_priv->osync_error_free(&error);
947 throw err;
948 }
949
950 return m_priv->osync_member_get_id(member);
951 }
952
953 bool OpenSync22::IsConfigurable(const std::string &group_name,
954 long member_id)
955 {
956 OSyncGroup *group = m_priv->osync_env_find_group(m_priv->env, group_name.c_str());
957 if( !group )
958 throw std::runtime_error("Group not found: " + group_name);
959
960 OSyncMember *member = m_priv->osync_member_from_id(group, member_id);
961 if( !member ) {
962 ostringstream oss;
963 oss << "IsConfigurable(): Member " << member_id << " not found.";
964 throw std::runtime_error(oss.str());
965 }
966
967 OSyncConfigurationTypes type = NO_CONFIGURATION;
968 OSyncError *error = NULL;
969 if( !m_priv->osync_member_need_config(member, &type, &error) ) {
970 std::runtime_error err(string("Unable to determine needed config: ") + m_priv->osync_error_print(&error));
971 m_priv->osync_error_free(&error);
972 throw err;
973 }
974
975 return type != NO_CONFIGURATION;
976 }
977
978 std::string OpenSync22::GetConfiguration(const std::string &group_name,
979 long member_id)
980 {
981 if( !IsConfigurable(group_name, member_id) ) {
982 ostringstream oss;
983 oss << "GetConfiguration(): Member " << member_id << " of group '" << group_name << "' does not accept configuration.";
984 throw std::runtime_error(oss.str());
985 }
986
987 OSyncGroup *group = m_priv->osync_env_find_group(m_priv->env, group_name.c_str());
988 if( !group )
989 throw std::runtime_error("GetConfiguration(): Group not found: " + group_name);
990
991 OSyncMember *member = m_priv->osync_member_from_id(group, member_id);
992 if( !member ) {
993 ostringstream oss;
994 oss << "GetConfiguration(): Member " << member_id << " not found.";
995 throw std::runtime_error(oss.str());
996 }
997
998 OSyncError *error = NULL;
999 char *data = NULL;
1000 int size = 0;
1001 if( !m_priv->osync_member_get_config_or_default(member, &data, &size, &error)) {
1002 std::runtime_error err(string("GetConfiguration(): Unable to retrieve config: ") + m_priv->osync_error_print(&error));
1003 m_priv->osync_error_free(&error);
1004 throw err;
1005 }
1006
1007 std::string config(data, size);
1008 g_free(data);
1009
1010 return config;
1011 }
1012
1013 void OpenSync22::SetConfiguration(const std::string &group_name,
1014 long member_id,
1015 const std::string &config_data)
1016 {
1017 if( !IsConfigurable(group_name, member_id) ) {
1018 ostringstream oss;
1019 oss << "SetConfiguration(): Member " << member_id << " of group '" << group_name << "' does not accept configuration.";
1020 throw std::runtime_error(oss.str());
1021 }
1022
1023 OSyncGroup *group = m_priv->osync_env_find_group(m_priv->env, group_name.c_str());
1024 if( !group )
1025 throw std::runtime_error("SetConfiguration(): Group not found: " + group_name);
1026
1027 OSyncMember *member = m_priv->osync_member_from_id(group, member_id);
1028 if( !member ) {
1029 ostringstream oss;
1030 oss << "SetConfiguration(): Member " << member_id << " not found.";
1031 throw std::runtime_error(oss.str());
1032 }
1033
1034 m_priv->osync_member_set_config(member, config_data.c_str(), config_data.size());
1035
1036 OSyncError *error = NULL;
1037 if( !m_priv->osync_member_save(member, &error) ) {
1038 std::runtime_error err(string("SetConfiguration(): Unable to save member's config: ") + m_priv->osync_error_print(&error));
1039 m_priv->osync_error_free(&error);
1040 throw err;
1041 }
1042 }
1043
1044 void OpenSync22::Discover(const std::string &group_name)
1045 {
1046 // Discover is a successful noop on 0.22
1047 }
1048
1049 void OpenSync22::Sync(const std::string &group_name,
1050 SyncStatus &status_callback,
1051 Config::pst_type sync_types)
1052 {
1053 OSyncGroup *group = m_priv->osync_env_find_group(m_priv->env, group_name.c_str());
1054 if( !group )
1055 throw std::runtime_error("Sync(): Group not found: " + group_name);
1056
1057 // enable/disable each objtype, as per sync_types
1058 if( !(sync_types & PST_DO_NOT_SET) ) {
1059 cerr << "enabling objtypes: " << sync_types << endl;
1060 m_priv->osync_group_set_objtype_enabled(group, "contact",
1061 (sync_types & PST_CONTACTS) ? TRUE : FALSE);
1062 m_priv->osync_group_set_objtype_enabled(group, "event",
1063 (sync_types & PST_EVENTS) ? TRUE : FALSE);
1064 m_priv->osync_group_set_objtype_enabled(group, "note",
1065 (sync_types & PST_NOTES) ? TRUE : FALSE);
1066 m_priv->osync_group_set_objtype_enabled(group, "todo",
1067 (sync_types & PST_TODOS) ? TRUE : FALSE);
1068 }
1069
1070 OSyncError *error = NULL;
1071 EngineHandle engine(m_priv->osengine_free);
1072 engine = m_priv->osengine_new(group, &error);
1073 if( !engine.get() ) {
1074 std::ostringstream oss;
1075 oss << "Error while synchronizing: "
1076 << m_priv->osync_error_print(&error);
1077 m_priv->osync_error_free(&error);
1078 throw std::runtime_error(oss.str());
1079 }
1080
1081 CallbackBundle22 cbdata(m_priv, status_callback);
1082
1083 m_priv->osengine_set_memberstatus_callback(engine.get(),
1084 &member_status, &cbdata);
1085 m_priv->osengine_set_changestatus_callback(engine.get(),
1086 &entry_status, &cbdata);
1087 m_priv->osengine_set_enginestatus_callback(engine.get(),
1088 &engine_status, &cbdata);
1089 m_priv->osengine_set_mappingstatus_callback(engine.get(),
1090 &mapping_status, &cbdata);
1091 m_priv->osengine_set_conflict_callback(engine.get(),
1092 &conflict_handler, &cbdata);
1093
1094 if( !m_priv->osengine_init(engine.get(), &error) ) {
1095 ostringstream oss;
1096 oss << "Error initializing osengine: "
1097 << m_priv->osync_error_print(&error);
1098 m_priv->osync_error_free(&error);
1099 throw std::runtime_error(oss.str());
1100 }
1101
1102 // successfully initialized, so finalize must be called
1103 EngineHandle initialized_engine(m_priv->osengine_finalize);
1104 initialized_engine = engine.get();
1105
1106 if( !m_priv->osengine_sync_and_block(engine.get(), &error) ) {
1107 ostringstream oss;
1108 oss << "Error during sync: "
1109 << m_priv->osync_error_print(&error);
1110 m_priv->osync_error_free(&error);
1111 throw std::runtime_error(oss.str());
1112 }
1113 }
1114
1115 } // namespace OpenSync
1116
Barry fork