Subscription Code

package com.daffodilwoods.demo.simple;

/*
*    Replicator - class Sample application SubscriptionReplicatorSimpleCode

*/

import com.daffodilwoods.ftp.server.FTPParameters;
import com.daffodilwoods.replicator.dataSources.RemoteDataSource;
import com.daffodilwoods.replicator.server.Replicator;
import com.daffodilwoods.replicator.server.datasources.PublisherDataSource;
import com.daffodilwoods.replicator.server.datasources.SubscriberDataSource;
import com.daffodilwoods.replicator.server.schedule.JobSchedular;
import com.daffodilwoods.replicator.server.schedule.Schedule;
import com.daffodilwoods.replicator.server.schedule._OccurrenceTypes;
import com.daffodilwoods.replicator.server.subscription.Subscription;
import com.daffodilwoods.replicator.utils.RepException;
import com.daffodilwoods.replicator.utils.ReplicationSaver;

/**
* This is Sample application which show The replication of one data base into
* another data base. SQL Server is taken in this sample as publisher data base as
* well subscriber data base
*/
public class SubscriptionReplicatorSimpleCode {

   // Parameters to set the server
   private static String serverSystemName = "server";
   private static String serverRepHome = "d:\rephome";
   private static int serverFTPPort = 1230;

   /**
   * if we use currentmode as subscription then we can call the doSubscription method for replication.
   * if we use currentmode as realTime we can call the realtime scheduling without call the doSubscription method for replication.
   * if we use currentmode as nonRealTime we can add the schedule using NonRealtime scheduling for replication.
   */
   private static String currentmode = "runSubscription";

   public static void main(String[] args) throws RepException {
       SubscriptionReplicatorSimpleCode subscriptionReplicatorSimpleCode = new SubscriptionReplicatorSimpleCode();
       Replicator repServer = subscriptionReplicatorSimpleCode.addDataSourceToReplicator();
       PublisherDataSource publisherDataSource = subscriptionReplicatorSimpleCode.configurePublisher(repServer);
       SubscriberDataSource subscriberDataSource = subscriptionReplicatorSimpleCode.configureSubscriber(repServer);

       Schedule schedule = subscriptionReplicatorSimpleCode.getSchedule();

       Subscription subscription = new Subscription(publisherDataSource, subscriberDataSource);
       subscription.setName("Subscription");
       repServer.addSubscription(subscription);

       if (currentmode.equals("runSubscription")) {
           subscriptionReplicatorSimpleCode.runSubscriptionWithoutSchedule(repServer);
       } else if (currentmode.equals("realTime")) {
           subscriptionReplicatorSimpleCode.addRealTimeScheduleOnSubscription(repServer, subscription, schedule);
       } else if (currentmode.equals("nonRealTime")) {
           subscriptionReplicatorSimpleCode.addNonRealTimeScheduleOnSubscription(repServer, subscription, schedule);
       }
   }

   private void runSubscriptionWithoutSchedule(Replicator repServer) throws RepException {
       //   if there is more than one job to be executed then use
       // repServer.doSubscriptions();
       repServer.doSubscription("Subscription");
   }

   public Replicator getReplicatorInstance() throws RepException {
       Replicator repServer = new Replicator();
       repServer.setReplicationHome("D:/rephome");
       FTPParameters parameters = new FTPParameters();
       parameters.setHostName(serverSystemName);
       parameters.setRootDir(serverRepHome);
       parameters.setPort(serverFTPPort);
       repServer.setFTPServerParameters(parameters);
       repServer.start();
       return repServer;
   }

   public Replicator addDataSourceToReplicator() throws RepException {
       Replicator repServer = getReplicatorInstance();

       // Add Publisher data source to the replication server object
       RemoteDataSource sourceRemoteDataSource = new RemoteDataSource();
       sourceRemoteDataSource.setReplicatorClientIPAddress("169.254.182.164");
       sourceRemoteDataSource.setReplicatorClientPortNo(new Integer(1050));
       sourceRemoteDataSource.setDataSourceName("source");
       repServer.addDataSource(sourceRemoteDataSource);

       // Add Subscriber data source to the replication server object
       RemoteDataSource targetRemoteDataSource = new RemoteDataSource();
       targetRemoteDataSource.setReplicatorClientIPAddress("169.254.182.164");
       targetRemoteDataSource.setReplicatorClientPortNo(new Integer("5010"));
       targetRemoteDataSource.setDataSourceName("target");
       repServer.addDataSource(targetRemoteDataSource);
       return repServer;

   }

   public PublisherDataSource configurePublisher(Replicator repServer) throws RepException {
       PublisherDataSource publisherDataSource = new PublisherDataSource(repServer, "source");
       return publisherDataSource;
   }

   public SubscriberDataSource configureSubscriber(Replicator repServer) throws RepException {
       SubscriberDataSource subscriberDataSource = new SubscriberDataSource(repServer, "target");
       return subscriberDataSource;
   }

   /**
   * After making the Subscription we can apply non real time schedule using this method.
   * @param repServer
   * @param subscription
   * @param schedule
   * @throws RepException
   */
   public void addNonRealTimeScheduleOnSubscription(Replicator repServer, Subscription subscription, Schedule schedule) throws RepException {
       // set the Occurrence Type as hours
       schedule.setOccurrenceType(_OccurrenceTypes.HOUR);
       // set schedule interval in no of hours
       schedule.setOccurrenceInterval(2);
       subscription.setSchedule(schedule);
       JobSchedular.getSharedInstance().scheduleSubscription(subscription, new ReplicationSaver(), repServer);
   }

   /**
   * After making the Subscription we can apply real time schedule using this method.
   * @param repServer
   * @param Subscription
   * @throws RepException
   */
   public void addRealTimeScheduleOnSubscription(Replicator repServer, Subscription subscription, Schedule schedule) throws RepException {
       schedule.setOccurrenceType(_OccurrenceTypes.REALTIME);
       subscription.setSchedule(schedule);
       JobSchedular.getSharedInstance().scheduleSubscription(subscription, new ReplicationSaver(), repServer);
   }

   // making a realTime Schedule
   public Schedule getSchedule() {
       Schedule schedule = new Schedule();
       schedule.setScheduleName("scheduleName");
       return schedule;
   }
}