Example #1
0
            /*
             * public Node findSuccessor(byte[] queryHashedKey, Node queryingNode)
             * {
             *      if((Node)self<queryHashedKey && queryHashedKey<(Node)successor)
             *              return successor;
             *      else
             *      {
             *              Node closestPrecNode = findClosestPreceedingNode(queryHashedKey);
             *              if (closestPrecNode==self)
             *                      return successor;
             *              else
             *              {
             *                      return closestPrecNode.findSuccessor(queryHashedKey, queryingNode);
             *      }
             * }
             * }
             */
            public void beginFindSuccessor(byte[] queryHashedKey, IChordNode queryingNode, AsyncCallback findSuccessorCallBack, Object appState, Guid relayTicket)
            {
                Console.WriteLine("Chord::engine::beginFindSuccessor ENTER");
                ChordCommon.IChordNode_Object iNode_Object;
                lock (successorLock)
                {
                    if ((ChordRealNode)self < queryHashedKey && queryHashedKey < (ChordRealNode)successor)
                    {
                        Console.WriteLine("Chord::engine::beginFindSuccessor query falls inbetween node and successor");
                        if (!(findSuccessorCallBack == null))
                        {
                            iNode_Object = new ChordCommon.IChordNode_Object();
                            lock (successorLock)
                            {
                                iNode_Object.node = successor;
                            }
                            iNode_Object.obj = appState;

                            IAsyncResult res = new ChordCommon.IChordNode_ObjectAsyncResult(iNode_Object, true, true);
                            findSuccessorCallBack(res);
                        }
                    }
                    else
                    {
                        Console.WriteLine("Chord::engine::beginFindSuccessor query DOES NOT fall inbetween node and successor");
                        IChordNode closestPrecNode = findClosestPreceedingNode(queryHashedKey);
                        if (closestPrecNode == self)
                        {
                            Console.WriteLine("Chord::engine::beginFindSuccessor closestPrecNode==self");
                            if (!(findSuccessorCallBack == null))
                            {
                                Console.WriteLine("Chord::engine::beginFindSuccessor if(!(findSuccessorCallBack==null))");
                                iNode_Object = new ChordCommon.IChordNode_Object();
                                lock (successorLock)
                                {
                                    iNode_Object.node = successor;
                                }
                                iNode_Object.obj = appState;

                                Console.WriteLine("Chord::engine::beginFindSuccessor before new IChordNode_ObjectAsyncResult");
                                IAsyncResult res = new ChordCommon.IChordNode_ObjectAsyncResult(iNode_Object, true, true);
                                Console.WriteLine("Chord::engine::beginFindSuccessor before calling findSuccessorCallBack");
                                findSuccessorCallBack(res);
                            }
                        }
                        else
                        {
                            Console.WriteLine("Chord::engine::beginFindSuccessor relaying request to closestPrecNode");
                            closestPrecNode.beginFindSuccessor(queryHashedKey, queryingNode, findSuccessorCallBack, appState, relayTicket);
                        }
                    }
                }

                Console.WriteLine("Chord::engine::beginFindSuccessor EXIT");
            }
Example #2
0
        /* public Node getPredecessor()
         * {
         *      return engine.getPredecessor();
         *
         * }
         */

        public void beginGetPredecessor(AsyncCallback getPredecessorCallBack, Object appState)
        {
            Console.WriteLine("ChordRealNode::beginGetPredecessor ENTER");

            IChordNode predecessor = engine.getPredecessor();

            ChordCommon.IChordNode_Object iNode_Object = new ChordCommon.IChordNode_Object();
            iNode_Object.node = predecessor;
            iNode_Object.obj  = appState;

            if (!(getPredecessorCallBack == null))
            {
                IAsyncResult res = new ChordCommon.IChordNode_ObjectAsyncResult(iNode_Object, false, true);
                getPredecessorCallBack(res);
            }
        }
Example #3
0
            void processGetPredecessorForStabilize(IAsyncResult result)
            {
                Console.WriteLine("Chord::Engine::processGetPredecessorForStabilize ENTER");

                ChordCommon.IChordNode_Object iNode_Object = (ChordCommon.IChordNode_Object)(result.AsyncState);
                Object appState = iNode_Object.obj;

                AsyncCallback callBack  = ((Tashjik.Common.AsyncCallback_Object)appState).callBack;
                Object        appState1 = ((Tashjik.Common.AsyncCallback_Object)appState).obj;

                IChordNode x = iNode_Object.node;

                if (x == null)
                {
                    Console.WriteLine("Chord::Engine::processGetPredecessorForStabilize UNKNOWN_PREDECESSOR");
                    if (callBack != null)
                    {
                        iNode_Object      = new ChordCommon.IChordNode_Object();
                        iNode_Object.node = null;
                        iNode_Object.obj  = appState1;

                        IAsyncResult res = new ChordCommon.IChordNode_ObjectAsyncResult(iNode_Object, true, true);
                        //		callBack(res);
                    }
                }
                else
                {
                    Console.WriteLine("Chord::Engine::processGetPredecessorForStabilize before condition check");
                    lock (successorLock)
                    {
                        if ((self < (IChordNode)x) && ((ChordRealNode)x /*.getHashedIP()*/ < (successor)))
                        {
                            successor = x;
                        }
                    }
                    Console.WriteLine("Chord::Engine::processGetPredecessorForStabilize before calling beginNotify on successor");
                }
                lock (successorLock)
                {
                    successor.beginPredecessorNotify(self, callBack, appState1);
                }
            }
Example #4
0
            /*
                public Node findSuccessor(byte[] queryHashedKey, Node queryingNode)
                {
                    if((Node)self<queryHashedKey && queryHashedKey<(Node)successor)
                        return successor;
                    else
                    {
                        Node closestPrecNode = findClosestPreceedingNode(queryHashedKey);
                        if (closestPrecNode==self)
                            return successor;
                        else
                        {
                            return closestPrecNode.findSuccessor(queryHashedKey, queryingNode);
                    }
                }
            }
            */
            public void beginFindSuccessor(byte[] queryHashedKey, IChordNode queryingNode, AsyncCallback findSuccessorCallBack, Object appState, Guid relayTicket)
            {
                Console.WriteLine("Chord::engine::beginFindSuccessor ENTER");
                ChordCommon.IChordNode_Object iNode_Object;
                lock (successorLock)
                {
                    if ((ChordRealNode)self < queryHashedKey && queryHashedKey < (ChordRealNode)successor)
                    {
                        Console.WriteLine("Chord::engine::beginFindSuccessor query falls inbetween node and successor");
                        if (!(findSuccessorCallBack == null))
                        {
                            iNode_Object = new ChordCommon.IChordNode_Object();
                            lock (successorLock)
                            {
                                iNode_Object.node = successor;
                            }
                            iNode_Object.obj = appState;

                            IAsyncResult res = new ChordCommon.IChordNode_ObjectAsyncResult(iNode_Object, true, true);
                            findSuccessorCallBack(res);
                        }
                    }
                    else
                    {
                        Console.WriteLine("Chord::engine::beginFindSuccessor query DOES NOT fall inbetween node and successor");
                        IChordNode closestPrecNode = findClosestPreceedingNode(queryHashedKey);
                        if (closestPrecNode == self)
                        {
                            Console.WriteLine("Chord::engine::beginFindSuccessor closestPrecNode==self");
                            if (!(findSuccessorCallBack == null))
                            {
                                Console.WriteLine("Chord::engine::beginFindSuccessor if(!(findSuccessorCallBack==null))");
                                iNode_Object = new ChordCommon.IChordNode_Object();
                                lock (successorLock)
                                {
                                    iNode_Object.node = successor;
                                }
                                iNode_Object.obj = appState;

                                Console.WriteLine("Chord::engine::beginFindSuccessor before new IChordNode_ObjectAsyncResult");
                                IAsyncResult res = new ChordCommon.IChordNode_ObjectAsyncResult(iNode_Object, true, true);
                                Console.WriteLine("Chord::engine::beginFindSuccessor before calling findSuccessorCallBack");
                                findSuccessorCallBack(res);
                            }
                        }
                        else
                        {
                            Console.WriteLine("Chord::engine::beginFindSuccessor relaying request to closestPrecNode");
                            closestPrecNode.beginFindSuccessor(queryHashedKey, queryingNode, findSuccessorCallBack, appState, relayTicket);
                        }

                    }
                }

                Console.WriteLine("Chord::engine::beginFindSuccessor EXIT");
            }
Example #5
0
        /* public Node getPredecessor()
        {
            return engine.getPredecessor();

        }
        */
        public void beginGetPredecessor(AsyncCallback getPredecessorCallBack, Object appState)
        {
            Console.WriteLine("ChordRealNode::beginGetPredecessor ENTER");

            IChordNode predecessor = engine.getPredecessor();

            ChordCommon.IChordNode_Object iNode_Object = new ChordCommon.IChordNode_Object();
            iNode_Object.node = predecessor;
            iNode_Object.obj = appState;

            if(!(getPredecessorCallBack==null))
            {
                IAsyncResult res = new ChordCommon.IChordNode_ObjectAsyncResult(iNode_Object, false,true);
                getPredecessorCallBack(res);
            }
        }
Example #6
0
            void processGetPredecessorForStabilize(IAsyncResult result)
            {
                Console.WriteLine("Chord::Engine::processGetPredecessorForStabilize ENTER");

                    ChordCommon.IChordNode_Object iNode_Object = (ChordCommon.IChordNode_Object)(result.AsyncState);
                    Object appState = iNode_Object.obj;

                    AsyncCallback callBack = ((Tashjik.Common.AsyncCallback_Object)appState).callBack;
                    Object appState1 = ((Tashjik.Common.AsyncCallback_Object)appState).obj;

                    IChordNode x = iNode_Object.node;
                    if(x==null)
                    {
                        Console.WriteLine("Chord::Engine::processGetPredecessorForStabilize UNKNOWN_PREDECESSOR");
                        if(callBack != null)
                        {	iNode_Object = new ChordCommon.IChordNode_Object();
                            iNode_Object.node = null;
                            iNode_Object.obj = appState1;

                            IAsyncResult res = new ChordCommon.IChordNode_ObjectAsyncResult(iNode_Object, true, true);
                    //		callBack(res);
                        }
                    }
                    else
                    {

                        Console.WriteLine("Chord::Engine::processGetPredecessorForStabilize before condition check");
                        lock (successorLock)
                        {
                            if ((self < (IChordNode)x) && ((ChordRealNode)x/*.getHashedIP()*/ < (successor)))
                                successor = x;
                        }
                        Console.WriteLine("Chord::Engine::processGetPredecessorForStabilize before calling beginNotify on successor");

                    }
                    lock (successorLock)
                    {
                        successor.beginPredecessorNotify(self, callBack, appState1);
                    }
            }