Bug 4512: demo/book/evictor_filesystem issues

8 files changed, 73 insertions, 141 deletions

diff --git a/cpp/demo/book/evictor_filesystem/PersistentFilesystem.ice b/cpp/demo/book/evictor_filesystem/PersistentFilesystem.ice
index b8e915644d6..fe0216eb4d2 100644
--- a/cpp/demo/book/evictor_filesystem/PersistentFilesystem.ice
+++ b/cpp/demo/book/evictor_filesystem/PersistentFilesystem.ice
@@ -19,14 +19,14 @@ module Filesystem
         PersistentDirectory* parent;
     };
 
-    ["cpp:virtual"]class PersistentFile extends PersistentNode implements File
+    class PersistentFile extends PersistentNode implements File
     {
         Lines text;
     };
 
     dictionary<string, NodeDesc> NodeDict;
 
-    ["cpp:virtual"]class PersistentDirectory extends PersistentNode implements Directory
+    class PersistentDirectory extends PersistentNode implements Directory
     {
         ["freeze:write"]
         void removeNode(string name);
diff --git a/cpp/demo/book/evictor_filesystem/PersistentFilesystemI.cpp b/cpp/demo/book/evictor_filesystem/PersistentFilesystemI.cpp
index dc5ed333dff..4813ca17573 100644
--- a/cpp/demo/book/evictor_filesystem/PersistentFilesystemI.cpp
+++ b/cpp/demo/book/evictor_filesystem/PersistentFilesystemI.cpp
@@ -12,27 +12,19 @@
 using namespace std;
 
 //
-// Filesystem::NodeI
+// Filesystem::FileI
 //
-Freeze::EvictorPtr Filesystem::NodeI::_evictor;
 
-Filesystem::NodeI::NodeI()
-  : _destroyed(false), _id(Ice::Identity())
-{
-}
+Freeze::EvictorPtr Filesystem::FileI::_evictor;
 
-Filesystem::NodeI::NodeI(const Ice::Identity& id)
-    : _destroyed(false), _id(id)
+Filesystem::FileI::FileI() : _destroyed(false)
 {
 }
 
-//
-// Filesystem::FileI
-//
 string
 Filesystem::FileI::name(const Ice::Current& c)
 {
-    IceUtil::Mutex::Lock lock(*this);
+    IceUtil::Mutex::Lock lock(_mutex);
 
     if(_destroyed)
     {
@@ -46,7 +38,7 @@ void
 Filesystem::FileI::destroy(const Ice::Current& c)
 {
     {
-        IceUtil::Mutex::Lock lock(*this);
+        IceUtil::Mutex::Lock lock(_mutex);
 
 	if(_destroyed)
 	{
@@ -55,14 +47,17 @@ Filesystem::FileI::destroy(const Ice::Current& c)
 	_destroyed = true;
     }
 
+    //
+    // Because we use a transactional evictor, these updates are guaranteed to be atomic.
+    //
     parent->removeNode(nodeName);
-    _evictor->remove(_id);
+    _evictor->remove(c.id);
 }
 
 Filesystem::Lines
 Filesystem::FileI::read(const Ice::Current& c)
 {
-    IceUtil::Mutex::Lock lock(*this);
+    IceUtil::Mutex::Lock lock(_mutex);
 
     if(_destroyed)
     {
@@ -75,7 +70,7 @@ Filesystem::FileI::read(const Ice::Current& c)
 void
 Filesystem::FileI::write(const Filesystem::Lines& text, const Ice::Current& c)
 {
-    IceUtil::Mutex::Lock lock(*this);
+    IceUtil::Mutex::Lock lock(_mutex);
 
     if(_destroyed)
     {
@@ -85,22 +80,20 @@ Filesystem::FileI::write(const Filesystem::Lines& text, const Ice::Current& c)
     this->text = text;
 }
 
-Filesystem::FileI::FileI()
-{
-}
+//
+// Filesystem::DirectoryI
+//
 
-Filesystem::FileI::FileI(const Ice::Identity& id)
-    : NodeI(id)
+Freeze::EvictorPtr Filesystem::DirectoryI::_evictor;
+
+Filesystem::DirectoryI::DirectoryI() : _destroyed(false)
 {
 }
 
-//
-// Filesystem::DirectoryI
-//
 string
 Filesystem::DirectoryI::name(const Ice::Current& c)
 {
-    IceUtil::Mutex::Lock lock(*this);
+    IceUtil::Mutex::Lock lock(_mutex);
 
     if(_destroyed)
     {
@@ -119,7 +112,7 @@ Filesystem::DirectoryI::destroy(const Ice::Current& c)
     }
 
     {
-        IceUtil::Mutex::Lock lock(*this);
+        IceUtil::Mutex::Lock lock(_mutex);
 
         if(_destroyed)
         {
@@ -132,14 +125,17 @@ Filesystem::DirectoryI::destroy(const Ice::Current& c)
         _destroyed = true;
     }
 
+    //
+    // Because we use a transactional evictor, these updates are guaranteed to be atomic.
+    //
     parent->removeNode(nodeName);
-    _evictor->remove(_id);
+    _evictor->remove(c.id);
 }
 
 Filesystem::NodeDescSeq
 Filesystem::DirectoryI::list(const Ice::Current& c)
 {
-    IceUtil::Mutex::Lock lock(*this);
+    IceUtil::Mutex::Lock lock(_mutex);
 
     if(_destroyed)
     {
@@ -158,7 +154,7 @@ Filesystem::DirectoryI::list(const Ice::Current& c)
 Filesystem::NodeDesc
 Filesystem::DirectoryI::find(const string& name, const Ice::Current& c)
 {
-    IceUtil::Mutex::Lock lock(*this);
+    IceUtil::Mutex::Lock lock(_mutex);
 
     if(_destroyed)
     {
@@ -176,7 +172,7 @@ Filesystem::DirectoryI::find(const string& name, const Ice::Current& c)
 Filesystem::DirectoryPrx
 Filesystem::DirectoryI::createDirectory(const string& name, const Ice::Current& c)
 {
-    IceUtil::Mutex::Lock lock(*this);
+    IceUtil::Mutex::Lock lock(_mutex);
 
     if(_destroyed)
     {
@@ -190,7 +186,7 @@ Filesystem::DirectoryI::createDirectory(const string& name, const Ice::Current&
 
     Ice::Identity id;
     id.name = IceUtil::generateUUID();
-    PersistentDirectoryPtr dir = new DirectoryI(id);
+    PersistentDirectoryPtr dir = new DirectoryI;
     dir->nodeName = name;
     dir->parent = PersistentDirectoryPrx::uncheckedCast(c.adapter->createProxy(c.id));
     DirectoryPrx proxy = DirectoryPrx::uncheckedCast(_evictor->add(dir, id));
@@ -207,7 +203,7 @@ Filesystem::DirectoryI::createDirectory(const string& name, const Ice::Current&
 Filesystem::FilePrx
 Filesystem::DirectoryI::createFile(const string& name, const Ice::Current& c)
 {
-    IceUtil::Mutex::Lock lock(*this);
+    IceUtil::Mutex::Lock lock(_mutex);
 
     if(_destroyed)
     {
@@ -221,7 +217,7 @@ Filesystem::DirectoryI::createFile(const string& name, const Ice::Current& c)
 
     Ice::Identity id;
     id.name = IceUtil::generateUUID();
-    PersistentFilePtr file = new FileI(id);
+    PersistentFilePtr file = new FileI;
     file->nodeName = name;
     file->parent = PersistentDirectoryPrx::uncheckedCast(c.adapter->createProxy(c.id));
     FilePrx proxy = FilePrx::uncheckedCast(_evictor->add(file, id));
@@ -238,22 +234,13 @@ Filesystem::DirectoryI::createFile(const string& name, const Ice::Current& c)
 void
 Filesystem::DirectoryI::removeNode(const string& name, const Ice::Current&)
 {
-    IceUtil::Mutex::Lock lock(*this);
+    IceUtil::Mutex::Lock lock(_mutex);
 
     NodeDict::iterator p = nodes.find(name);
     assert(p != nodes.end());
     nodes.erase(p);
 }
 
-Filesystem::DirectoryI::DirectoryI()
-{
-}
-
-Filesystem::DirectoryI::DirectoryI(const Ice::Identity& id) :
-    NodeI(id)
-{
-}
-
 //
 // Filesystem::NodeFactory
 //
@@ -279,17 +266,3 @@ void
 Filesystem::NodeFactory::destroy()
 {
 }
-
-//
-// Filesystem::NodeInitializer
-//
-void
-Filesystem::NodeInitializer::initialize(const Ice::ObjectAdapterPtr&,
-                                        const Ice::Identity& id,
-                                        const string& facet,
-                                        const Ice::ObjectPtr& obj)
-{
-    NodeIPtr node = NodeIPtr::dynamicCast(obj);
-    assert(node);
-    const_cast<Ice::Identity&>(node->_id) = id;
-}
diff --git a/cpp/demo/book/evictor_filesystem/PersistentFilesystemI.h b/cpp/demo/book/evictor_filesystem/PersistentFilesystemI.h
index ae6773be1fe..bd112facb5a 100644
--- a/cpp/demo/book/evictor_filesystem/PersistentFilesystemI.h
+++ b/cpp/demo/book/evictor_filesystem/PersistentFilesystemI.h
@@ -27,36 +27,37 @@ public:
 protected:
 
     NodeI();
-    NodeI(const Ice::Identity&);
 
     bool _destroyed;
-
-public:
-
-    const Ice::Identity _id;
 };
 typedef IceUtil::Handle<NodeI> NodeIPtr;
 
-class FileI : virtual public PersistentFile,
-              virtual public NodeI
+class FileI : virtual public PersistentFile
 {
 public:
 
+    FileI();
+
     virtual std::string name(const Ice::Current&);
     virtual void destroy(const Ice::Current&);
 
     virtual Lines read(const Ice::Current&);
     virtual void write(const Lines&, const Ice::Current&);
 
-    FileI();
-    FileI(const Ice::Identity&);
+    static Freeze::EvictorPtr _evictor;
+
+private:
+
+    bool _destroyed;
+    IceUtil::Mutex _mutex;
 };
 
-class DirectoryI : virtual public PersistentDirectory,
-                   virtual public NodeI
+class DirectoryI : virtual public PersistentDirectory
 {
 public:
 
+    DirectoryI();
+
     virtual std::string name(const Ice::Current&);
     virtual void destroy(const Ice::Current&);
 
@@ -66,9 +67,12 @@ public:
     virtual FilePrx createFile(const std::string&, const Ice::Current&);
     virtual void removeNode(const std::string&, const Ice::Current&);
 
-    DirectoryI();
-    DirectoryI(const Ice::Identity&);
+    static Freeze::EvictorPtr _evictor;
 
+public:
+
+    bool _destroyed;
+    IceUtil::Mutex _mutex;
 };
 
 class NodeFactory : virtual public Ice::ObjectFactory
@@ -79,16 +83,6 @@ public:
     virtual void destroy();
 };
 
-class NodeInitializer : virtual public Freeze::ServantInitializer
-{
-public:
-
-    virtual void initialize(const Ice::ObjectAdapterPtr&,
-                            const Ice::Identity&,
-                            const std::string&,
-                            const Ice::ObjectPtr&);
-};
-
 }
 
 #endif
diff --git a/cpp/demo/book/evictor_filesystem/Server.cpp b/cpp/demo/book/evictor_filesystem/Server.cpp
index 72af8fe658d..4692488244a 100644
--- a/cpp/demo/book/evictor_filesystem/Server.cpp
+++ b/cpp/demo/book/evictor_filesystem/Server.cpp
@@ -36,23 +36,24 @@ public:
         Ice::ObjectAdapterPtr adapter = communicator()->createObjectAdapter("EvictorFilesystem");
 
         //
-        // Create the Freeze evictor (stored in the NodeI::_evictor static member).
+        // Create the Freeze evictor.
         //
-        Freeze::ServantInitializerPtr init = new NodeInitializer;
-        NodeI::_evictor = Freeze::createTransactionalEvictor(adapter, _envName, "evictorfs",
-                                                             Freeze::FacetTypeMap(), init);
+        Freeze::EvictorPtr evictor = Freeze::createTransactionalEvictor(adapter, _envName, "evictorfs");
+        FileI::_evictor = evictor;
+        DirectoryI::_evictor = evictor;
 
-        adapter->addServantLocator(NodeI::_evictor, "");
+        adapter->addServantLocator(evictor, "");
 
         //
         // Create the root node if it doesn't exist.
         //
-        Ice::Identity rootId = communicator()->stringToIdentity("RootDir");
-        if(!NodeI::_evictor->hasObject(rootId))
+        Ice::Identity rootId;
+        rootId.name = "RootDir";
+        if(!evictor->hasObject(rootId))
         {
-            PersistentDirectoryPtr root = new DirectoryI(rootId);
+            PersistentDirectoryPtr root = new DirectoryI;
             root->nodeName = "/";
-            NodeI::_evictor->add(root, rootId);
+            evictor->add(root, rootId);
         }
 
         //
diff --git a/java/demo/book/evictor_filesystem/DirectoryI.java b/java/demo/book/evictor_filesystem/DirectoryI.java
index c58f1c64013..98cd14d7dbd 100644
--- a/java/demo/book/evictor_filesystem/DirectoryI.java
+++ b/java/demo/book/evictor_filesystem/DirectoryI.java
@@ -15,14 +15,7 @@ public final class DirectoryI extends PersistentDirectory
     DirectoryI()
     {
         _destroyed = false;
-    }
-
-    public
-    DirectoryI(Ice.Identity id)
-    {
-        _id = id;
         nodes = new java.util.HashMap<java.lang.String, NodeDesc>();
-        _destroyed = false;
     }
 
     public synchronized String
@@ -58,8 +51,11 @@ public final class DirectoryI extends PersistentDirectory
 	    _destroyed = true;
         }
 
+        //
+        // Because we use a transactional evictor, these updates are guaranteed to be atomic.
+        //
         parent.removeNode(nodeName);
-        _evictor.remove(_id);
+        _evictor.remove(current.id);
     }
 
     public synchronized NodeDesc[]
@@ -112,7 +108,7 @@ public final class DirectoryI extends PersistentDirectory
         }
 
         Ice.Identity id = current.adapter.getCommunicator().stringToIdentity(java.util.UUID.randomUUID().toString());
-        PersistentDirectory dir = new DirectoryI(id);
+        PersistentDirectory dir = new DirectoryI();
         dir.nodeName = name;
         dir.parent = PersistentDirectoryPrxHelper.uncheckedCast(current.adapter.createProxy(current.id));
         DirectoryPrx proxy = DirectoryPrxHelper.uncheckedCast(_evictor.add(dir, id));
@@ -141,7 +137,7 @@ public final class DirectoryI extends PersistentDirectory
         }
 
         Ice.Identity id = current.adapter.getCommunicator().stringToIdentity(java.util.UUID.randomUUID().toString());
-        PersistentFile file = new FileI(id);
+        PersistentFile file = new FileI();
         file.nodeName = name;
         file.parent = PersistentDirectoryPrxHelper.uncheckedCast(current.adapter.createProxy(current.id));
         FilePrx proxy = FilePrxHelper.uncheckedCast(_evictor.add(file, id));
@@ -163,6 +159,5 @@ public final class DirectoryI extends PersistentDirectory
     }
 
     public static Freeze.Evictor _evictor;
-    public Ice.Identity _id;
     private boolean _destroyed;
 }
diff --git a/java/demo/book/evictor_filesystem/FileI.java b/java/demo/book/evictor_filesystem/FileI.java
index 8b84ae13b34..5455b0880c6 100644
--- a/java/demo/book/evictor_filesystem/FileI.java
+++ b/java/demo/book/evictor_filesystem/FileI.java
@@ -17,13 +17,6 @@ public final class FileI extends PersistentFile
         _destroyed = false;
     }
 
-    public
-    FileI(Ice.Identity id)
-    {
-        _id = id;
-        _destroyed = false;
-    }
-
     public synchronized String
     name(Ice.Current current)
     {
@@ -48,8 +41,11 @@ public final class FileI extends PersistentFile
 	    _destroyed = true;
 	}
 
+        //
+        // Because we use a transactional evictor, these updates are guaranteed to be atomic.
+        //
         parent.removeNode(nodeName);
-        _evictor.remove(_id);
+        _evictor.remove(current.id);
     }
 
     public synchronized String[]
@@ -76,6 +72,5 @@ public final class FileI extends PersistentFile
     }
 
     public static Freeze.Evictor _evictor;
-    public Ice.Identity _id;
     private boolean _destroyed;
 }
diff --git a/java/demo/book/evictor_filesystem/NodeInitializer.java b/java/demo/book/evictor_filesystem/NodeInitializer.java
deleted file mode 100644
index e09f39c1db5..00000000000
--- a/java/demo/book/evictor_filesystem/NodeInitializer.java
+++ /dev/null
@@ -1,26 +0,0 @@
-// **********************************************************************
-//
-// Copyright (c) 2003-2009 ZeroC, Inc. All rights reserved.
-//
-// This copy of Ice is licensed to you under the terms described in the
-// ICE_LICENSE file included in this distribution.
-//
-// **********************************************************************
-
-import Filesystem.*;
-
-public class NodeInitializer implements Freeze.ServantInitializer
-{
-    public void
-    initialize(Ice.ObjectAdapter adapter, Ice.Identity id, String facet, Ice.Object obj)
-    {
-        if(obj instanceof FileI)
-        {
-            ((FileI)obj)._id = id;
-        }
-        else if(obj instanceof DirectoryI)
-        {
-            ((DirectoryI)obj)._id = id;
-        }
-    }
-}
diff --git a/java/demo/book/evictor_filesystem/Server.java b/java/demo/book/evictor_filesystem/Server.java
index dfdf5e109c3..55bd40fccc5 100644
--- a/java/demo/book/evictor_filesystem/Server.java
+++ b/java/demo/book/evictor_filesystem/Server.java
@@ -37,9 +37,8 @@ public class Server extends Ice.Application
         // Create the Freeze evictor (stored in the _evictor
         // static member).
         //
-        Freeze.ServantInitializer init = new NodeInitializer();
         Freeze.Evictor evictor = Freeze.Util.createTransactionalEvictor(adapter, _envName, "evictorfs",
-                                                                        null, init, null, true);
+                                                                        null, null, null, true);
         DirectoryI._evictor = evictor;
         FileI._evictor = evictor;
 
@@ -48,10 +47,11 @@ public class Server extends Ice.Application
         //
         // Create the root node if it doesn't exist.
         //
-        Ice.Identity rootId = Ice.Util.stringToIdentity("RootDir");
+        Ice.Identity rootId = new Ice.Identity();
+        rootId.name = "RootDir";
         if(!evictor.hasObject(rootId))
         {
-            PersistentDirectory root = new DirectoryI(rootId);
+            PersistentDirectory root = new DirectoryI();
             root.nodeName = "/";
             root.nodes = new java.util.HashMap<java.lang.String, NodeDesc>();
             evictor.add(root, rootId);