Пример #1
0
 public override void ice_invoke_async(Ice.AMD_Object_ice_invoke cb, byte[] inParams, Ice.Current current)
 {
     Ice.Communicator communicator = current.adapter.getCommunicator();
     Ice.InputStream inS = Ice.Util.createInputStream(communicator, inParams);
     Ice.OutputStream outS = Ice.Util.createOutputStream(communicator);
     if(current.operation.Equals("opOneway"))
     {
         cb.ice_response(true, new byte[0]);
     }
     else if(current.operation.Equals("opString"))
     {
         string s = inS.readString();
         outS.writeString(s);
         outS.writeString(s);
         cb.ice_response(true, outS.finished());
     }
     else if(current.operation.Equals("opException"))
     {
         Test.MyException ex = new Test.MyException();
         outS.writeException(ex);
         cb.ice_response(false, outS.finished());
     }
     else if(current.operation.Equals("shutdown"))
     {
         communicator.shutdown();
         cb.ice_response(true, null);
     }
     else if(current.operation.Equals("ice_isA"))
     {
         string s = inS.readString();
         if(s.Equals("::Test::MyClass"))
         {
             outS.writeBool(true);
         }
         else
         {
             outS.writeBool(false);
         }
         cb.ice_response(true, outS.finished());
     }
     else
     {
         Ice.OperationNotExistException ex = new Ice.OperationNotExistException();
         ex.id = current.id;
         ex.facet = current.facet;
         ex.operation = current.operation;
         throw ex;
     }
 }
Пример #2
0
    public override void findAdapterById_async(Ice.AMD_Locator_findAdapterById response, string adapter,
                                               Ice.Current current)
    {
        ++_requestCount;
        if(adapter.Equals("TestAdapter10") || adapter.Equals("TestAdapter10-2"))
        {
            Debug.Assert(current.encoding.Equals(Ice.Util.Encoding_1_0));
            response.ice_response(_registry.getAdapter("TestAdapter"));
            return;
        }

        // We add a small delay to make sure locator request queuing gets tested when
        // running the test on a fast machine
        System.Threading.Thread.Sleep(1);
        response.ice_response(_registry.getAdapter(adapter));
    }
Пример #3
0
 public override void findAdapterById_async(Ice.AMD_Locator_findAdapterById response, string adapter,
                                            Ice.Current current)
 {
     _controller.checkCallPause(current);
     Ice.Communicator communicator = current.adapter.getCommunicator();
     response.ice_response(current.adapter.createDirectProxy(communicator.stringToIdentity("dummy")));
 }
Пример #4
0
 setServerProcessProxy_async(Ice.AMD_LocatorRegistry_setServerProcessProxy cb, 
                             string id, 
                             Ice.ProcessPrx process,
                             Ice.Current current)
 {
     cb.ice_response();
 }
Пример #5
0
 setReplicatedAdapterDirectProxy_async(Ice.AMD_LocatorRegistry_setReplicatedAdapterDirectProxy cb,
                                       string adapterId,
                                       string replicaGroupId,
                                       Ice.ObjectPrx proxy, 
                                       Ice.Current current)
 {
     lock(this)
     {
         if(proxy != null)
         {
             _adapters.Add(adapterId, proxy);
             HashSet<string> adapterIds;
             if(!_replicaGroups.TryGetValue(replicaGroupId, out adapterIds))
             {
                 adapterIds = new HashSet<string>();
                 _replicaGroups.Add(replicaGroupId, adapterIds);
             }
             adapterIds.Add(adapterId);
         }
         else
         {
             _adapters.Remove(adapterId);
             HashSet<string> adapterIds;
             if(_replicaGroups.TryGetValue(replicaGroupId, out adapterIds))
             {
                 adapterIds.Remove(adapterId);
                 if(adapterIds.Count == 0)
                 {
                     _replicaGroups.Remove(replicaGroupId);
                 }
             }
         }
     }
     cb.ice_response();
 }
Пример #6
0
 public override void findObjectById_async(Ice.AMD_Locator_findObjectById response, Ice.Identity id,
                                           Ice.Current current)
 {
     ++_requestCount;
     // We add a small delay to make sure locator request queuing gets tested when
     // running the test on a fast machine
     System.Threading.Thread.Sleep(1);
     response.ice_response(_registry.getObject(id));
 }
Пример #7
0
 public override void setAdapterDirectProxy_async(Ice.AMD_LocatorRegistry_setAdapterDirectProxy cb, string adapter,
             Ice.ObjectPrx obj, Ice.Current current)
 {
     if(obj != null)
     {
         _adapters[adapter] = obj;
     }
     else
     {
         _adapters.Remove(adapter);
     }
     cb.ice_response();
 }
Пример #8
0
    public override void ice_invoke_async(Ice.AMD_Object_ice_invoke amdCb, byte[] inEncaps, Ice.Current current)
    {
        bool twoway = current.requestId > 0;
        Ice.ObjectPrx obj = current.con.createProxy(current.id);
        if(!twoway)
        {
            if(_startBatch)
            {
                _startBatch = false;
                _batchProxy = obj.ice_batchOneway();
            }
            if(_batchProxy != null)
            {
                obj = _batchProxy;
            }

            if(current.facet.Length != 0)
            {
                obj = obj.ice_facet(current.facet);
            }

            if(_batchProxy != null)
            {
                byte[] outEncaps;
                obj.ice_invoke(current.operation, current.mode, inEncaps, out outEncaps, current.ctx);
                amdCb.ice_response(true, new byte[0]);
            }
            else
            {
                Callback cb = new Callback(amdCb, false);
                obj.ice_oneway().begin_ice_invoke(current.operation,
                                                  current.mode,
                                                  inEncaps,
                                                  current.ctx).whenCompleted(cb.response, cb.exception)
                                                              .whenSent(cb.sent);
            }
        }
        else
        {
            if(current.facet.Length != 0)
            {
                obj = obj.ice_facet(current.facet);
            }
            Callback cb = new Callback(amdCb, true);
            obj.begin_ice_invoke(current.operation,
                                 current.mode,
                                 inEncaps,
                                 current.ctx).whenCompleted(cb.response, cb.exception).whenSent(cb.sent);
        }
    }
Пример #9
0
 setAdapterDirectProxy_async(Ice.AMD_LocatorRegistry_setAdapterDirectProxy cb, 
                             string adapterId, 
                             Ice.ObjectPrx proxy, 
                             Ice.Current current)
 {
     lock(this)
     {
         if(proxy != null)
         {
             _adapters.Add(adapterId, proxy);
         }
         else
         {
             _adapters.Remove(adapterId);
         }
         cb.ice_response();
     }
 }
Пример #10
0
 public override void findObjectById_async(Ice.AMD_Locator_findObjectById amdCB, Ice.Identity id, Ice.Current current)
 {
     amdCB.ice_response(null);
 }
Пример #11
0
 public override void findAdapterById_async(Ice.AMD_Locator_findAdapterById amdCB, String id, Ice.Current current)
 {
     amdCB.ice_response(null);
 }
Пример #12
0
 public override void findObjectById_async(Ice.AMD_Locator_findObjectById response, Ice.Identity id,
                                           Ice.Current current)
 {
     _controller.checkCallPause(current);
     response.ice_response(current.adapter.createDirectProxy(id));
 }
Пример #13
0
        public override void setProperties_async(Ice.AMD_PropertiesAdmin_setProperties cb, 
                                                 Dictionary<string, string> props,
                                                 Ice.Current current)
        {
            lock(this)
            {
                Dictionary<string, string> old = _properties.getPropertiesForPrefix("");
                int traceLevel = _properties.getPropertyAsInt("Ice.Trace.Admin.Properties");

                //
                // Compute the difference between the new property set and the existing property set:
                //
                // 1) Any properties in the new set that were not defined in the existing set.
                //
                // 2) Any properties that appear in both sets but with different values.
                //
                // 3) Any properties not present in the new set but present in the existing set.
                //    In other words, the property has been removed.
                //
                Dictionary<string, string> added = new Dictionary<string, string>();
                Dictionary<string, string> changed = new Dictionary<string, string>();
                Dictionary<string, string> removed = new Dictionary<string, string>();
                foreach(KeyValuePair<string, string> e in props)
                {
                    string key = e.Key;
                    string value = e.Value;
                    if(!old.ContainsKey(key))
                    {
                        if(value.Length > 0)
                        {
                            //
                            // This property is new.
                            //
                            added.Add(key, value);
                        }
                    }
                    else
                    {
                        string v;
                        if(!old.TryGetValue(key, out v) || !value.Equals(v))
                        {
                            if(value.Length == 0)
                            {
                                //
                                // This property was removed.
                                //
                                removed.Add(key, value);
                            }
                            else
                            {
                                //
                                // This property has changed.
                                //
                                changed.Add(key, value);
                            }
                        }

                        old.Remove(key);
                    }
                }

                if(traceLevel > 0 && (added.Count > 0 || changed.Count > 0 || removed.Count > 0))
                {
                    System.Text.StringBuilder message = new System.Text.StringBuilder("Summary of property changes");

                    if(added.Count > 0)
                    {
                        message.Append("\nNew properties:");
                        foreach(KeyValuePair<string, string> e in added)
                        {
                            message.Append("\n  ");
                            message.Append(e.Key);
                            if(traceLevel > 1)
                            {
                                message.Append(" = ");
                                message.Append(e.Value);
                            }
                        }
                    }

                    if(changed.Count > 0)
                    {
                        message.Append("\nChanged properties:");
                        foreach(KeyValuePair<string, string> e in changed)
                        {
                            message.Append("\n  ");
                            message.Append(e.Key);
                            if(traceLevel > 1)
                            {
                                message.Append(" = ");
                                message.Append(e.Value);
                                message.Append(" (old value = ");
                                message.Append(_properties.getProperty(e.Key));
                                message.Append(")");
                            }
                        }
                    }

                    if(removed.Count > 0)
                    {
                        message.Append("\nRemoved properties:");
                        foreach(KeyValuePair<string, string> e in removed)
                        {
                            message.Append("\n  ");
                            message.Append(e.Key);
                        }
                    }

                    _logger.trace(_traceCategory, message.ToString());
                }

                //
                // Update the property set.
                //

                foreach(KeyValuePair<string, string> e in added)
                {
                    _properties.setProperty(e.Key, e.Value);
                }

                foreach(KeyValuePair<string, string> e in changed)
                {
                    _properties.setProperty(e.Key, e.Value);
                }

                foreach(KeyValuePair<string, string> e in removed)
                {
                    _properties.setProperty(e.Key, "");
                }

                //
                // Send the response now so that we do not block the client during the call to the update callback.
                //
                cb.ice_response();

                if(_updateCallbacks.Count > 0)
                {
                    //
                    // Copy the callbacks to allow callbacks to update the callbacks.
                    //
                    List<Ice.PropertiesAdminUpdateCallback> callbacks =
                        new List<Ice.PropertiesAdminUpdateCallback>(_updateCallbacks);

                    Dictionary<string, string> changes = new Dictionary<string, string>(added);
                    foreach(KeyValuePair<string, string> e in changed)
                    {
                        changes.Add(e.Key, e.Value);
                    }
                    foreach(KeyValuePair<string, string> e in removed)
                    {
                        changes.Add(e.Key, e.Value);
                    }
                    
                    foreach(Ice.PropertiesAdminUpdateCallback callback in callbacks)
                    {
                        try
                        {
                            callback.updated(changes);
                        }
                        catch(System.Exception)
                        {
                            // Ignore.
                        }
                    }
                }
            }
        }