rhodes 3.0.0 → 3.0.1.beta.2

data/platform/wp7/RhoRubyLib/rubyext/RhoJSON.cs

@@ -4,6 +4,7 @@ using IronRuby.Runtime;
 using IronRuby.Builtins;
 using System;
 using System.Runtime.InteropServices;
+using rho.common;
 
 namespace rho.rubyext
 {
@@ -15,6 +16,9 @@ namespace rho.rubyext
         {
             #region Private Implementation Details
 
+            private static RhoLogger LOG = RhoLogger.RHO_STRIP_LOG ? new RhoEmptyLogger() :
+                new RhoLogger("RhoJSON");
+
             #endregion
 
             #region Private Instance & Singleton Methods
@@ -22,15 +26,46 @@ namespace rho.rubyext
             [RubyMethodAttribute("parse", RubyMethodAttributes.PublicSingleton)]
             public static object parse(RubyModule/*!*/ self, [NotNull]string/*!*/ strData)
             {
-                return fastJSON.RJSONTokener.JsonDecode(strData);
+                object res = null;
+                try
+                {
+                    res = fastJSON.RJSONTokener.JsonDecode(strData);
+                }
+                catch (Exception ex)
+                {
+                    Exception rubyEx = self.Context.CurrentException;
+                    if (rubyEx == null)
+                    {
+                        rubyEx = RubyExceptionData.InitializeException(new RuntimeError(ex.Message.ToString()), ex.Message);
+                    }
+                    LOG.ERROR("parse", ex);
+                    throw rubyEx;
+                }
+
+                return res;
             }
 
             [RubyMethodAttribute("quote_value", RubyMethodAttributes.PublicSingleton)]
             public static object quote_value(RubyModule/*!*/ self, [NotNull]string/*!*/ strData)
             {
-                String strRes = rho.json.JSONEntry.quoteValue(strData);
+                object res = null;
+                try
+                {
+                    String strRes = rho.json.JSONEntry.quoteValue(strData);
+                    res = CRhoRuby.Instance.createString(strRes);
+                }
+                catch (Exception ex)
+                {
+                    Exception rubyEx = self.Context.CurrentException;
+                    if (rubyEx == null)
+                    {
+                        rubyEx = RubyExceptionData.InitializeException(new RuntimeError(ex.Message.ToString()), ex.Message);
+                    }
+                    LOG.ERROR("quote_value", ex);
+                    throw rubyEx;
+                }
 
-                return CRhoRuby.Instance.createString(strRes);
+                return res;
             }
 
             #endregion

data/platform/wp7/RhoRubyLib/rubyext/RhoKernelOps.cs

@@ -9,16 +9,41 @@ namespace rho.rubyext
 {
     public static class RhoKernelOps
     {
+        private static RhoLogger LOG = RhoLogger.RHO_STRIP_LOG ? new RhoEmptyLogger() :
+            new RhoLogger("RhoKernelOps");
+
+        static CRhoRuby RhoRuby { get { return CRhoRuby.Instance; } }
+
         private static CRhodesApp RhodesApp { get { return CRhodesApp.Instance; } }
 
         public static Object __rhoGetCallbackObject(Object/*!*/ self, int index)
         {
-            return RhodesApp.getCallbackObject(index); ;
+            Object res = null;
+            try
+            {
+                res = RhodesApp.getCallbackObject(index);
+            }
+            catch (Exception ex)
+            {
+                LOG.HandleRubyException(ex, RhoRuby.rubyContext.CurrentException, "__rhoGetCallbackObject");
+            }
+
+            return res;
         }
 
         public static Object __rho_exist_in_resources(Object/*!*/ self, String path)
         {
-            return CRhoFile.isResourceFileExist(path);
+            Object res = null;
+            try
+            {
+                res = CRhoFile.isResourceFileExist(path);
+            }
+            catch (Exception ex)
+            {
+                LOG.HandleRubyException(ex, RhoRuby.rubyContext.CurrentException, "__rho_exist_in_resources");
+            }
+
+            return res;
         }
 
     }

data/platform/wp7/RhoRubyLib/rubyext/RhoNativeBar.cs

@@ -14,6 +14,8 @@ namespace rho.rubyext
 
         #region Private Implementation Details
 
+        private static RhoLogger LOG = RhoLogger.RHO_STRIP_LOG ? new RhoEmptyLogger() :
+            new RhoLogger("RhoNativeBar");
         private static CRhodesApp RhodesApp { get { return CRhodesApp.Instance; } }
 
         #endregion
@@ -23,27 +25,66 @@ namespace rho.rubyext
         [RubyMethodAttribute("create", RubyMethodAttributes.PublicSingleton)]
         public static void Create(RubyModule/*!*/ self, int barType, RubyArray args)
         {
-            if (args != null && args.Count > 0)
-                RhodesApp.createToolBar(barType, (Object)args);
-
-            if (barType == 2)
-                RhodesApp.removeToolBar();
+            try
+            {
+                if (args != null && args.Count > 0)
+                    RhodesApp.createToolBar(barType, (Object)args);
+
+                if (barType == 2)
+                    RhodesApp.removeToolBar();
+            }
+            catch (Exception ex)
+            {
+                Exception rubyEx = self.Context.CurrentException;
+                if (rubyEx == null)
+                {
+                    rubyEx = RubyExceptionData.InitializeException(new RuntimeError(ex.Message.ToString()), ex.Message);
+                }
+                LOG.ERROR("create", ex);
+                throw rubyEx;
+            }
         }
 
         [RubyMethodAttribute("create", RubyMethodAttributes.PublicSingleton)]
         public static void Create(RubyModule/*!*/ self, int barType, Hash args)
         {
-            if (args != null && args.Count > 0)
-                RhodesApp.createToolBar(barType, (Object)args);
-
-            if (barType == 2)
-                RhodesApp.removeToolBar();
+            try
+            {
+                if (args != null && args.Count > 0)
+                    RhodesApp.createToolBar(barType, (Object)args);
+
+                if (barType == 2)
+                    RhodesApp.removeToolBar();
+            }
+            catch (Exception ex)
+            {
+                Exception rubyEx = self.Context.CurrentException;
+                if (rubyEx == null)
+                {
+                    rubyEx = RubyExceptionData.InitializeException(new RuntimeError(ex.Message.ToString()), ex.Message);
+                }
+                LOG.ERROR("create", ex);
+                throw rubyEx;
+            }
         }
 
         [RubyMethodAttribute("remove", RubyMethodAttributes.PublicSingleton)]
         public static void Remove(RubyModule/*!*/ self)
         {
-            RhodesApp.removeToolBar();
+            try
+            {
+                RhodesApp.removeToolBar();
+            }
+            catch (Exception ex)
+            {
+                Exception rubyEx = self.Context.CurrentException;
+                if (rubyEx == null)
+                {
+                    rubyEx = RubyExceptionData.InitializeException(new RuntimeError(ex.Message.ToString()), ex.Message);
+                }
+                LOG.ERROR("remove", ex);
+                throw rubyEx;
+            }
         }
 
         [RubyMethodAttribute("switch_tab", RubyMethodAttributes.PublicSingleton)]
@@ -55,7 +96,23 @@ namespace rho.rubyext
         [RubyMethodAttribute("started", RubyMethodAttributes.PublicSingleton)]
         public static Boolean isStarted(RubyModule/*!*/ self)
         {
-            return RhodesApp.barIsStarted;
+            Boolean res = false;
+            try
+            {
+                res = RhodesApp.barIsStarted;
+            }
+            catch (Exception ex)
+            {
+                Exception rubyEx = self.Context.CurrentException;
+                if (rubyEx == null)
+                {
+                    rubyEx = RubyExceptionData.InitializeException(new RuntimeError(ex.Message.ToString()), ex.Message);
+                }
+                LOG.ERROR("started", ex);
+                throw rubyEx;
+            }
+
+            return res;
         }
 
         [RubyMethodAttribute("set_tab_badge", RubyMethodAttributes.PublicSingleton)]
@@ -67,19 +124,58 @@ namespace rho.rubyext
         [RubyMethodAttribute("create_native_toolbar", RubyMethodAttributes.PublicSingleton)]
         public static void createNativeToolBar(RubyModule/*!*/ self, int barType, RubyArray args)
         {
-            Create(self, barType, args);
+            try
+            {
+                Create(self, barType, args);
+            }
+            catch (Exception ex)
+            {
+                Exception rubyEx = self.Context.CurrentException;
+                if (rubyEx == null)
+                {
+                    rubyEx = RubyExceptionData.InitializeException(new RuntimeError(ex.Message.ToString()), ex.Message);
+                }
+                LOG.ERROR("create_native_toolbar", ex);
+                throw rubyEx;
+            }
         }
 
         [RubyMethodAttribute("create_native_toolbar", RubyMethodAttributes.PublicSingleton)]
         public static void createNativeToolBar(RubyModule/*!*/ self, int barType, Hash args)
         {
-            Create(self, barType, args);
+            try
+            {
+                Create(self, barType, args);
+            }
+            catch (Exception ex)
+            {
+                Exception rubyEx = self.Context.CurrentException;
+                if (rubyEx == null)
+                {
+                    rubyEx = RubyExceptionData.InitializeException(new RuntimeError(ex.Message.ToString()), ex.Message);
+                }
+                LOG.ERROR("create_native_toolbar", ex);
+                throw rubyEx;
+            }
         }
 
         [RubyMethodAttribute("remove_native_toolbar", RubyMethodAttributes.PublicSingleton)]
         public static void removeNativeToolBar(RubyModule/*!*/ self)
         {
-            Remove(self);
+            try
+            {
+                Remove(self);
+            }
+            catch (Exception ex)
+            {
+                Exception rubyEx = self.Context.CurrentException;
+                if (rubyEx == null)
+                {
+                    rubyEx = RubyExceptionData.InitializeException(new RuntimeError(ex.Message.ToString()), ex.Message);
+                }
+                LOG.ERROR("remove_native_toolbar", ex);
+                throw rubyEx;
+            }
         }
 
         [RubyMethodAttribute("create_native_tabbar", RubyMethodAttributes.PublicSingleton)]

data/platform/wp7/RhoRubyLib/rubyext/RhoSyncEngine.cs

@@ -19,69 +19,169 @@ namespace rho.rubyext
         [RubyMethod("dosync", RubyMethodAttributes.PublicSingleton)]
         public static object dosync(RubyModule/*!*/ self)
         {
-            SyncThread.getInstance().addQueueCommand(new SyncThread.SyncCommand(SyncThread.scSyncAll, false));
-            return SyncThread.getInstance().getRetValue();
+            object res = null;
+            try
+            {
+                SyncThread.getInstance().addQueueCommand(new SyncThread.SyncCommand(SyncThread.scSyncAll, false));
+
+                res = SyncThread.getInstance().getRetValue();
+            }
+            catch (Exception ex)
+            {
+                Exception rubyEx = self.Context.CurrentException;
+                if (rubyEx == null)
+                {
+                    rubyEx = RubyExceptionData.InitializeException(new RuntimeError(ex.Message.ToString()), ex.Message);
+                }
+                LOG.ERROR("dosync", ex);
+                throw rubyEx;
+            }
+
+            return res;
         }
 
         [RubyMethod("dosync", RubyMethodAttributes.PublicSingleton)]
         public static object dosync(RubyModule/*!*/ self, bool/*!*/ show_status_popup)
         {
-            SyncThread.getInstance().addQueueCommand(new SyncThread.SyncCommand(SyncThread.scSyncAll, show_status_popup));
-            return SyncThread.getInstance().getRetValue();
+            object res = null;
+            try
+            {
+                SyncThread.getInstance().addQueueCommand(new SyncThread.SyncCommand(SyncThread.scSyncAll, show_status_popup));
+
+                res = SyncThread.getInstance().getRetValue();
+            }
+            catch (Exception ex)
+            {
+                Exception rubyEx = self.Context.CurrentException;
+                if (rubyEx == null)
+                {
+                    rubyEx = RubyExceptionData.InitializeException(new RuntimeError(ex.Message.ToString()), ex.Message);
+                }
+                LOG.ERROR("dosync", ex);
+                throw rubyEx;
+            }
+
+            return res;
         }
 
         [RubyMethod("dosync_source", RubyMethodAttributes.PublicSingleton)]
         public static object dosync_source(RubyModule/*!*/ self, [NotNull]object/*!*/ srcID)
         {
-            int nSrcID = 0;
-			String strName = "";
-            if (srcID is long)
-                nSrcID = (int)(long)srcID;
-            else if (srcID is int)
-                nSrcID = (int)srcID;
-            else
-                strName = srcID.ToString();
+            object res = null;
+            try
+            {
+                int nSrcID = 0;
+                String strName = "";
+                if (srcID is long)
+                    nSrcID = (int)(long)srcID;
+                else if (srcID is int)
+                    nSrcID = (int)srcID;
+                else
+                    strName = srcID.ToString();
+
+                SyncThread.getInstance().addQueueCommand(new SyncThread.SyncCommand(SyncThread.scSyncOne, strName, nSrcID, true));
+
+                res = SyncThread.getInstance().getRetValue();
+            }
+            catch (Exception ex)
+            {
+                Exception rubyEx = self.Context.CurrentException;
+                if (rubyEx == null)
+                {
+                    rubyEx = RubyExceptionData.InitializeException(new RuntimeError(ex.Message.ToString()), ex.Message);
+                }
+                LOG.ERROR("dosync_source", ex);
+                throw rubyEx;
+            }
 
-            SyncThread.getInstance().addQueueCommand(new SyncThread.SyncCommand(SyncThread.scSyncOne, strName, nSrcID, true));
-            return SyncThread.getInstance().getRetValue();
+            return res;
         }
         
         [RubyMethod("dosync_source", RubyMethodAttributes.PublicSingleton)]
         public static object dosync_source(RubyModule/*!*/ self, [NotNull]object/*!*/ srcID, bool/*!*/ show_status_popup)
         {
-            int nSrcID = 0;
-            String strName = "";
-            if (srcID is long)
-                nSrcID = (int)(long)srcID;
-            else if (srcID is int)
-                nSrcID = (int)srcID;
-            else
-                strName = srcID.ToString();
+            object res = null;
+            try
+            {
+                int nSrcID = 0;
+                String strName = "";
+                if (srcID is long)
+                    nSrcID = (int)(long)srcID;
+                else if (srcID is int)
+                    nSrcID = (int)srcID;
+                else
+                    strName = srcID.ToString();
+
+                SyncThread.getInstance().addQueueCommand(new SyncThread.SyncCommand(SyncThread.scSyncOne, strName, nSrcID, show_status_popup));
+
+                res = SyncThread.getInstance().getRetValue();
+            }
+            catch (Exception ex)
+            {
+                Exception rubyEx = self.Context.CurrentException;
+                if (rubyEx == null)
+                {
+                    rubyEx = RubyExceptionData.InitializeException(new RuntimeError(ex.Message.ToString()), ex.Message);
+                }
+                LOG.ERROR("dosync_source", ex);
+                throw rubyEx;
+            }
 
-            SyncThread.getInstance().addQueueCommand(new SyncThread.SyncCommand(SyncThread.scSyncOne, strName, nSrcID, show_status_popup));
-            return SyncThread.getInstance().getRetValue();
+            return res;
         }
 
         [RubyMethod("dosearch", RubyMethodAttributes.PublicSingleton)]
         public static object dosearch(RubyModule/*!*/ self, [NotNull]RubyArray/*!*/ arSourcesR, [NotNull]String/*!*/ from, [NotNull]String/*!*/ strParams,
             [NotNull]bool/*!*/ bSearchSyncChanges, [NotNull]int/*!*/ nProgressStep, String/*!*/ strCallback, String/*!*/ strCallbackParams)
         {
-            SyncThread.stopSync();
+            object res = null;
+            try
+            {
+                SyncThread.stopSync();
 
-			if ( strCallback != null && strCallback.Length > 0 )
-				SyncThread.getSyncEngine().getNotify().setSearchNotification(strCallback, strCallbackParams);
+                if (strCallback != null && strCallback.Length > 0)
+                    SyncThread.getSyncEngine().getNotify().setSearchNotification(strCallback, strCallbackParams);
 
-            Vector<String> arSources = RhoRuby.makeVectorStringFromArray(arSourcesR);
+                Vector<String> arSources = RhoRuby.makeVectorStringFromArray(arSourcesR);
 
-            SyncThread.getInstance().addQueueCommand(new SyncThread.SyncSearchCommand(from, strParams, arSources, bSearchSyncChanges, nProgressStep));        
+                SyncThread.getInstance().addQueueCommand(new SyncThread.SyncSearchCommand(from, strParams, arSources, bSearchSyncChanges, nProgressStep));
+
+                res = SyncThread.getInstance().getRetValue();
+            }
+            catch (Exception ex)
+            {
+                Exception rubyEx = self.Context.CurrentException;
+                if (rubyEx == null)
+                {
+                    rubyEx = RubyExceptionData.InitializeException(new RuntimeError(ex.Message.ToString()), ex.Message);
+                }
+                LOG.ERROR("dosearch", ex);
+                throw rubyEx;
+            }
 
-            return SyncThread.getInstance().getRetValue();
+            return res;
         }
 
         [RubyMethod("logged_in", RubyMethodAttributes.PublicSingleton)]
         public static int logged_in(RubyModule/*!*/ self)
         {
-            return SyncThread.getSyncEngine().isLoggedIn() ? 1 : 0;
+            int res = 0;
+            try
+            {
+                res = SyncThread.getSyncEngine().isLoggedIn() ? 1 : 0;
+            }
+            catch (Exception ex)
+            {
+                Exception rubyEx = self.Context.CurrentException;
+                if (rubyEx == null)
+                {
+                    rubyEx = RubyExceptionData.InitializeException(new RuntimeError(ex.Message.ToString()), ex.Message);
+                }
+                LOG.ERROR("logged_in", ex);
+                throw rubyEx;
+            }
+
+            return res;
         }
 
         [RubyMethod("login", RubyMethodAttributes.PublicSingleton)]
@@ -106,94 +206,269 @@ namespace rho.rubyext
         [RubyMethod("set_notification", RubyMethodAttributes.PublicSingleton)]
         public static void set_notification(RubyModule/*!*/ self, [NotNull]int/*!*/ nSrcID, [NotNull]String/*!*/ url, string/*!*/ callback_param)
         {
-            SyncThread.getSyncEngine().getNotify().setSyncNotification(nSrcID,
-                new SyncNotify.SyncNotification(url, callback_param != null ? callback_param : "", nSrcID != -1));
+            try
+            {
+                SyncThread.getSyncEngine().getNotify().setSyncNotification(nSrcID,
+                    new SyncNotify.SyncNotification(url, callback_param != null ? callback_param : "", nSrcID != -1));
+            }
+            catch (Exception ex)
+            {
+                Exception rubyEx = self.Context.CurrentException;
+                if (rubyEx == null)
+                {
+                    rubyEx = RubyExceptionData.InitializeException(new RuntimeError(ex.Message.ToString()), ex.Message);
+                }
+                LOG.ERROR("set_notification", ex);
+                throw rubyEx;
+            }
         }
 
         [RubyMethod("enable_status_popup", RubyMethodAttributes.PublicSingleton)]
         public static void enable_status_popup(RubyModule/*!*/ self, bool/*!*/ bEnable)
         {
-            SyncThread.getSyncEngine().getNotify().enableStatusPopup(bEnable);
+            try
+            {
+                SyncThread.getSyncEngine().getNotify().enableStatusPopup(bEnable);
+            }
+            catch (Exception ex)
+            {
+                Exception rubyEx = self.Context.CurrentException;
+                if (rubyEx == null)
+                {
+                    rubyEx = RubyExceptionData.InitializeException(new RuntimeError(ex.Message.ToString()), ex.Message);
+                }
+                LOG.ERROR("enable_status_popup", ex);
+                throw rubyEx;
+            }
         }
 
         [RubyMethod("is_blob_attr", RubyMethodAttributes.PublicSingleton)]
         public static bool is_blob_attr(RubyModule/*!*/ self, [NotNull]String/*!*/ strPartition, [NotNull]int/*!*/ nSrcID, [NotNull]String/*!*/ strAttrName)
         {
-            return DBAdapter.getDB(strPartition).getAttrMgr().isBlobAttr(nSrcID, strAttrName);
+            bool res = false;
+            try
+            {
+                res = DBAdapter.getDB(strPartition).getAttrMgr().isBlobAttr(nSrcID, strAttrName);
+            }
+            catch (Exception ex)
+            {
+                Exception rubyEx = self.Context.CurrentException;
+                if (rubyEx == null)
+                {
+                    rubyEx = RubyExceptionData.InitializeException(new RuntimeError(ex.Message.ToString()), ex.Message);
+                }
+                LOG.ERROR("is_blob_attr", ex);
+                throw rubyEx;
+            }
+
+            return res;
         }
 
         [RubyMethod("update_blob_attribs", RubyMethodAttributes.PublicSingleton)]
         public static void update_blob_attribs(RubyModule/*!*/ self, [NotNull]String/*!*/ strPartition, [NotNull]int/*!*/ srcID)
         {
-            DBAdapter db = DBAdapter.getDB(strPartition);
-            db.getAttrMgr().loadBlobAttrs(db);
+            try
+            {
+                DBAdapter db = DBAdapter.getDB(strPartition);
+                db.getAttrMgr().loadBlobAttrs(db);
+            }
+            catch (Exception ex)
+            {
+                Exception rubyEx = self.Context.CurrentException;
+                if (rubyEx == null)
+                {
+                    rubyEx = RubyExceptionData.InitializeException(new RuntimeError(ex.Message.ToString()), ex.Message);
+                }
+                LOG.ERROR("update_blob_attribs", ex);
+                throw rubyEx;
+            }
         }
 
         [RubyMethod("set_threaded_mode", RubyMethodAttributes.PublicSingleton)]
         public static void set_threaded_mode(RubyModule/*!*/ self, [NotNull]bool/*!*/ bThreadMode)
         {
-            SyncThread.getInstance().setNonThreadedMode(!bThreadMode);
-            SyncThread.getSyncEngine().setNonThreadedMode(!bThreadMode);
+            try
+            {
+                SyncThread.getInstance().setNonThreadedMode(!bThreadMode);
+                SyncThread.getSyncEngine().setNonThreadedMode(!bThreadMode);
+            }
+            catch (Exception ex)
+            {
+                Exception rubyEx = self.Context.CurrentException;
+                if (rubyEx == null)
+                {
+                    rubyEx = RubyExceptionData.InitializeException(new RuntimeError(ex.Message.ToString()), ex.Message);
+                }
+                LOG.ERROR("set_threaded_mode", ex);
+                throw rubyEx;
+            }
         }
 
         [RubyMethod("logout", RubyMethodAttributes.PublicSingleton)]
         public static void logout(RubyModule/*!*/ self)
         {
-            SyncThread.stopSync();
-            SyncThread.getSyncEngine().stopSyncByUser();
-            SyncThread.getSyncEngine().logout();
+            try
+            {
+                SyncThread.stopSync();
+                SyncThread.getSyncEngine().stopSyncByUser();
+                SyncThread.getSyncEngine().logout();
+            }
+            catch (Exception ex)
+            {
+                Exception rubyEx = self.Context.CurrentException;
+                if (rubyEx == null)
+                {
+                    rubyEx = RubyExceptionData.InitializeException(new RuntimeError(ex.Message.ToString()), ex.Message);
+                }
+                LOG.ERROR("logout", ex);
+                throw rubyEx;
+            }
         }
 
         [RubyMethod("set_syncserver", RubyMethodAttributes.PublicSingleton)]
         public static void set_syncserver(RubyModule/*!*/ self, [NotNull]String/*!*/ syncserver)
         {
-            SyncThread.stopSync();
-            SyncThread.getSyncEngine().setSyncServer(syncserver);
 
-            if (syncserver != null && syncserver.length() > 0)
+            try
             {
-                SyncThread.getInstance().start(SyncThread.epLow);
-                if (ClientRegister.getInstance() != null)
-                    ClientRegister.getInstance().startUp();
+                SyncThread.stopSync();
+                SyncThread.getSyncEngine().setSyncServer(syncserver);
+
+                if (syncserver != null && syncserver.length() > 0)
+                {
+                    SyncThread.getInstance().start(SyncThread.epLow);
+                    if (ClientRegister.getInstance() != null)
+                        ClientRegister.getInstance().startUp();
+                }
+            }
+            catch (Exception ex)
+            {
+                Exception rubyEx = self.Context.CurrentException;
+                if (rubyEx == null)
+                {
+                    rubyEx = RubyExceptionData.InitializeException(new RuntimeError(ex.Message.ToString()), ex.Message);
+                }
+                LOG.ERROR("set_syncserver", ex);
+                throw rubyEx;
             }
         }
 
         [RubyMethod("set_pollinterval", RubyMethodAttributes.PublicSingleton)]
         public static int set_pollinterval(RubyModule/*!*/ self, [NotNull]int/*!*/ nInterval)
         {
-            int nOldInterval = SyncThread.getInstance().getPollInterval();
-            SyncThread.getInstance().setPollInterval(nInterval);
+            int nOldInterval = 0;
+            try
+            {
+                nOldInterval = SyncThread.getInstance().getPollInterval();
+                SyncThread.getInstance().setPollInterval(nInterval);
+            }
+            catch (Exception ex)
+            {
+                Exception rubyEx = self.Context.CurrentException;
+                if (rubyEx == null)
+                {
+                    rubyEx = RubyExceptionData.InitializeException(new RuntimeError(ex.Message.ToString()), ex.Message);
+                }
+                LOG.ERROR("set_pollinterval", ex);
+                throw rubyEx;
+            }
+
             return nOldInterval;
         }
 
         [RubyMethod("stop_sync", RubyMethodAttributes.PublicSingleton)]
         public static void set_pollinterval(RubyModule/*!*/ self)
         {
-            SyncThread.stopSync();
+            try
+            {
+                SyncThread.stopSync();
+            }
+            catch (Exception ex)
+            {
+                Exception rubyEx = self.Context.CurrentException;
+                if (rubyEx == null)
+                {
+                    rubyEx = RubyExceptionData.InitializeException(new RuntimeError(ex.Message.ToString()), ex.Message);
+                }
+                LOG.ERROR("stop_sync", ex);
+                throw rubyEx;
+            }
         }
 
         [RubyMethod("set_source_property", RubyMethodAttributes.PublicSingleton)]
         public static void set_source_property(RubyModule/*!*/ self, [NotNull]int/*!*/ nSrcID, [NotNull]String/*!*/ strPropName, [NotNull]String/*!*/ strPropValue)
         {
-            SyncEngine.getSourceOptions().setProperty(nSrcID, strPropName, strPropValue);
+            try
+            {
+                SyncEngine.getSourceOptions().setProperty(nSrcID, strPropName, strPropValue);
+            }
+            catch (Exception ex)
+            {
+                Exception rubyEx = self.Context.CurrentException;
+                if (rubyEx == null)
+                {
+                    rubyEx = RubyExceptionData.InitializeException(new RuntimeError(ex.Message.ToString()), ex.Message);
+                }
+                LOG.ERROR("set_source_property", ex);
+                throw rubyEx;
+            }
         }
 
         [RubyMethod("set_objectnotify_url", RubyMethodAttributes.PublicSingleton)]
         public static void set_objectnotify_url(RubyModule/*!*/ self, [DefaultProtocol, NotNull]string/*!*/ url)
         {
-            SyncNotify.setObjectNotifyUrl(url);
+            try
+            {
+                SyncNotify.setObjectNotifyUrl(url);
+            }
+            catch (Exception ex)
+            {
+                Exception rubyEx = self.Context.CurrentException;
+                if (rubyEx == null)
+                {
+                    rubyEx = RubyExceptionData.InitializeException(new RuntimeError(ex.Message.ToString()), ex.Message);
+                }
+                LOG.ERROR("set_objectnotify_url", ex);
+                throw rubyEx;
+            }
         }
 
         [RubyMethod("add_objectnotify", RubyMethodAttributes.PublicSingleton)]
         public static void add_objectnotify(RubyModule/*!*/ self, [NotNull]int/*!*/ nSrcID, [NotNull]string/*!*/ strObject)
         {
-            SyncThread.getSyncEngine().getNotify().addObjectNotify(nSrcID, strObject);
+            try
+            {
+                SyncThread.getSyncEngine().getNotify().addObjectNotify(nSrcID, strObject);
+            }
+            catch (Exception ex)
+            {
+                Exception rubyEx = self.Context.CurrentException;
+                if (rubyEx == null)
+                {
+                    rubyEx = RubyExceptionData.InitializeException(new RuntimeError(ex.Message.ToString()), ex.Message);
+                }
+                LOG.ERROR("add_objectnotify", ex);
+                throw rubyEx;
+            }
         }
 
         [RubyMethod("clean_objectnotify", RubyMethodAttributes.PublicSingleton)]
         public static void clean_objectnotify(RubyModule/*!*/ self)
         {
-            SyncThread.getSyncEngine().getNotify().cleanObjectNotifications();
+            try
+            {
+                SyncThread.getSyncEngine().getNotify().cleanObjectNotifications();
+            }
+            catch (Exception ex)
+            {
+                Exception rubyEx = self.Context.CurrentException;
+                if (rubyEx == null)
+                {
+                    rubyEx = RubyExceptionData.InitializeException(new RuntimeError(ex.Message.ToString()), ex.Message);
+                }
+                LOG.ERROR("clean_objectnotify", ex);
+                throw rubyEx;
+            }
         }
     }
 }