//     $Revision: 1.1.2.1 $
package com.kabira.snippets.highavailability;

import com.kabira.platform.Transaction;
import com.kabira.platform.Transaction.Rollback;
import com.kabira.platform.annotation.Managed;
import com.kabira.platform.highavailability.Partition;
import com.kabira.platform.highavailability.PartitionManager;
import static com.kabira.platform.highavailability.PartitionManager.EnableAction.JOIN_CLUSTER;
import com.kabira.platform.highavailability.PartitionMapper;
import com.kabira.platform.highavailability.PartitionNotFound;
import com.kabira.platform.highavailability.ReplicaNode;
import static com.kabira.platform.highavailability.ReplicaNode.ReplicationType.SYNCHRONOUS;
import com.kabira.platform.property.Status;

/**
 * This snippet shows how to migrate a partition
 * <p>
 * <h2> Target Nodes</h2>
 * <ul>
 * <li> <b>domainnode</b> = "A"
 * </ul>
 */
public class PartitionMigration
{
    @Managed
    private static class AnObject
    {
    }

    //
    //  Partition mapper that maps objects to either Even or Odd
    //
    private static class UpdateMapper extends PartitionMapper
    {
        @Override
        public String getPartition(Object obj)
        {
            return PARTITION_NAME;
        }
    }

    /**
     * Main entry point
     *
     * @param args Not used
     * @throws java.lang.InterruptedException
     */
    public static void main(String[] args) throws InterruptedException
    {
        new Transaction("Initialization")
        {
            @Override
            protected void run() throws Rollback
            {
                //
                //  Install the partition mapper
                //
                PartitionManager.setMapper(AnObject.class, new UpdateMapper());

                //
                //  Define the partition
                //
                ReplicaNode[] replicas = new ReplicaNode[]
                {
                    new ReplicaNode("B", SYNCHRONOUS),
                    new ReplicaNode("C", SYNCHRONOUS)
                };
                PartitionManager.definePartition(PARTITION_NAME, null, "A", replicas);

                //
                //  Enable the partition
                //
                PartitionManager.enablePartitions(JOIN_CLUSTER);
            }
        }.execute();

        new Transaction("Create Object")
        {
            @Override
            protected void run() throws Rollback
            {
                m_object = new AnObject();

                //
                //  Get the partition for the object
                //
                Partition partition = PartitionManager.getObjectPartition(m_object);

                //
                //  Display the active node
                //
                System.out.println("Active node is " + partition.getActiveNode());
            }
        }.execute();

        new Transaction("Migrate Partition")
        {
            @Override
            protected void run() throws Rollback
            {
                //
                //  Get the partition for the object
                //
                Partition partition = PartitionManager.getObjectPartition(m_object);

                //
                //  Partition migration can only be done on the current 
                //  active node
                //
                if (partition.getActiveNode().equals(
                    System.getProperty(Status.NODE_NAME)) == false)
                {
                    return;
                }

                //
                //  Mirgate the partition to make node C the active node.
                //
                //  Partition migration can only be from the current active node.
                //
                //  The default properties specified when the partition was
                //  defined are used.
                //
                ReplicaNode[] replicas = new ReplicaNode[]
                {
                    new ReplicaNode("B", SYNCHRONOUS),
                    new ReplicaNode("A", SYNCHRONOUS)
                };
                partition.migrate(null, "C", replicas);

                System.out.println("Migrated partition to node C");
            }
        }.execute();

        waitForMigration();

        new Transaction("Display Active Node")
        {
            @Override
            protected void run() throws Rollback
            {
                //
                //  Get the partition for the object
                //
                Partition partition = PartitionManager.getObjectPartition(m_object);

                //
                //  Display the active node again
                //
                System.out.println("Active node is " + partition.getActiveNode());
            }
        }.execute();
    }

    private static void waitForMigration() throws InterruptedException
    {
        System.out.println("Waiting for migration...");

        while (m_partitionFound == false)
        {
            Thread.sleep(5000);

            new Transaction("Wait for Migration")
            {
                @Override
                protected void run()
                {
                    try
                    {
                        Partition partition = PartitionManager.getPartition(PARTITION_NAME);

                        //
                        //  Wait for partition to migrate to node C
                        //
                        m_partitionFound = partition.getActiveNode().equals("C");
                    }
                    catch (PartitionNotFound ex)
                    {
                        // not available yet
                    }
                }
            }.execute();
        }

        System.out.println("Partition migration complete.");
    }

    private static boolean m_partitionFound = false;
    private static AnObject m_object = null;
    private static final String PARTITION_NAME = "Partition Migration Snippet";
}

#
# Partition is active on node A
#
[C] Active node is A
[B] Active node is A
[A] Active node is A

#
# Nodes B and C are waiting for partition migration
#
[C] Waiting for migration...
[B] Waiting for migration...

#
# Node A migrates partition to node C
#
[A] Migrated partition to node C
[A] Waiting for migration...

#
# Migration completes
#
[C] Partition migration complete.
[B] Partition migration complete.
[A] Partition migration complete.

#
# Partition is now active on node C
#
[C] Active node is C
[B] Active node is C
[A] Active node is C