java/src/IceInternal/ServantManager.java

   1 // **********************************************************************
   2 //
   3 // Copyright (c) 2003-2011 ZeroC, Inc. All rights reserved.
   4 //
   5 // This copy of Ice is licensed to you under the terms described in the
   6 // ICE_LICENSE file included in this distribution.
   7 //
   8 // **********************************************************************
   9
  10 package IceInternal;
  11
  12 public final class ServantManager
  13 {
  14     public synchronized void
  15     addServant(Ice.Object servant, Ice.Identity ident, String facet)
  16     {
  17         assert(_instance != null); // Must not be called after destruction.
  18
  19         if(facet == null)
  20         {
  21             facet = "";
  22         }
  23
  24         java.util.Map<String, Ice.Object> m = _servantMapMap.get(ident);
  25         if(m == null)
  26         {
  27             m = new java.util.HashMap<String, Ice.Object>();
  28             _servantMapMap.put(ident, m);
  29         }
  30         else
  31         {
  32             if(m.containsKey(facet))
  33             {
  34                 Ice.AlreadyRegisteredException ex = new Ice.AlreadyRegisteredException();
  35                 ex.id = _instance.identityToString(ident);
  36                 ex.kindOfObject = "servant";
  37                 if(facet.length() > 0)
  38                 {
  39                     ex.id += " -f " + IceUtilInternal.StringUtil.escapeString(facet, "");
  40                 }
  41                 throw ex;
  42             }
  43         }
  44
  45         m.put(facet, servant);
  46     }
  47
  48     public synchronized void
  49     addDefaultServant(Ice.Object servant, String category)
  50     {
  51         assert(_instance != null); // Must not be called after destruction
  52
  53         Ice.Object obj = _defaultServantMap.get(category);
  54         if(obj != null)
  55         {
  56             Ice.AlreadyRegisteredException ex = new Ice.AlreadyRegisteredException();
  57             ex.kindOfObject = "default servant";
  58             ex.id = category;
  59             throw ex;
  60         }
  61
  62         _defaultServantMap.put(category, servant);
  63     }
  64
  65     public synchronized Ice.Object
  66     removeServant(Ice.Identity ident, String facet)
  67     {
  68         assert(_instance != null); // Must not be called after destruction.
  69
  70         if(facet == null)
  71         {
  72             facet = "";
  73         }
  74
  75         java.util.Map<String, Ice.Object> m = _servantMapMap.get(ident);
  76         Ice.Object obj = null;
  77         if(m == null || (obj = m.remove(facet)) == null)
  78         {
  79             Ice.NotRegisteredException ex = new Ice.NotRegisteredException();
  80             ex.id = _instance.identityToString(ident);
  81             ex.kindOfObject = "servant";
  82             if(facet.length() > 0)
  83             {
  84                 ex.id += " -f " + IceUtilInternal.StringUtil.escapeString(facet, "");
  85             }
  86             throw ex;
  87         }
  88
  89         if(m.isEmpty())
  90         {
  91             _servantMapMap.remove(ident);
  92         }
  93         return obj;
  94     }
  95
  96     public synchronized Ice.Object
  97     removeDefaultServant(String category)
  98     {
  99         assert(_instance != null); // Must not be called after destruction.
 100
 101         Ice.Object obj = _defaultServantMap.get(category);
 102         if(obj == null)
 103         {
 104             Ice.NotRegisteredException ex = new Ice.NotRegisteredException();
 105             ex.kindOfObject = "default servant";
 106             ex.id = category;
 107             throw ex;
 108         }
 109
 110         _defaultServantMap.remove(category);
 111         return obj;
 112     }
 113
 114     public synchronized java.util.Map<String, Ice.Object>
 115     removeAllFacets(Ice.Identity ident)
 116     {
 117         assert(_instance != null); // Must not be called after destruction.
 118
 119         java.util.Map<String, Ice.Object> m = _servantMapMap.get(ident);
 120         if(m == null)
 121         {
 122             Ice.NotRegisteredException ex = new Ice.NotRegisteredException();
 123             ex.id = _instance.identityToString(ident);
 124             ex.kindOfObject = "servant";
 125             throw ex;
 126         }
 127
 128         _servantMapMap.remove(ident);
 129
 130         return m;
 131     }
 132
 133     public synchronized Ice.Object
 134     findServant(Ice.Identity ident, String facet)
 135     {
 136         //
 137         // This assert is not valid if the adapter dispatch incoming
 138         // requests from bidir connections. This method might be called if
 139         // requests are received over the bidir connection after the
 140         // adapter was deactivated.
 141         //
 142         //assert(_instance != null); // Must not be called after destruction.
 143
 144         if(facet == null)
 145         {
 146             facet = "";
 147         }
 148
 149         java.util.Map<String, Ice.Object> m = _servantMapMap.get(ident);
 150         Ice.Object obj = null;
 151         if(m == null)
 152         {
 153             obj = _defaultServantMap.get(ident.category);
 154             if(obj == null)
 155             {
 156                 obj = _defaultServantMap.get("");
 157             }
 158         }
 159         else
 160         {
 161             obj = m.get(facet);
 162         }
 163
 164         return obj;
 165     }
 166
 167     public synchronized Ice.Object
 168     findDefaultServant(String category)
 169     {
 170         assert(_instance != null); // Must not be called after destruction.
 171
 172         return _defaultServantMap.get(category);
 173     }
 174
 175     public synchronized java.util.Map<String, Ice.Object>
 176     findAllFacets(Ice.Identity ident)
 177     {
 178         assert(_instance != null); // Must not be called after destruction.
 179
 180         java.util.Map<String, Ice.Object> m = _servantMapMap.get(ident);
 181         if(m != null)
 182         {
 183             return new java.util.HashMap<String, Ice.Object>(m);
 184         }
 185
 186         return new java.util.HashMap<String, Ice.Object>();
 187     }
 188
 189     public synchronized boolean
 190     hasServant(Ice.Identity ident)
 191     {
 192         //
 193         // This assert is not valid if the adapter dispatch incoming
 194         // requests from bidir connections. This method might be called if
 195         // requests are received over the bidir connection after the
 196         // adapter was deactivated.
 197         //
 198         //assert(_instance != null); // Must not be called after destruction.
 199
 200         java.util.Map<String, Ice.Object> m = _servantMapMap.get(ident);
 201         if(m == null)
 202         {
 203             return false;
 204         }
 205         else
 206         {
 207             assert(!m.isEmpty());
 208             return true;
 209         }
 210     }
 211
 212     public synchronized void
 213     addServantLocator(Ice.ServantLocator locator, String category)
 214     {
 215         assert(_instance != null); // Must not be called after destruction.
 216
 217         Ice.ServantLocator l = _locatorMap.get(category);
 218         if(l != null)
 219         {
 220             Ice.AlreadyRegisteredException ex = new Ice.AlreadyRegisteredException();
 221             ex.id = IceUtilInternal.StringUtil.escapeString(category, "");
 222             ex.kindOfObject = "servant locator";
 223             throw ex;
 224         }
 225
 226         _locatorMap.put(category, locator);
 227     }
 228
 229     public synchronized Ice.ServantLocator
 230     removeServantLocator(String category)
 231     {
 232         Ice.ServantLocator l = null;
 233         assert(_instance != null); // Must not be called after destruction.
 234
 235         l = _locatorMap.remove(category);
 236         if(l == null)
 237         {
 238             Ice.NotRegisteredException ex = new Ice.NotRegisteredException();
 239             ex.id = IceUtilInternal.StringUtil.escapeString(category, "");
 240             ex.kindOfObject = "servant locator";
 241             throw ex;
 242         }
 243         return l;
 244     }
 245
 246     public synchronized Ice.ServantLocator
 247     findServantLocator(String category)
 248     {
 249         //
 250         // This assert is not valid if the adapter dispatch incoming
 251         // requests from bidir connections. This method might be called if
 252         // requests are received over the bidir connection after the
 253         // adapter was deactivated.
 254         //
 255         //assert(_instance != null); // Must not be called after destruction.
 256
 257         return _locatorMap.get(category);
 258     }
 259
 260     //
 261     // Only for use by Ice.ObjectAdatperI.
 262     //
 263     public
 264     ServantManager(Instance instance, String adapterName)
 265     {
 266         _instance = instance;
 267         _adapterName = adapterName;
 268     }
 269
 270     //
 271     // Only for use by Ice.ObjectAdapterI.
 272     //
 273     public void
 274     destroy()
 275     {
 276         java.util.Map<String, Ice.ServantLocator> locatorMap = new java.util.HashMap<String, Ice.ServantLocator>();
 277         Ice.Logger logger = null;
 278         synchronized(this)
 279         {
 280             assert(_instance != null); // Must not be called after destruction.
 281             logger = _instance.initializationData().logger;
 282             _servantMapMap.clear();
 283
 284             locatorMap.putAll(_locatorMap);
 285             _locatorMap.clear();
 286             _instance = null;
 287         }
 288
 289         for(java.util.Map.Entry<String, Ice.ServantLocator> p : locatorMap.entrySet())
 290         {
 291             Ice.ServantLocator locator = p.getValue();
 292             try
 293             {
 294                 locator.deactivate(p.getKey());
 295             }
 296             catch(java.lang.Exception ex)
 297             {
 298                 String s = "exception during locator deactivation:\n" + "object adapter: `" + _adapterName + "'\n" +
 299                     "locator category: `" + p.getKey() + "'\n" + Ex.toString(ex);
 300                 logger.error(s);
 301             }
 302         }
 303     }
 304
 305     private Instance _instance;
 306     final private String _adapterName;
 307     private java.util.Map<Ice.Identity, java.util.Map<String, Ice.Object> > _servantMapMap =
 308         new java.util.HashMap<Ice.Identity, java.util.Map<String, Ice.Object> >();
 309     private java.util.Map<String, Ice.Object> _defaultServantMap = new java.util.HashMap<String, Ice.Object>();
 310     private java.util.Map<String, Ice.ServantLocator> _locatorMap = new java.util.HashMap<String, Ice.ServantLocator>();
 311 }