コード例 #1
0
ファイル: CatalogCache.cs プロジェクト: laszlo-kiss/Dataphor
 private void PopulateDefaultCachedObjects(Schema.Catalog defaultCachedObjects)
 {
     foreach (Schema.Object objectValue in defaultCachedObjects)
     {
         _cachedObjects.Add(objectValue);
     }
 }
コード例 #2
0
ファイル: Engine.cs プロジェクト: cybernetics/Dataphor
 private void InternalCreateCatalog()
 {
     _catalog   = new Schema.Catalog();
     _planCache = new PlanCache(DefaultPlanCacheSize);
     if (_streamManager == null)
     {
         _streamManager = new ServerStreamManager(this);
     }
 }
コード例 #3
0
        private void CatalogLookupFailed(Schema.Catalog catalog, string name)
        {
                        #if LOGCACHEEVENTS
            FSession.FServer.FInternalServer.LogMessage(String.Format("Retrieving catalog for '{0}'.", AName));
                        #endif

            // A cache miss forces the retrieval of the datatype and its dependencies from the remote server process
            long   cacheTimeStamp;
            long   clientCacheTimeStamp;
            bool   cacheChanged;
            string stringValue = _process.GetCatalog(name, out cacheTimeStamp, out clientCacheTimeStamp, out cacheChanged);

            // Ensure that the local cache is consistent before adding to the cache
            if (cacheChanged)
            {
                try
                {
                    _session._server.WaitForCacheTimeStamp(this, clientCacheTimeStamp - 1);
                    _session._server.AcquireCacheLock(this, LockMode.Exclusive);
                    try
                    {
                        _session._server.EnsureCacheConsistent(cacheTimeStamp);
                        if (stringValue != String.Empty)
                        {
                            IServerScript script = ((IServerProcess)_internalProcess).PrepareScript(stringValue);
                            try
                            {
                                script.Execute(null);
                            }
                            finally
                            {
                                ((IServerProcess)_internalProcess).UnprepareScript(script);
                            }
                        }
                    }
                    finally
                    {
                        _session._server.ReleaseCacheLock(this, LockMode.Exclusive);
                    }
                }
                catch (Exception E)
                {
                    // Notify the server that the client cache is out of sync
                    Execute(".System.UpdateTimeStamps();", null);
                    E = new ServerException(ServerException.Codes.CacheDeserializationError, E, clientCacheTimeStamp);
                    _session._server._internalServer.LogError(E);
                    throw E;
                }
                finally
                {
                    _session._server.SetCacheTimeStamp(this, clientCacheTimeStamp);
                }
            }
        }
コード例 #4
0
ファイル: CatalogCache.cs プロジェクト: laszlo-kiss/Dataphor
 public bool EnsureConsistent(long cacheTimeStamp, Schema.Catalog defaultCachedObjects)
 {
     if (cacheTimeStamp > _cacheTimeStamp)
     {
         _cachedObjects.Clear();
         _cacheTimeStamp = cacheTimeStamp;
         PopulateDefaultCachedObjects(defaultCachedObjects);
         UpdateTimeStamp();
         return(true);
     }
     return(false);
 }
コード例 #5
0
 public void EnsureCacheConsistent(long serverCacheTimeStamp)
 {
     if (_serverCacheTimeStamp < serverCacheTimeStamp)
     {
         DoCacheClearing();
         Schema.Catalog catalog       = _internalServer.Catalog;
         var            catalogDevice = _internalServer.CatalogDevice;
         _internalServer.ClearCatalog();
         foreach (Schema.RegisteredAssembly assembly in catalog.ClassLoader.Assemblies)
         {
             if (assembly.Library.Name != Engine.SystemLibraryName)
             {
                 _internalServer.Catalog.ClassLoader.Assemblies.Add(assembly);
             }
         }
         foreach (Schema.RegisteredClass classValue in catalog.ClassLoader.Classes)
         {
             if (!_internalServer.Catalog.ClassLoader.Classes.Contains(classValue))
             {
                 _internalServer.Catalog.ClassLoader.Classes.Add(classValue);
             }
         }
         foreach (ServerSession session in _internalServer.Sessions)
         {
             if (session.User.ID == _internalServer.SystemUser.ID)
             {
                 session.SetUser(_internalServer.SystemUser);
             }
             if (session.User.ID == _internalServer.AdminUser.ID)
             {
                 session.SetUser(_internalServer.AdminUser);
             }
             session.SessionObjects.Clear();
             foreach (ServerProcess process in session.Processes)
             {
                 process.DeviceDisconnect(catalogDevice);
             }
         }
         _serverCacheTimeStamp = serverCacheTimeStamp;
         DoCacheCleared();
     }
 }
コード例 #6
0
        public string GetCatalog(string name, out long cacheTimeStamp, out long clientCacheTimeStamp, out bool cacheChanged)
        {
            cacheTimeStamp = _serverProcess.ServerSession.Server.CacheTimeStamp;

            Schema.Catalog catalog = new Schema.Catalog();
            catalog.IncludeDependencies(_serverProcess.CatalogDeviceSession, _serverProcess.Catalog, _serverProcess.Catalog[name], EmitMode.ForRemote);

                        #if LOGCACHEEVENTS
            FServerProcess.ServerSession.Server.LogMessage(String.Format("Getting catalog for data type '{0}'.", AName));
                        #endif

            cacheChanged = true;
            string[] requiredObjects = _session.Server.CatalogCaches.GetRequiredObjects(_session, catalog, cacheTimeStamp, out clientCacheTimeStamp);
            if (requiredObjects.Length > 0)
            {
                string catalogString = new D4TextEmitter(EmitMode.ForRemote).Emit(catalog.EmitStatement(_serverProcess.CatalogDeviceSession, EmitMode.ForRemote, requiredObjects));
                return(catalogString);
            }
            return(String.Empty);
        }
コード例 #7
0
ファイル: CatalogCache.cs プロジェクト: laszlo-kiss/Dataphor
        public string[] GetRequiredObjects(RemoteServerSession session, Schema.Catalog catalog, long cacheTimeStamp, out long clientCacheTimeStamp)
        {
            List <string> requiredObjects = new List <string>();
            CatalogCache  cache           = (CatalogCache)_caches[session.CatalogCacheName];

            lock (cache)
            {
                bool cacheChanged = cache.EnsureConsistent(cacheTimeStamp, _defaultCachedObjects);
                foreach (Schema.Object objectValue in catalog)
                {
                    if (!cache.CachedObjects.ContainsName(objectValue.Name))
                    {
                        if (!((objectValue is Schema.DerivedTableVar) && (objectValue.Name == ((Schema.DerivedTableVar)objectValue).SessionObjectName)))
                        {
                            cache.CachedObjects.Add(objectValue);
                        }
                        requiredObjects.Add(objectValue.Name);
                    }
                }

                if (!cacheChanged)
                {
                    cache.UpdateTimeStamp();
                }

                clientCacheTimeStamp = cache.TimeStamp;
            }

            string[] result = new string[requiredObjects.Count];
            requiredObjects.CopyTo(result, 0);

                        #if LOGCACHEEVENTS
            ASession.Server.LogMessage(String.Format("Session {0} cache timestamp updated to {1} with required objects: {2}", ASession.SessionID.ToString(), AClientCacheTimeStamp.ToString(), ExceptionUtility.StringsToCommaList(requiredObjects)));
                        #endif

            return(result);
        }
コード例 #8
0
ファイル: CatalogCache.cs プロジェクト: laszlo-kiss/Dataphor
 public CatalogCache(string cacheName, long cacheTimeStamp, Schema.Catalog defaultCachedObjects) : base()
 {
     _cacheName      = cacheName;
     _cacheTimeStamp = cacheTimeStamp;
     PopulateDefaultCachedObjects(defaultCachedObjects);
 }