OpenSync 0.22

osengine/osengine_deciders.c

00001 /*
00002  * libosengine - A synchronization engine for the opensync framework
00003  * Copyright (C) 2004-2005  Armin Bauer <armin.bauer@opensync.org>
00004  * 
00005  * This library is free software; you can redistribute it and/or
00006  * modify it under the terms of the GNU Lesser General Public
00007  * License as published by the Free Software Foundation; either
00008  * version 2.1 of the License, or (at your option) any later version.
00009  * 
00010  * This library is distributed in the hope that it will be useful,
00011  * but WITHOUT ANY WARRANTY; without even the implied warranty of
00012  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
00013  * Lesser General Public License for more details.
00014  * 
00015  * You should have received a copy of the GNU Lesser General Public
00016  * License along with this library; if not, write to the Free Software
00017  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307  USA
00018  * 
00019  */
00020  
00021 #include "engine.h"
00022 #include "engine_internals.h"
00023 
00034 
00035 #ifndef DOXYGEN_SHOULD_SKIP_THIS
00036 void osengine_mappingentry_decider(OSyncEngine *engine, OSyncMappingEntry *entry)
00037 {
00038         osync_trace(TRACE_ENTRY, "osengine_mappingentry_decider(%p, %p)", engine, entry);
00039         osengine_print_flags(engine);
00040         osengine_mappingentry_print_flags(entry);
00041         
00042         engine->alldeciders++;
00043         
00044         if (osync_flag_is_set(engine->fl_running) \
00045         && osync_flag_is_set(engine->fl_sync) \
00046         && osync_flag_is_set(entry->fl_has_info) \
00047         && osync_flag_is_not_set(entry->fl_has_data)) {
00048                 osync_trace(TRACE_INTERNAL, "++++ ENGINE COMMAND: Get data (Entry %p) ++++", entry);
00049                 osync_client_get_change_data(entry->client, engine, entry, NULL);
00050                 osync_trace(TRACE_EXIT, "osengine_mappingentry_decider");
00051                 return;
00052         }
00053         
00054         if (osync_flag_is_set(engine->fl_running) \
00055         && osync_flag_is_set(engine->cmb_read_all) \
00056         && osync_flag_is_set(engine->cmb_sent_changes) \
00057         && osync_flag_is_set(engine->fl_sync) \
00058         && osync_flag_is_set(entry->fl_has_info) \
00059         && osync_flag_is_set(entry->fl_has_data)) {
00060                 if (osync_flag_is_not_set(entry->fl_mapped)) {
00061                         osync_trace(TRACE_INTERNAL, "++++ ENGINE COMMAND: Mapping entry (Entry %p) ++++", entry);
00062                         osengine_change_map(engine, entry);
00063                         osync_trace(TRACE_EXIT, "osengine_mappingentry_decider");
00064                         return;
00065                 }
00066                 if (osync_flag_is_set(entry->fl_dirty)) {
00067                         osync_trace(TRACE_INTERNAL, "++++ ENGINE COMMAND: Commiting (Entry %p) ++++", entry);
00068                         osync_client_commit_change(entry->client, engine, entry, NULL);
00069                         osync_trace(TRACE_EXIT, "osengine_mappingentry_decider");
00070                         return;
00071                 }
00072         }
00073         
00074         engine->wasted++;
00075         osync_trace(TRACE_EXIT, "osengine_mappingentry_decider: Waste");
00076 }
00077 
00078 void osengine_mappingentry_all_deciders(OSyncEngine *engine, OSyncMapping *mapping)
00079 {
00080         osync_debug("ENG", 3, "Calling all mappingentry deciders (%i) for mapping %p", g_list_length(mapping->entries), mapping);
00081         GList *e;
00082         for (e = mapping->entries; e ; e = e->next) {
00083                 OSyncMappingEntry *entry = e->data;
00084                 send_mappingentry_changed(engine, entry);
00085         }
00086 }
00087 
00088 void osengine_mapping_decider(OSyncEngine *engine, OSyncMapping *mapping)
00089 {
00090         osync_trace(TRACE_ENTRY, "osengine_mapping_decider(%p, %p)", engine, mapping);
00091         osengine_print_flags(engine);
00092         osengine_mapping_print_flags(mapping);
00093 
00094         engine->alldeciders++;
00095         
00096         if (osync_flag_is_set(engine->fl_running) \
00097         && osync_flag_is_set(engine->cmb_sent_changes) \
00098         && osync_flag_is_set(engine->cmb_read_all) \
00099         && osync_flag_is_set(engine->cmb_entries_mapped) \
00100         && osync_flag_is_set(mapping->cmb_has_data) \
00101         && osync_flag_is_not_set(mapping->cmb_synced) \
00102         && osync_flag_is_not_set(mapping->fl_solved) \
00103         && osync_flag_is_not_set(mapping->fl_chkconflict)) {
00104                 osync_trace(TRACE_INTERNAL, "++++ ENGINE COMMAND: Check Conflict (Mapping %p) ++++", mapping);
00105                 osengine_mapping_check_conflict(engine, mapping);
00106                 osync_trace(TRACE_EXIT, "osengine_mapping_decider");
00107                 return;
00108         }
00109         
00110         if (osync_flag_is_set(engine->fl_running) \
00111         && osync_flag_is_set(engine->cmb_sent_changes) \
00112         && osync_flag_is_set(engine->cmb_read_all) \
00113         && osync_flag_is_set(engine->cmb_entries_mapped) \
00114         && osync_flag_is_set(mapping->cmb_has_data) \
00115         && osync_flag_is_not_set(mapping->cmb_synced) \
00116         && osync_flag_is_set(mapping->fl_solved) \
00117         && osync_flag_is_set(mapping->fl_chkconflict) \
00118         && osync_flag_is_not_set(mapping->fl_multiplied)) {
00119                 osync_trace(TRACE_INTERNAL, "++++ ENGINE COMMAND: Multiply (Mapping %p) ++++", mapping);
00120                 osengine_mapping_multiply_master(engine, mapping);
00121                 osync_trace(TRACE_EXIT, "osengine_mapping_decider");
00122                 return;
00123         }
00124         
00125         if (osync_flag_is_set(engine->fl_running) \
00126         && osync_flag_is_set(engine->cmb_synced) \
00127         && osync_flag_is_set(mapping->cmb_has_info) \
00128         && osync_flag_is_not_set(mapping->cmb_deleted) \
00129         && osync_flag_is_set(engine->cmb_multiplied)) {
00130                 osync_trace(TRACE_INTERNAL, "++++ ENGINE COMMAND: Reset Mapping (Mapping %p) ++++", mapping);
00131                 osengine_mapping_reset(mapping);
00132                 osync_trace(TRACE_EXIT, "osengine_mapping_decider");
00133                 return;
00134         }
00135         
00136         if (osync_flag_is_set(engine->fl_running) \
00137         && osync_flag_is_set(mapping->cmb_synced) \
00138         && osync_flag_is_set(mapping->cmb_deleted)) {
00139                 osync_trace(TRACE_INTERNAL, "++++ ENGINE COMMAND: Deleting Mapping (Mapping %p) ++++", mapping);
00140                 osengine_mapping_delete(mapping);
00141                 osync_trace(TRACE_EXIT, "osengine_mapping_decider");
00142                 return;
00143         }
00144         
00145         engine->wasted++;
00146         osync_trace(TRACE_EXIT, "osengine_mapping_decider: Waste");
00147 }
00148 
00149 void osengine_mapping_all_deciders(OSyncEngine *engine)
00150 {
00151         GList *m;
00152         osync_trace(TRACE_INTERNAL, "Calling all mapping deciders (%i)", g_list_length(engine->maptable->mappings));
00153         for (m = engine->maptable->mappings; m; m = m->next) {
00154                 OSyncMapping *mapping = m->data;
00155                 send_mapping_changed(engine, mapping);
00156         }
00157 }
00158 
00159 void osengine_client_decider(OSyncEngine *engine, OSyncClient *client)
00160 {
00161         osync_trace(TRACE_ENTRY, "osengine_client_decider(%p, %p)", engine, client);
00162         osengine_print_flags(engine);
00163         osync_client_print_flags(client);
00164         
00165         engine->alldeciders++;
00166         
00167         if (osync_flag_is_set(engine->fl_running) \
00168         && osync_flag_is_not_set(engine->fl_stop) \
00169         && osync_flag_is_not_set(client->fl_done) \
00170         && osync_flag_is_not_set(client->fl_connected) \
00171         && osync_flag_is_not_set(client->fl_finished)) {
00172                 osync_trace(TRACE_INTERNAL, "++++ ENGINE COMMAND: Connecting (Client %p) ++++", client);
00173                 osync_client_connect(client, engine, NULL);
00174                 osync_trace(TRACE_EXIT, "osengine_client_decider");
00175                 return;
00176         }
00177         
00178         if (osync_flag_is_set(engine->fl_running) \
00179         && osync_flag_is_not_set(engine->fl_stop) \
00180         && osync_flag_is_not_set(client->fl_done) \
00181         && osync_flag_is_set(client->fl_connected) \
00182         && osync_flag_is_not_set(client->fl_sent_changes) \
00183         && osync_flag_is_set(engine->cmb_connected)) {
00184                 osync_trace(TRACE_INTERNAL, "++++ ENGINE COMMAND: Get changes (Client %p) ++++", client);
00185                 osync_client_get_changes(client, engine, NULL);
00186                 osync_trace(TRACE_EXIT, "osengine_client_decider");
00187                 return;
00188         }
00189         
00190         if (osync_flag_is_set(engine->fl_running) \
00191         && osync_flag_is_not_set(engine->fl_stop) \
00192         && osync_flag_is_not_set(client->fl_done) \
00193         && osync_flag_is_set(client->fl_connected) \
00194         && osync_flag_is_set(client->fl_sent_changes) \
00195         && osync_flag_is_not_set(client->fl_committed_all) \
00196         && osync_flag_is_set(engine->cmb_sent_changes) \
00197         && osync_flag_is_set(engine->cmb_multiplied) \
00198         && osync_flag_is_set(engine->cmb_read_all) \
00199         && osync_flag_is_set(engine->cmb_entries_mapped) \
00200         && osync_flag_is_set(engine->cmb_committed_all)) {
00201                 osync_trace(TRACE_INTERNAL, "++++ ENGINE COMMAND: Committed all (Client %p) ++++", client);
00202                 osync_client_committed_all(client, engine, NULL);
00203                 osync_trace(TRACE_EXIT, "osengine_client_decider");
00204                 return;
00205         }
00206         
00207         if (osync_flag_is_set(engine->fl_running) \
00208         && osync_flag_is_not_set(engine->fl_stop) \
00209         && osync_flag_is_not_set(client->fl_done) \
00210         && osync_flag_is_set(client->fl_connected) \
00211         && osync_flag_is_set(client->fl_sent_changes) \
00212         && osync_flag_is_set(client->fl_committed_all) \
00213         && osync_flag_is_set(engine->cmb_read_all) \
00214         && osync_flag_is_set(engine->cmb_sent_changes) \
00215         && osync_flag_is_set(engine->cmb_synced) \
00216         && osync_flag_is_set(engine->cmb_entries_mapped)) {
00217                 osync_trace(TRACE_INTERNAL, "++++ ENGINE COMMAND: Sync done (Client %p) ++++", client);
00218                 osync_client_sync_done(client, engine, NULL);
00219                 osync_trace(TRACE_EXIT, "osengine_client_decider");
00220                 return;
00221         }
00222         
00223         if (osync_flag_is_set(engine->fl_running) \
00224         && (osync_flag_is_set(client->fl_done) \
00225         || osync_flag_is_set(engine->fl_stop)) \
00226         && osync_flag_is_set(client->fl_connected)) {
00227                 osync_trace(TRACE_INTERNAL, "++++ ENGINE COMMAND: Disconnecting (Client %p) ++++", client);
00228                 osync_client_disconnect(client, engine, NULL);
00229                 osync_trace(TRACE_EXIT, "osengine_client_decider");
00230                 return;
00231         }
00232         
00233         engine->wasted++;
00234         osync_trace(TRACE_EXIT, "osengine_client_decider: Waste");
00235 }
00236 
00237 void osengine_client_all_deciders(OSyncEngine *engine)
00238 {
00239         GList *c;
00240         osync_debug("ENG", 3, "Calling all client deciders (%i)", g_list_length(engine->clients));
00241         for (c = engine->clients; c; c = c->next) {
00242                 OSyncClient *client = c->data;
00243                 osengine_client_decider(engine, client);
00244         }
00245 }
00246 #endif
00247