diff --git a/asterix-events/src/main/java/edu/uci/ics/asterix/event/driver/EventDriver.java b/asterix-events/src/main/java/edu/uci/ics/asterix/event/driver/EventDriver.java
index 9facf0a..b6a32e3 100644
--- a/asterix-events/src/main/java/edu/uci/ics/asterix/event/driver/EventDriver.java
+++ b/asterix-events/src/main/java/edu/uci/ics/asterix/event/driver/EventDriver.java
@@ -41,7 +41,7 @@
 public class EventDriver {
 
     public static final String CLIENT_NODE_ID = "client_node";
-    public static final Node CLIENT_NODE = new Node(CLIENT_NODE_ID, "127.0.0.1", null, null, null, null);
+    public static final Node CLIENT_NODE = new Node(CLIENT_NODE_ID, "127.0.0.1", null, null, null, null, null);
 
     private static String eventsDir;
     private static Events events;
diff --git a/asterix-events/src/main/java/edu/uci/ics/asterix/event/management/EventUtil.java b/asterix-events/src/main/java/edu/uci/ics/asterix/event/management/EventUtil.java
index 81fabac..7cbb515 100644
--- a/asterix-events/src/main/java/edu/uci/ics/asterix/event/management/EventUtil.java
+++ b/asterix-events/src/main/java/edu/uci/ics/asterix/event/management/EventUtil.java
@@ -191,12 +191,12 @@
         }
 
         if (nodeid.equals(cluster.getMasterNode().getId())) {
-            String logDir = cluster.getMasterNode().getLogdir() == null ? cluster.getLogdir() : cluster.getMasterNode()
-                    .getLogdir();
+            String logDir = cluster.getMasterNode().getLogDir() == null ? cluster.getLogDir() : cluster.getMasterNode()
+                    .getLogDir();
             String javaHome = cluster.getMasterNode().getJavaHome() == null ? cluster.getJavaHome() : cluster
                     .getMasterNode().getJavaHome();
             return new Node(cluster.getMasterNode().getId(), cluster.getMasterNode().getClusterIp(), javaHome, logDir,
-                    null, null);
+                    null, null, null);
         }
 
         List<Node> nodeList = cluster.getNode();
diff --git a/asterix-events/src/main/resources/events/backup/backup.sh b/asterix-events/src/main/resources/events/backup/backup.sh
index 556ca39..fc6e3cc 100755
--- a/asterix-events/src/main/resources/events/backup/backup.sh
+++ b/asterix-events/src/main/resources/events/backup/backup.sh
@@ -3,7 +3,7 @@
 ASTERIX_IODEVICES=$3
 NODE_STORE=$4
 ASTERIX_ROOT_METADATA_DIR=$5
-TXN_LOG_DIR_NAME=$6
+TXN_LOG_DIR=$6
 BACKUP_ID=$7
 BACKUP_DIR=$8
 BACKUP_TYPE=$9
@@ -20,7 +20,6 @@
   for nodeIODevice in $nodeIODevices
   do
     STORE_DIR=$nodeIODevice/$NODE_STORE
-    TXN_LOG_DIR=$nodeIODevice/$TXN_LOG_DIR_NAME
     NODE_BACKUP_DIR=$BACKUP_DIR/$ASTERIX_INSTANCE_NAME/$BACKUP_ID/$NODE_ID/
    
     # make the destination directory 
@@ -46,7 +45,6 @@
   for nodeIODevice in $nodeIODevices
   do
     STORE_DIR=$nodeIODevice/$NODE_STORE
-    TXN_LOG_DIR=$nodeIODevice/$TXN_LOG_DIR_NAME
     NODE_BACKUP_DIR=$BACKUP_DIR/$ASTERIX_INSTANCE_NAME/$BACKUP_ID/$NODE_ID
 
     # create the backup directory, if it does not exists
diff --git a/asterix-events/src/main/resources/events/restore/restore.sh b/asterix-events/src/main/resources/events/restore/restore.sh
index 6396eec..88c5a6f 100755
--- a/asterix-events/src/main/resources/events/restore/restore.sh
+++ b/asterix-events/src/main/resources/events/restore/restore.sh
@@ -3,7 +3,7 @@
 ASTERIX_IODEVICES=$3
 NODE_STORE=$4
 ASTERIX_ROOT_METADATA_DIR=$5
-TXN_LOG_DIR_NAME=$6
+TXN_LOG_DIR=$6
 BACKUP_ID=$7
 BACKUP_DIR=$8
 BACKUP_TYPE=$9
@@ -33,8 +33,9 @@
   rm -rf $DEST_STORE_DIR/$SOURCE_STORE_DIR
 
   # remove the existing log directory
-  DEST_LOG_DIR=$iodevice/$TXN_LOG_DIR_NAME/
-  rm -rf $DEST_LOG_DIR
+  DEST_LOG_DIR=$TXN_LOG_DIR
+  rm -rf $DEST_LOG_DIR/*
+  TXN_LOG_DIR_NAME=${TXN_LOG_DIR%/*}
 
   # remove the existing asterix metadata directory
   rm -rf $iodevice/$ASTERIX_ROOT_METADATA_DIR
@@ -52,7 +53,7 @@
         $HADOOP_HOME/bin/hadoop fs -copyToLocal $HDFS_URL/$NODE_BACKUP_DIR/$ASTERIX_ROOT_METADATA_DIR $iodevice/
 
         # copy transaction logs directory
-        $HADOOP_HOME/bin/hadoop fs -copyToLocal $HDFS_URL/$NODE_BACKUP_DIR/$TXN_LOG_DIR_NAME $iodevice/
+        $HADOOP_HOME/bin/hadoop fs -copyToLocal $HDFS_URL/$NODE_BACKUP_DIR/$TXN_LOG_DIR_NAME $$TXN_LOG_DIR/
       fi
 
   else
@@ -67,7 +68,7 @@
         cp -r $NODE_BACKUP_DIR/$ASTERIX_ROOT_METADATA_DIR $iodevice/
 
         # copy transaction logs directory
-        cp -r $NODE_BACKUP_DIR/$TXN_LOG_DIR_NAME $iodevice/
+        cp -r $NODE_BACKUP_DIR/$TXN_LOG_DIR_NAME $TXN_LOG_DIR/
       fi
 
   fi
diff --git a/asterix-events/src/main/resources/schema/cluster.xsd b/asterix-events/src/main/resources/schema/cluster.xsd
index 4292418..718d7b0 100644
--- a/asterix-events/src/main/resources/schema/cluster.xsd
+++ b/asterix-events/src/main/resources/schema/cluster.xsd
@@ -4,10 +4,11 @@
 
 	<!-- definition of simple types -->
 	<xs:element name="name" type="xs:string" />
-	<xs:element name="logdir" type="xs:string" />
+	<xs:element name="log_dir" type="xs:string" />
+	<xs:element name="txn_log_dir" type="xs:string" />
 	<xs:element name="id" type="xs:string" />
-	<xs:element name="client-ip" type="xs:string" />
-	<xs:element name="cluster-ip" type="xs:string" />
+	<xs:element name="client_ip" type="xs:string" />
+	<xs:element name="cluster_ip" type="xs:string" />
 	<xs:element name="key" type="xs:string" />
 	<xs:element name="value" type="xs:string" />
 	<xs:element name="dir" type="xs:string" />
@@ -18,7 +19,7 @@
 	<xs:element name="username" type="xs:string" />
 
 	<!-- definition of complex elements -->
-	<xs:element name="workingDir">
+	<xs:element name="working_dir">
 		<xs:complexType>
 			<xs:sequence>
 				<xs:element ref="cl:dir" />
@@ -27,14 +28,14 @@
 		</xs:complexType>
 	</xs:element>
 
-	<xs:element name="master-node">
+	<xs:element name="master_node">
 		<xs:complexType>
 			<xs:sequence>
 				<xs:element ref="cl:id" />
-				<xs:element ref="cl:client-ip" />
-				<xs:element ref="cl:cluster-ip" />
+				<xs:element ref="cl:client_ip" />
+				<xs:element ref="cl:cluster_ip" />
 				<xs:element ref="cl:java_home" minOccurs="0" />
-				<xs:element ref="cl:logdir" minOccurs="0" />
+				<xs:element ref="cl:log_dir" minOccurs="0" />
 			</xs:sequence>
 		</xs:complexType>
 	</xs:element>
@@ -60,9 +61,10 @@
 		<xs:complexType>
 			<xs:sequence>
 				<xs:element ref="cl:id" />
-				<xs:element ref="cl:cluster-ip" />
+				<xs:element ref="cl:cluster_ip" />
 				<xs:element ref="cl:java_home" minOccurs="0" />
-				<xs:element ref="cl:logdir" minOccurs="0" />
+				<xs:element ref="cl:log_dir" minOccurs="0" />
+				<xs:element ref="cl:txn_log_dir" minOccurs="0" />
 				<xs:element ref="cl:store" minOccurs="0" />
 				<xs:element ref="cl:iodevices" minOccurs="0" />
 			</xs:sequence>
@@ -76,11 +78,12 @@
 				<xs:element ref="cl:username" />
 				<xs:element ref="cl:env" minOccurs="0" />
 				<xs:element ref="cl:java_home" minOccurs="0" />
-				<xs:element ref="cl:logdir" minOccurs="0" />
+				<xs:element ref="cl:log_dir" minOccurs="0" />
+				<xs:element ref="cl:txn_log_dir" minOccurs="0" />
 				<xs:element ref="cl:store" minOccurs="0" />
 				<xs:element ref="cl:iodevices" minOccurs="0" />
-				<xs:element ref="cl:workingDir" />
-				<xs:element ref="cl:master-node" />
+				<xs:element ref="cl:working_dir" />
+				<xs:element ref="cl:master_node" />
 				<xs:element ref="cl:node" maxOccurs="unbounded" />
 			</xs:sequence>
 		</xs:complexType>
