ACE/protocols/ace/INet/ConnectionCache.cpp

   1 #include "ace/INet/ConnectionCache.h"
   2
   3 #if !defined (__ACE_INLINE__)
   4 #include "ace/INet/ConnectionCache.inl"
   5 #endif
   6
   7 #include "ace/INet/INet_Log.h"
   8
   9
  10 ACE_BEGIN_VERSIONED_NAMESPACE_DECL
  11
  12 namespace ACE
  13 {
  14   namespace INet
  15   {
  16     ConnectionKey::ConnectionKey ()
  17       {}
  18
  19     ConnectionKey::~ConnectionKey ()
  20       {}
  21
  22     ConnectionCacheKey::ConnectionCacheKey ()
  23       : key_ (0),
  24         delete_key_ (false)
  25       {
  26       }
  27
  28     ConnectionCacheKey::ConnectionCacheKey (const ConnectionKey& key)
  29       : key_ (&const_cast<ConnectionKey&> (key)),
  30         delete_key_ (false)
  31       {
  32       }
  33
  34     ConnectionCacheKey::ConnectionCacheKey (const ConnectionCacheKey& cachekey)
  35       : key_ (0),
  36         delete_key_ (false)
  37       {
  38         *this = cachekey;
  39       }
  40
  41     ConnectionCacheKey::~ConnectionCacheKey ()
  42       {
  43         if (this->key_ != 0 && this->delete_key_)
  44           {
  45             delete this->key_;
  46             this->delete_key_ = false;
  47           }
  48       }
  49
  50     ConnectionCacheKey& ConnectionCacheKey::operator =(const ConnectionCacheKey& cachekey)
  51       {
  52         if (this != &cachekey)
  53           {
  54             if (this->key_ != 0 && this->delete_key_)
  55               {
  56                 delete this->key_;
  57                 this->delete_key_ = false;
  58               }
  59
  60             this->key_ = cachekey.key_->duplicate ();
  61
  62             if (this->key_ == 0)
  63               {
  64                 this->delete_key_ = false;
  65               }
  66             else
  67               {
  68                 this->delete_key_ = true;
  69               }
  70           }
  71         return *this;
  72       }
  73
  74     u_long ConnectionCacheKey::hash () const
  75       {
  76         return this->key_ ? this->key ().hash () : 0;
  77       }
  78
  79     ConnectionHolder::~ConnectionHolder () {}
  80     ConnectionHolder::ConnectionHolder () {}
  81
  82     ConnectionFactory::~ConnectionFactory () {}
  83     ConnectionFactory::ConnectionFactory () {}
  84
  85     ConnectionCacheValue::ConnectionCacheValue ()
  86       : state_ (CST_INIT),
  87         connection_ (0)
  88       {
  89       }
  90
  91     ConnectionCacheValue::ConnectionCacheValue (connection_type* connection)
  92       : state_ (connection ? CST_IDLE : CST_INIT),
  93         connection_ (connection)
  94       {
  95       }
  96
  97     ConnectionCacheValue::ConnectionCacheValue (const ConnectionCacheValue& cacheval)
  98       {
  99         *this = cacheval;
 100       }
 101
 102     ConnectionCacheValue& ConnectionCacheValue::operator =(const ConnectionCacheValue& cacheval)
 103       {
 104         if (this != &cacheval)
 105           {
 106             this->state_ = cacheval.state ();
 107             this->connection_ = const_cast<connection_type*> (cacheval.connection ());
 108           }
 109         return *this;
 110       }
 111
 112     ConnectionCache::ConnectionCache(size_t size)
 113       : condition_ (lock_),
 114         cache_map_ (size)
 115       {
 116       }
 117
 118     ConnectionCache::~ConnectionCache ()
 119       {
 120         this->close_all_connections ();
 121       }
 122
 123     bool ConnectionCache::find_connection (const ConnectionKey& key,
 124                                            ConnectionCacheValue& cacheval)
 125       {
 126         if (this->cache_map_.find (ConnectionCacheKey (key),
 127                                    cacheval) == 0)
 128           {
 129             return true;
 130           }
 131         return false;
 132       }
 133
 134     bool ConnectionCache::set_connection (const ConnectionKey& key,
 135                                           const ConnectionCacheValue& cacheval)
 136       {
 137         return this->cache_map_.rebind (ConnectionCacheKey (key),
 138                                         cacheval) != -1;
 139       }
 140
 141     bool ConnectionCache::claim_existing_connection(const ConnectionKey& key,
 142                                                     connection_type*& connection,
 143                                                     ConnectionCacheValue::State& state)
 144       {
 145         INET_TRACE ("ConnectionCache::claim_existing_connection");
 146
 147         ConnectionCacheValue cacheval;
 148         if (this->find_connection (key, cacheval))
 149           {
 150             state = cacheval.state ();
 151             if (state == ConnectionCacheValue::CST_IDLE)
 152               {
 153                 cacheval.state (ConnectionCacheValue::CST_BUSY);
 154                 if (this->set_connection (key, cacheval))
 155                   {
 156                     connection = cacheval.connection ();
 157                     return true;
 158                   }
 159                 else
 160                   {
 161                     INET_ERROR (1, (LM_ERROR, DLINFO ACE_TEXT ("ConnectionCache::claim_existing_connection - ")
 162                                               ACE_TEXT ("failed to claim connection entry")));
 163                   }
 164               }
 165           }
 166         return false;
 167       }
 168
 169     bool ConnectionCache::claim_connection(const ConnectionKey& key,
 170                                            connection_type*& connection,
 171                                            const factory_type& connection_factory,
 172                                            bool wait)
 173       {
 174         INET_TRACE ("ConnectionCache::claim_connection");
 175
 176         while (1)
 177           {
 178             bool create_connection = false;
 179             ConnectionCacheValue::State state = ConnectionCacheValue::CST_NONE;
 180             do
 181               {
 182                 ACE_MT (ACE_GUARD_RETURN (ACE_SYNCH_MUTEX,
 183                                           guard_,
 184                                           this->lock_,
 185                                           false));
 186
 187                 if (this->claim_existing_connection (key, connection, state))
 188                   {
 189                     INET_DEBUG (9, (LM_INFO, DLINFO ACE_TEXT ("%P|%t) ConnectionCache::claim_connection - ")
 190                                              ACE_TEXT ("successfully claimed existing connection\n")));
 191                     return true;
 192                   }
 193
 194                 if ((state == ConnectionCacheValue::CST_BUSY ||
 195                         state == ConnectionCacheValue::CST_INIT) && !wait)
 196                   return false;
 197
 198                 if (state == ConnectionCacheValue::CST_CLOSED ||
 199                         state == ConnectionCacheValue::CST_NONE)
 200                   {
 201                     if (!this->set_connection (key, ConnectionCacheValue ()))
 202                       {
 203                         INET_ERROR (1, (LM_ERROR, DLINFO ACE_TEXT ("ConnectionCache::claim_connection - ")
 204                                                   ACE_TEXT ("failed to initialize connection entry")));
 205                         return false;
 206                       }
 207
 208                     create_connection = true;
 209                   }
 210                 else
 211                   {
 212                     INET_DEBUG (9, (LM_INFO, DLINFO ACE_TEXT ("ConnectionCache::claim_connection - ")
 213                                              ACE_TEXT ("waiting for connection to become available\n")));
 214                     // wait for connection to become ready/free
 215                     if (this->condition_.wait () != 0)
 216                       {
 217                         INET_ERROR (1, (LM_ERROR, DLINFO ACE_TEXT ("(%P|%t) ConnectionCache::claim_connection - ")
 218                                                   ACE_TEXT ("error waiting for connection condition (%p)\n")));
 219                         return false;
 220                       }
 221                     INET_DEBUG (9, (LM_INFO, DLINFO ACE_TEXT ("ConnectionCache::claim_connection - ")
 222                                              ACE_TEXT ("awoken and retrying to claim connection\n")));
 223                   }
 224               }
 225             while (0);
 226
 227             if (create_connection)
 228               {
 229                 connection = connection_factory.create_connection (key);
 230                 if (connection)
 231                   {
 232                     INET_DEBUG (9, (LM_INFO, DLINFO ACE_TEXT ("ConnectionCache::claim_connection - ")
 233                                              ACE_TEXT ("successfully created new connection\n")));
 234
 235                     ACE_MT (ACE_GUARD_RETURN (ACE_SYNCH_MUTEX,
 236                                               guard_,
 237                                               this->lock_,
 238                                               false));
 239
 240                     ConnectionCacheValue cacheval (connection);
 241                     cacheval.state (ConnectionCacheValue::CST_BUSY);
 242                     return this->set_connection (key, cacheval);
 243                   }
 244                 else
 245                   return false;
 246               }
 247           }
 248       }
 249
 250     bool ConnectionCache::release_connection(const ConnectionKey& key,
 251                                              connection_type* connection)
 252       {
 253         INET_TRACE ("ConnectionCache::release_connection");
 254
 255         INET_DEBUG (9, (LM_INFO, DLINFO ACE_TEXT ("ConnectionCache::release_connection - ")
 256                                  ACE_TEXT ("releasing connection\n")));
 257
 258         ACE_MT (ACE_GUARD_RETURN (ACE_SYNCH_MUTEX,
 259                                   guard_,
 260                                   this->lock_,
 261                                   false));
 262
 263         ConnectionCacheValue cacheval;
 264         if (this->find_connection (key, cacheval) &&
 265               cacheval.connection () == connection &&
 266               cacheval.state () == ConnectionCacheValue::CST_BUSY)
 267           {
 268             cacheval.state (ConnectionCacheValue::CST_IDLE);
 269             if (this->set_connection (key, cacheval))
 270               {
 271                 // signal other threads about free connection
 272                 this->condition_.broadcast ();
 273                 return true;
 274               }
 275             else
 276               {
 277                 INET_ERROR (1, (LM_ERROR, DLINFO ACE_TEXT ("ConnectionCache::release_connection - ")
 278                                           ACE_TEXT ("failed to release connection entry")));
 279                 return false;
 280               }
 281           }
 282         else
 283           return false;
 284       }
 285
 286     bool ConnectionCache::close_connection(const ConnectionKey& key,
 287                                            connection_type* connection)
 288       {
 289         INET_TRACE ("ConnectionCache::close_connection");
 290
 291         INET_DEBUG (9, (LM_INFO, DLINFO ACE_TEXT ("ConnectionCache::close_connection - ")
 292                                  ACE_TEXT ("closing connection\n")));
 293
 294         ACE_MT (ACE_GUARD_RETURN (ACE_SYNCH_MUTEX,
 295                                   guard_,
 296                                   this->lock_,
 297                                   false));
 298
 299         ConnectionCacheValue cacheval;
 300         if (this->find_connection (key, cacheval) &&
 301               cacheval.connection () == connection &&
 302               cacheval.state () == ConnectionCacheValue::CST_BUSY)
 303           {
 304             connection_type* conn = cacheval.connection ();
 305             cacheval.connection (0);
 306             cacheval.state (ConnectionCacheValue::CST_CLOSED);
 307             if (this->set_connection (key, cacheval))
 308               {
 309                 // signal other threads about closed connection
 310                 this->condition_.broadcast ();
 311                 delete conn; // clean up
 312                 return true;
 313               }
 314             else
 315               {
 316                 INET_ERROR (1, (LM_ERROR, DLINFO ACE_TEXT ("ConnectionCache::close_connection - ")
 317                                           ACE_TEXT ("failed to close connection entry")));
 318                 return false;
 319               }
 320           }
 321         else
 322           return false;
 323       }
 324
 325     bool ConnectionCache::has_connection(const ConnectionKey& key)
 326       {
 327         INET_TRACE ("ConnectionCache::has_connection");
 328
 329         ACE_MT (ACE_GUARD_RETURN (ACE_SYNCH_MUTEX,
 330                                   guard_,
 331                                   this->lock_,
 332                                   false));
 333
 334         ConnectionCacheValue cacheval;
 335         return (this->find_connection (key, cacheval) &&
 336                   cacheval.state () != ConnectionCacheValue::CST_CLOSED);
 337       }
 338
 339     void ConnectionCache::close_all_connections()
 340       {
 341         INET_TRACE ("ConnectionCache::close_all_connections");
 342
 343         ACE_MT (ACE_GUARD (ACE_SYNCH_MUTEX,
 344                            guard_,
 345                            this->lock_));
 346
 347         map_iter_type iter = this->cache_map_.end ();
 348         for (iter = this->cache_map_.begin ();
 349              iter != this->cache_map_.end ();
 350              ++iter)
 351           {
 352             if ((*iter).int_id_.state () != ConnectionCacheValue::CST_CLOSED)
 353               {
 354                 connection_type* conn = (*iter).int_id_.connection ();
 355                 (*iter).int_id_.connection (0);
 356                 (*iter).int_id_.state (ConnectionCacheValue::CST_CLOSED);
 357                 delete conn;
 358               }
 359           }
 360         this->cache_map_.unbind_all ();
 361       }
 362
 363   }
 364 }
 365
 366 ACE_END_VERSIONED_NAMESPACE_DECL