diff --git a/asterix-installer/pom.xml b/asterix-installer/pom.xml
index fbca379..6462c9d 100644
--- a/asterix-installer/pom.xml
+++ b/asterix-installer/pom.xml
@@ -16,7 +16,7 @@
 	<modelVersion>4.0.0</modelVersion>
 	<parent>
 		<artifactId>asterix</artifactId>
-		<groupId>edu.uci.ics.asterix</groupId>
+		<groupId>org.apache.asterix</groupId>
 		<version>0.8.7-SNAPSHOT</version>
 	</parent>
 	<artifactId>asterix-installer</artifactId>
@@ -77,7 +77,7 @@
 							<schemaIncludes>
 								<include>installer-conf.xsd</include>
 							</schemaIncludes>
-							<generatePackage>edu.uci.ics.asterix.installer.schema.conf</generatePackage>
+							<generatePackage>org.apache.asterix.installer.schema.conf</generatePackage>
 							<generateDirectory>${project.build.directory}/generated-sources/configuration</generateDirectory>
 						</configuration>
 					</execution>
@@ -91,7 +91,7 @@
 							<schemaIncludes>
 								<include>cluster.xsd</include>
 							</schemaIncludes>
-							<generatePackage>edu.uci.ics.asterix.installer.schema.cluster</generatePackage>
+							<generatePackage>org.apache.asterix.installer.schema.cluster</generatePackage>
 							<bindingDirectory>src/main/resources/schema</bindingDirectory>
 							<bindingIncludes>
 								<bindingInclude>jaxb-bindings.xjb</bindingInclude>
@@ -245,28 +245,28 @@
 			<artifactId>commons-io</artifactId>
 		</dependency>
 		<dependency>
-			<groupId>edu.uci.ics.asterix</groupId>
+			<groupId>org.apache.asterix</groupId>
 			<artifactId>asterix-events</artifactId>
 			<version>0.8.7-SNAPSHOT</version>
 			<type>jar</type>
 			<scope>compile</scope>
 		</dependency>
 		<dependency>
-			<groupId>edu.uci.ics.asterix</groupId>
+			<groupId>org.apache.asterix</groupId>
 			<artifactId>asterix-common</artifactId>
 			<version>0.8.7-SNAPSHOT</version>
 			<type>test-jar</type>
 			<scope>test</scope>
 		</dependency>
 		<dependency>
-			<groupId>edu.uci.ics.asterix</groupId>
+			<groupId>org.apache.asterix</groupId>
 			<artifactId>asterix-server</artifactId>
 			<version>0.8.7-SNAPSHOT</version>
 			<type>zip</type>
 			<classifier>binary-assembly</classifier>
 		</dependency>
 		<dependency>
-			<groupId>edu.uci.ics.asterix</groupId>
+			<groupId>org.apache.asterix</groupId>
 			<artifactId>asterix-test-framework</artifactId>
 			<version>0.8.7-SNAPSHOT</version>
 			<scope>test</scope>
diff --git a/asterix-installer/src/main/assembly/binary-assembly.xml b/asterix-installer/src/main/assembly/binary-assembly.xml
index 8b52fc4..e096ee4 100644
--- a/asterix-installer/src/main/assembly/binary-assembly.xml
+++ b/asterix-installer/src/main/assembly/binary-assembly.xml
@@ -75,8 +75,8 @@
 		<dependencySet>
 			<includes>
 				<include>log4j:log4j</include>
-				<include>edu.uci.ics.asterix:asterix-events</include>
-				<include>edu.uci.ics.asterix:asterix-common</include>
+				<include>org.apache.asterix:asterix-events</include>
+				<include>org.apache.asterix:asterix-common</include>
 				<include>org.apache.zookeeper:zookeeper</include>
 				<include>args4j:args4j</include>
 				<include>log4j:log4j</include>
diff --git a/asterix-installer/src/main/java/org/apache/asterix/installer/command/AbstractCommand.java b/asterix-installer/src/main/java/org/apache/asterix/installer/command/AbstractCommand.java
index f72f88a..3a87250 100644
--- a/asterix-installer/src/main/java/org/apache/asterix/installer/command/AbstractCommand.java
+++ b/asterix-installer/src/main/java/org/apache/asterix/installer/command/AbstractCommand.java
@@ -12,7 +12,7 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-package edu.uci.ics.asterix.installer.command;
+package org.apache.asterix.installer.command;
 
 import org.apache.log4j.Logger;
 import org.kohsuke.args4j.CmdLineParser;
diff --git a/asterix-installer/src/main/java/org/apache/asterix/installer/command/AlterCommand.java b/asterix-installer/src/main/java/org/apache/asterix/installer/command/AlterCommand.java
index 4bb5056..f63d832 100644
--- a/asterix-installer/src/main/java/org/apache/asterix/installer/command/AlterCommand.java
+++ b/asterix-installer/src/main/java/org/apache/asterix/installer/command/AlterCommand.java
@@ -12,20 +12,20 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-package edu.uci.ics.asterix.installer.command;
+package org.apache.asterix.installer.command;
 
 import java.util.Date;
 
 import org.kohsuke.args4j.Option;
 
-import edu.uci.ics.asterix.common.configuration.AsterixConfiguration;
-import edu.uci.ics.asterix.event.model.AsterixInstance;
-import edu.uci.ics.asterix.event.model.AsterixInstance.State;
-import edu.uci.ics.asterix.event.service.AsterixEventServiceUtil;
-import edu.uci.ics.asterix.event.service.ILookupService;
-import edu.uci.ics.asterix.event.service.ServiceProvider;
-import edu.uci.ics.asterix.installer.driver.InstallerDriver;
-import edu.uci.ics.asterix.installer.driver.InstallerUtil;
+import org.apache.asterix.common.configuration.AsterixConfiguration;
+import org.apache.asterix.event.model.AsterixInstance;
+import org.apache.asterix.event.model.AsterixInstance.State;
+import org.apache.asterix.event.service.AsterixEventServiceUtil;
+import org.apache.asterix.event.service.ILookupService;
+import org.apache.asterix.event.service.ServiceProvider;
+import org.apache.asterix.installer.driver.InstallerDriver;
+import org.apache.asterix.installer.driver.InstallerUtil;
 
 public class AlterCommand extends AbstractCommand {
 
diff --git a/asterix-installer/src/main/java/org/apache/asterix/installer/command/BackupCommand.java b/asterix-installer/src/main/java/org/apache/asterix/installer/command/BackupCommand.java
index 960f041..2cc0d88 100644
--- a/asterix-installer/src/main/java/org/apache/asterix/installer/command/BackupCommand.java
+++ b/asterix-installer/src/main/java/org/apache/asterix/installer/command/BackupCommand.java
@@ -12,23 +12,23 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-package edu.uci.ics.asterix.installer.command;
+package org.apache.asterix.installer.command;
 
 import java.util.Date;
 import java.util.List;
 
 import org.kohsuke.args4j.Option;
 
-import edu.uci.ics.asterix.event.model.AsterixInstance;
-import edu.uci.ics.asterix.event.model.AsterixInstance.State;
-import edu.uci.ics.asterix.event.model.BackupInfo;
-import edu.uci.ics.asterix.event.schema.pattern.Patterns;
-import edu.uci.ics.asterix.event.service.AsterixEventService;
-import edu.uci.ics.asterix.event.service.AsterixEventServiceUtil;
-import edu.uci.ics.asterix.event.service.ServiceProvider;
-import edu.uci.ics.asterix.event.util.PatternCreator;
-import edu.uci.ics.asterix.installer.driver.InstallerDriver;
-import edu.uci.ics.asterix.installer.schema.conf.Backup;
+import org.apache.asterix.event.model.AsterixInstance;
+import org.apache.asterix.event.model.AsterixInstance.State;
+import org.apache.asterix.event.model.BackupInfo;
+import org.apache.asterix.event.schema.pattern.Patterns;
+import org.apache.asterix.event.service.AsterixEventService;
+import org.apache.asterix.event.service.AsterixEventServiceUtil;
+import org.apache.asterix.event.service.ServiceProvider;
+import org.apache.asterix.event.util.PatternCreator;
+import org.apache.asterix.installer.driver.InstallerDriver;
+import org.apache.asterix.installer.schema.conf.Backup;
 
 public class BackupCommand extends AbstractCommand {
 
diff --git a/asterix-installer/src/main/java/org/apache/asterix/installer/command/CommandConfig.java b/asterix-installer/src/main/java/org/apache/asterix/installer/command/CommandConfig.java
index 4106562..d562d06 100644
--- a/asterix-installer/src/main/java/org/apache/asterix/installer/command/CommandConfig.java
+++ b/asterix-installer/src/main/java/org/apache/asterix/installer/command/CommandConfig.java
@@ -12,7 +12,7 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-package edu.uci.ics.asterix.installer.command;
+package org.apache.asterix.installer.command;
 
 public abstract class CommandConfig {
 
diff --git a/asterix-installer/src/main/java/org/apache/asterix/installer/command/CommandHandler.java b/asterix-installer/src/main/java/org/apache/asterix/installer/command/CommandHandler.java
index b2a9b74..17da694 100644
--- a/asterix-installer/src/main/java/org/apache/asterix/installer/command/CommandHandler.java
+++ b/asterix-installer/src/main/java/org/apache/asterix/installer/command/CommandHandler.java
@@ -12,9 +12,9 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-package edu.uci.ics.asterix.installer.command;
+package org.apache.asterix.installer.command;
 
-import edu.uci.ics.asterix.installer.command.ICommand.CommandType;
+import org.apache.asterix.installer.command.ICommand.CommandType;
 
 public class CommandHandler {
 
diff --git a/asterix-installer/src/main/java/org/apache/asterix/installer/command/ConfigureCommand.java b/asterix-installer/src/main/java/org/apache/asterix/installer/command/ConfigureCommand.java
index 838c095..16d1a9e 100644
--- a/asterix-installer/src/main/java/org/apache/asterix/installer/command/ConfigureCommand.java
+++ b/asterix-installer/src/main/java/org/apache/asterix/installer/command/ConfigureCommand.java
@@ -12,7 +12,7 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-package edu.uci.ics.asterix.installer.command;
+package org.apache.asterix.installer.command;
 
 import java.io.File;
 import java.io.FileNotFoundException;
@@ -24,12 +24,12 @@
 import javax.xml.bind.PropertyException;
 import javax.xml.bind.Unmarshaller;
 
-import edu.uci.ics.asterix.event.management.EventUtil;
-import edu.uci.ics.asterix.event.schema.cluster.Cluster;
-import edu.uci.ics.asterix.event.schema.cluster.Node;
-import edu.uci.ics.asterix.event.schema.cluster.WorkingDir;
-import edu.uci.ics.asterix.installer.driver.InstallerDriver;
-import edu.uci.ics.asterix.installer.schema.conf.Configuration;
+import org.apache.asterix.event.management.EventUtil;
+import org.apache.asterix.event.schema.cluster.Cluster;
+import org.apache.asterix.event.schema.cluster.Node;
+import org.apache.asterix.event.schema.cluster.WorkingDir;
+import org.apache.asterix.installer.driver.InstallerDriver;
+import org.apache.asterix.installer.schema.conf.Configuration;
 
 public class ConfigureCommand extends AbstractCommand {
 
diff --git a/asterix-installer/src/main/java/org/apache/asterix/installer/command/CreateCommand.java b/asterix-installer/src/main/java/org/apache/asterix/installer/command/CreateCommand.java
index c7d8a12..2a83dee 100644
--- a/asterix-installer/src/main/java/org/apache/asterix/installer/command/CreateCommand.java
+++ b/asterix-installer/src/main/java/org/apache/asterix/installer/command/CreateCommand.java
@@ -12,26 +12,26 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-package edu.uci.ics.asterix.installer.command;
+package org.apache.asterix.installer.command;
 
 import java.io.File;
 
 import org.kohsuke.args4j.Option;
 
-import edu.uci.ics.asterix.common.configuration.AsterixConfiguration;
-import edu.uci.ics.asterix.event.error.VerificationUtil;
-import edu.uci.ics.asterix.event.management.AsterixEventServiceClient;
-import edu.uci.ics.asterix.event.management.EventUtil;
-import edu.uci.ics.asterix.event.model.AsterixInstance;
-import edu.uci.ics.asterix.event.model.AsterixRuntimeState;
-import edu.uci.ics.asterix.event.schema.cluster.Cluster;
-import edu.uci.ics.asterix.event.schema.pattern.Patterns;
-import edu.uci.ics.asterix.event.service.AsterixEventService;
-import edu.uci.ics.asterix.event.service.AsterixEventServiceUtil;
-import edu.uci.ics.asterix.event.service.ServiceProvider;
-import edu.uci.ics.asterix.event.util.PatternCreator;
-import edu.uci.ics.asterix.installer.driver.InstallerDriver;
-import edu.uci.ics.asterix.installer.driver.InstallerUtil;
+import org.apache.asterix.common.configuration.AsterixConfiguration;
+import org.apache.asterix.event.error.VerificationUtil;
+import org.apache.asterix.event.management.AsterixEventServiceClient;
+import org.apache.asterix.event.management.EventUtil;
+import org.apache.asterix.event.model.AsterixInstance;
+import org.apache.asterix.event.model.AsterixRuntimeState;
+import org.apache.asterix.event.schema.cluster.Cluster;
+import org.apache.asterix.event.schema.pattern.Patterns;
+import org.apache.asterix.event.service.AsterixEventService;
+import org.apache.asterix.event.service.AsterixEventServiceUtil;
+import org.apache.asterix.event.service.ServiceProvider;
+import org.apache.asterix.event.util.PatternCreator;
+import org.apache.asterix.installer.driver.InstallerDriver;
+import org.apache.asterix.installer.driver.InstallerUtil;
 
 public class CreateCommand extends AbstractCommand {
 
diff --git a/asterix-installer/src/main/java/org/apache/asterix/installer/command/DeleteCommand.java b/asterix-installer/src/main/java/org/apache/asterix/installer/command/DeleteCommand.java
index b1f82d1..a52c9d4 100644
--- a/asterix-installer/src/main/java/org/apache/asterix/installer/command/DeleteCommand.java
+++ b/asterix-installer/src/main/java/org/apache/asterix/installer/command/DeleteCommand.java
@@ -12,18 +12,18 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-package edu.uci.ics.asterix.installer.command;
+package org.apache.asterix.installer.command;
 
 import org.kohsuke.args4j.Option;
 
-import edu.uci.ics.asterix.event.model.AsterixInstance;
-import edu.uci.ics.asterix.event.model.AsterixInstance.State;
-import edu.uci.ics.asterix.event.schema.pattern.Patterns;
-import edu.uci.ics.asterix.event.service.AsterixEventService;
-import edu.uci.ics.asterix.event.service.AsterixEventServiceUtil;
-import edu.uci.ics.asterix.event.service.ServiceProvider;
-import edu.uci.ics.asterix.event.util.PatternCreator;
-import edu.uci.ics.asterix.installer.driver.InstallerDriver;
+import org.apache.asterix.event.model.AsterixInstance;
+import org.apache.asterix.event.model.AsterixInstance.State;
+import org.apache.asterix.event.schema.pattern.Patterns;
+import org.apache.asterix.event.service.AsterixEventService;
+import org.apache.asterix.event.service.AsterixEventServiceUtil;
+import org.apache.asterix.event.service.ServiceProvider;
+import org.apache.asterix.event.util.PatternCreator;
+import org.apache.asterix.installer.driver.InstallerDriver;
 
 public class DeleteCommand extends AbstractCommand {
 
diff --git a/asterix-installer/src/main/java/org/apache/asterix/installer/command/DescribeCommand.java b/asterix-installer/src/main/java/org/apache/asterix/installer/command/DescribeCommand.java
index 62760f6..ffdc32b 100644
--- a/asterix-installer/src/main/java/org/apache/asterix/installer/command/DescribeCommand.java
+++ b/asterix-installer/src/main/java/org/apache/asterix/installer/command/DescribeCommand.java
@@ -12,20 +12,20 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-package edu.uci.ics.asterix.installer.command;
+package org.apache.asterix.installer.command;
 
 import java.util.List;
 
 import org.kohsuke.args4j.Option;
 
-import edu.uci.ics.asterix.event.error.VerificationUtil;
-import edu.uci.ics.asterix.event.model.AsterixInstance;
-import edu.uci.ics.asterix.event.model.AsterixInstance.State;
-import edu.uci.ics.asterix.event.model.AsterixRuntimeState;
-import edu.uci.ics.asterix.event.service.AsterixEventServiceUtil;
-import edu.uci.ics.asterix.event.service.ServiceProvider;
-import edu.uci.ics.asterix.installer.driver.InstallerDriver;
-import edu.uci.ics.asterix.installer.error.InstallerException;
+import org.apache.asterix.event.error.VerificationUtil;
+import org.apache.asterix.event.model.AsterixInstance;
+import org.apache.asterix.event.model.AsterixInstance.State;
+import org.apache.asterix.event.model.AsterixRuntimeState;
+import org.apache.asterix.event.service.AsterixEventServiceUtil;
+import org.apache.asterix.event.service.ServiceProvider;
+import org.apache.asterix.installer.driver.InstallerDriver;
+import org.apache.asterix.installer.error.InstallerException;
 
 public class DescribeCommand extends AbstractCommand {
 
diff --git a/asterix-installer/src/main/java/org/apache/asterix/installer/command/HelpCommand.java b/asterix-installer/src/main/java/org/apache/asterix/installer/command/HelpCommand.java
index 11269e3..ce8dc39 100644
--- a/asterix-installer/src/main/java/org/apache/asterix/installer/command/HelpCommand.java
+++ b/asterix-installer/src/main/java/org/apache/asterix/installer/command/HelpCommand.java
@@ -12,7 +12,7 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-package edu.uci.ics.asterix.installer.command;
+package org.apache.asterix.installer.command;
 
 import org.kohsuke.args4j.Option;
 
diff --git a/asterix-installer/src/main/java/org/apache/asterix/installer/command/ICommand.java b/asterix-installer/src/main/java/org/apache/asterix/installer/command/ICommand.java
index 45f8943..ed88feb 100644
--- a/asterix-installer/src/main/java/org/apache/asterix/installer/command/ICommand.java
+++ b/asterix-installer/src/main/java/org/apache/asterix/installer/command/ICommand.java
@@ -12,7 +12,7 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-package edu.uci.ics.asterix.installer.command;
+package org.apache.asterix.installer.command;
 
 public interface ICommand {
 
diff --git a/asterix-installer/src/main/java/org/apache/asterix/installer/command/InstallCommand.java b/asterix-installer/src/main/java/org/apache/asterix/installer/command/InstallCommand.java
index 31d501b..324cb09 100644
--- a/asterix-installer/src/main/java/org/apache/asterix/installer/command/InstallCommand.java
+++ b/asterix-installer/src/main/java/org/apache/asterix/installer/command/InstallCommand.java
@@ -12,17 +12,17 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-package edu.uci.ics.asterix.installer.command;
+package org.apache.asterix.installer.command;
 
 import org.kohsuke.args4j.Option;
 
-import edu.uci.ics.asterix.event.model.AsterixInstance;
-import edu.uci.ics.asterix.event.model.AsterixInstance.State;
-import edu.uci.ics.asterix.event.schema.pattern.Patterns;
-import edu.uci.ics.asterix.event.service.AsterixEventService;
-import edu.uci.ics.asterix.event.service.AsterixEventServiceUtil;
-import edu.uci.ics.asterix.event.util.PatternCreator;
-import edu.uci.ics.asterix.installer.driver.InstallerDriver;
+import org.apache.asterix.event.model.AsterixInstance;
+import org.apache.asterix.event.model.AsterixInstance.State;
+import org.apache.asterix.event.schema.pattern.Patterns;
+import org.apache.asterix.event.service.AsterixEventService;
+import org.apache.asterix.event.service.AsterixEventServiceUtil;
+import org.apache.asterix.event.util.PatternCreator;
+import org.apache.asterix.installer.driver.InstallerDriver;
 
 public class InstallCommand extends AbstractCommand {
 
diff --git a/asterix-installer/src/main/java/org/apache/asterix/installer/command/LogCommand.java b/asterix-installer/src/main/java/org/apache/asterix/installer/command/LogCommand.java
index 5526e4a..528fe85 100644
--- a/asterix-installer/src/main/java/org/apache/asterix/installer/command/LogCommand.java
+++ b/asterix-installer/src/main/java/org/apache/asterix/installer/command/LogCommand.java
@@ -12,7 +12,7 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-package edu.uci.ics.asterix.installer.command;
+package org.apache.asterix.installer.command;
 
 import java.io.File;
 import java.io.FilenameFilter;
@@ -21,15 +21,15 @@
 import org.apache.commons.io.FileUtils;
 import org.kohsuke.args4j.Option;
 
-import edu.uci.ics.asterix.event.management.AsterixEventServiceClient;
-import edu.uci.ics.asterix.event.model.AsterixInstance;
-import edu.uci.ics.asterix.event.model.AsterixInstance.State;
-import edu.uci.ics.asterix.event.schema.pattern.Patterns;
-import edu.uci.ics.asterix.event.service.AsterixEventService;
-import edu.uci.ics.asterix.event.service.AsterixEventServiceUtil;
-import edu.uci.ics.asterix.event.util.PatternCreator;
-import edu.uci.ics.asterix.installer.driver.InstallerDriver;
-import edu.uci.ics.asterix.installer.error.InstallerException;
+import org.apache.asterix.event.management.AsterixEventServiceClient;
+import org.apache.asterix.event.model.AsterixInstance;
+import org.apache.asterix.event.model.AsterixInstance.State;
+import org.apache.asterix.event.schema.pattern.Patterns;
+import org.apache.asterix.event.service.AsterixEventService;
+import org.apache.asterix.event.service.AsterixEventServiceUtil;
+import org.apache.asterix.event.util.PatternCreator;
+import org.apache.asterix.installer.driver.InstallerDriver;
+import org.apache.asterix.installer.error.InstallerException;
 
 public class LogCommand extends AbstractCommand {
 
diff --git a/asterix-installer/src/main/java/org/apache/asterix/installer/command/RestoreCommand.java b/asterix-installer/src/main/java/org/apache/asterix/installer/command/RestoreCommand.java
index 8a5c5a1..b7c326a 100644
--- a/asterix-installer/src/main/java/org/apache/asterix/installer/command/RestoreCommand.java
+++ b/asterix-installer/src/main/java/org/apache/asterix/installer/command/RestoreCommand.java
@@ -12,20 +12,20 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-package edu.uci.ics.asterix.installer.command;
+package org.apache.asterix.installer.command;
 
 import java.util.List;
 
 import org.kohsuke.args4j.Option;
 
-import edu.uci.ics.asterix.event.model.AsterixInstance;
-import edu.uci.ics.asterix.event.model.AsterixInstance.State;
-import edu.uci.ics.asterix.event.model.BackupInfo;
-import edu.uci.ics.asterix.event.schema.pattern.Patterns;
-import edu.uci.ics.asterix.event.service.AsterixEventService;
-import edu.uci.ics.asterix.event.service.AsterixEventServiceUtil;
-import edu.uci.ics.asterix.event.util.PatternCreator;
-import edu.uci.ics.asterix.installer.driver.InstallerDriver;
+import org.apache.asterix.event.model.AsterixInstance;
+import org.apache.asterix.event.model.AsterixInstance.State;
+import org.apache.asterix.event.model.BackupInfo;
+import org.apache.asterix.event.schema.pattern.Patterns;
+import org.apache.asterix.event.service.AsterixEventService;
+import org.apache.asterix.event.service.AsterixEventServiceUtil;
+import org.apache.asterix.event.util.PatternCreator;
+import org.apache.asterix.installer.driver.InstallerDriver;
 
 public class RestoreCommand extends AbstractCommand {
 
diff --git a/asterix-installer/src/main/java/org/apache/asterix/installer/command/ShutdownCommand.java b/asterix-installer/src/main/java/org/apache/asterix/installer/command/ShutdownCommand.java
index a33b9d2..60cc8f3 100644
--- a/asterix-installer/src/main/java/org/apache/asterix/installer/command/ShutdownCommand.java
+++ b/asterix-installer/src/main/java/org/apache/asterix/installer/command/ShutdownCommand.java
@@ -12,12 +12,12 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-package edu.uci.ics.asterix.installer.command;
+package org.apache.asterix.installer.command;
 
-import edu.uci.ics.asterix.event.service.AsterixEventService;
-import edu.uci.ics.asterix.event.service.ILookupService;
-import edu.uci.ics.asterix.event.service.ServiceProvider;
-import edu.uci.ics.asterix.installer.driver.InstallerDriver;
+import org.apache.asterix.event.service.AsterixEventService;
+import org.apache.asterix.event.service.ILookupService;
+import org.apache.asterix.event.service.ServiceProvider;
+import org.apache.asterix.installer.driver.InstallerDriver;
 
 public class ShutdownCommand extends AbstractCommand {
 
diff --git a/asterix-installer/src/main/java/org/apache/asterix/installer/command/StartCommand.java b/asterix-installer/src/main/java/org/apache/asterix/installer/command/StartCommand.java
index 1310b1d..944f68d 100644
--- a/asterix-installer/src/main/java/org/apache/asterix/installer/command/StartCommand.java
+++ b/asterix-installer/src/main/java/org/apache/asterix/installer/command/StartCommand.java
@@ -12,23 +12,23 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-package edu.uci.ics.asterix.installer.command;
+package org.apache.asterix.installer.command;
 
 import java.io.File;
 
 import org.kohsuke.args4j.Option;
 
-import edu.uci.ics.asterix.event.error.VerificationUtil;
-import edu.uci.ics.asterix.event.management.AsterixEventServiceClient;
-import edu.uci.ics.asterix.event.model.AsterixInstance;
-import edu.uci.ics.asterix.event.model.AsterixInstance.State;
-import edu.uci.ics.asterix.event.model.AsterixRuntimeState;
-import edu.uci.ics.asterix.event.schema.pattern.Patterns;
-import edu.uci.ics.asterix.event.service.AsterixEventService;
-import edu.uci.ics.asterix.event.service.AsterixEventServiceUtil;
-import edu.uci.ics.asterix.event.service.ServiceProvider;
-import edu.uci.ics.asterix.event.util.PatternCreator;
-import edu.uci.ics.asterix.installer.driver.InstallerDriver;
+import org.apache.asterix.event.error.VerificationUtil;
+import org.apache.asterix.event.management.AsterixEventServiceClient;
+import org.apache.asterix.event.model.AsterixInstance;
+import org.apache.asterix.event.model.AsterixInstance.State;
+import org.apache.asterix.event.model.AsterixRuntimeState;
+import org.apache.asterix.event.schema.pattern.Patterns;
+import org.apache.asterix.event.service.AsterixEventService;
+import org.apache.asterix.event.service.AsterixEventServiceUtil;
+import org.apache.asterix.event.service.ServiceProvider;
+import org.apache.asterix.event.util.PatternCreator;
+import org.apache.asterix.installer.driver.InstallerDriver;
 
 public class StartCommand extends AbstractCommand {
 
diff --git a/asterix-installer/src/main/java/org/apache/asterix/installer/command/StartNodeCommand.java b/asterix-installer/src/main/java/org/apache/asterix/installer/command/StartNodeCommand.java
index 70cac7f..9d2dfca 100644
--- a/asterix-installer/src/main/java/org/apache/asterix/installer/command/StartNodeCommand.java
+++ b/asterix-installer/src/main/java/org/apache/asterix/installer/command/StartNodeCommand.java
@@ -12,29 +12,29 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-package edu.uci.ics.asterix.installer.command;
+package org.apache.asterix.installer.command;
 
 import java.util.ArrayList;
 import java.util.List;
 
 import org.kohsuke.args4j.Option;
 
-import edu.uci.ics.asterix.event.error.VerificationUtil;
-import edu.uci.ics.asterix.event.management.AsterixEventServiceClient;
-import edu.uci.ics.asterix.event.model.AsterixInstance;
-import edu.uci.ics.asterix.event.model.AsterixInstance.State;
-import edu.uci.ics.asterix.event.model.AsterixRuntimeState;
-import edu.uci.ics.asterix.event.model.ProcessInfo;
-import edu.uci.ics.asterix.event.schema.cluster.Cluster;
-import edu.uci.ics.asterix.event.schema.cluster.Node;
-import edu.uci.ics.asterix.event.schema.pattern.Pattern;
-import edu.uci.ics.asterix.event.schema.pattern.Patterns;
-import edu.uci.ics.asterix.event.service.AsterixEventService;
-import edu.uci.ics.asterix.event.service.AsterixEventServiceUtil;
-import edu.uci.ics.asterix.event.service.ServiceProvider;
-import edu.uci.ics.asterix.event.util.PatternCreator;
-import edu.uci.ics.asterix.installer.driver.InstallerDriver;
-import edu.uci.ics.asterix.installer.error.InstallerException;
+import org.apache.asterix.event.error.VerificationUtil;
+import org.apache.asterix.event.management.AsterixEventServiceClient;
+import org.apache.asterix.event.model.AsterixInstance;
+import org.apache.asterix.event.model.AsterixInstance.State;
+import org.apache.asterix.event.model.AsterixRuntimeState;
+import org.apache.asterix.event.model.ProcessInfo;
+import org.apache.asterix.event.schema.cluster.Cluster;
+import org.apache.asterix.event.schema.cluster.Node;
+import org.apache.asterix.event.schema.pattern.Pattern;
+import org.apache.asterix.event.schema.pattern.Patterns;
+import org.apache.asterix.event.service.AsterixEventService;
+import org.apache.asterix.event.service.AsterixEventServiceUtil;
+import org.apache.asterix.event.service.ServiceProvider;
+import org.apache.asterix.event.util.PatternCreator;
+import org.apache.asterix.installer.driver.InstallerDriver;
+import org.apache.asterix.installer.error.InstallerException;
 
 public class StartNodeCommand extends AbstractCommand {
 
diff --git a/asterix-installer/src/main/java/org/apache/asterix/installer/command/StopCommand.java b/asterix-installer/src/main/java/org/apache/asterix/installer/command/StopCommand.java
index 8c681f3..3b1f0c4 100644
--- a/asterix-installer/src/main/java/org/apache/asterix/installer/command/StopCommand.java
+++ b/asterix-installer/src/main/java/org/apache/asterix/installer/command/StopCommand.java
@@ -12,7 +12,7 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-package edu.uci.ics.asterix.installer.command;
+package org.apache.asterix.installer.command;
 
 import java.util.ArrayList;
 import java.util.Date;
@@ -20,17 +20,17 @@
 
 import org.kohsuke.args4j.Option;
 
-import edu.uci.ics.asterix.event.management.AsterixEventServiceClient;
-import edu.uci.ics.asterix.event.model.AsterixInstance;
-import edu.uci.ics.asterix.event.model.AsterixInstance.State;
-import edu.uci.ics.asterix.event.schema.cluster.Node;
-import edu.uci.ics.asterix.event.schema.pattern.Pattern;
-import edu.uci.ics.asterix.event.schema.pattern.Patterns;
-import edu.uci.ics.asterix.event.service.AsterixEventService;
-import edu.uci.ics.asterix.event.service.AsterixEventServiceUtil;
-import edu.uci.ics.asterix.event.service.ServiceProvider;
-import edu.uci.ics.asterix.event.util.PatternCreator;
-import edu.uci.ics.asterix.installer.driver.InstallerDriver;
+import org.apache.asterix.event.management.AsterixEventServiceClient;
+import org.apache.asterix.event.model.AsterixInstance;
+import org.apache.asterix.event.model.AsterixInstance.State;
+import org.apache.asterix.event.schema.cluster.Node;
+import org.apache.asterix.event.schema.pattern.Pattern;
+import org.apache.asterix.event.schema.pattern.Patterns;
+import org.apache.asterix.event.service.AsterixEventService;
+import org.apache.asterix.event.service.AsterixEventServiceUtil;
+import org.apache.asterix.event.service.ServiceProvider;
+import org.apache.asterix.event.util.PatternCreator;
+import org.apache.asterix.installer.driver.InstallerDriver;
 
 public class StopCommand extends AbstractCommand {
 
diff --git a/asterix-installer/src/main/java/org/apache/asterix/installer/command/StopNodeCommand.java b/asterix-installer/src/main/java/org/apache/asterix/installer/command/StopNodeCommand.java
index 7b504f2..654a516 100644
--- a/asterix-installer/src/main/java/org/apache/asterix/installer/command/StopNodeCommand.java
+++ b/asterix-installer/src/main/java/org/apache/asterix/installer/command/StopNodeCommand.java
@@ -12,7 +12,7 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-package edu.uci.ics.asterix.installer.command;
+package org.apache.asterix.installer.command;
 
 import java.util.ArrayList;
 import java.util.Date;
@@ -20,21 +20,21 @@
 
 import org.kohsuke.args4j.Option;
 
-import edu.uci.ics.asterix.event.error.VerificationUtil;
-import edu.uci.ics.asterix.event.management.AsterixEventServiceClient;
-import edu.uci.ics.asterix.event.model.AsterixInstance;
-import edu.uci.ics.asterix.event.model.AsterixInstance.State;
-import edu.uci.ics.asterix.event.model.AsterixRuntimeState;
-import edu.uci.ics.asterix.event.model.ProcessInfo;
-import edu.uci.ics.asterix.event.schema.cluster.Node;
-import edu.uci.ics.asterix.event.schema.pattern.Pattern;
-import edu.uci.ics.asterix.event.schema.pattern.Patterns;
-import edu.uci.ics.asterix.event.service.AsterixEventService;
-import edu.uci.ics.asterix.event.service.AsterixEventServiceUtil;
-import edu.uci.ics.asterix.event.service.ServiceProvider;
-import edu.uci.ics.asterix.event.util.PatternCreator;
-import edu.uci.ics.asterix.installer.driver.InstallerDriver;
-import edu.uci.ics.asterix.installer.error.InstallerException;
+import org.apache.asterix.event.error.VerificationUtil;
+import org.apache.asterix.event.management.AsterixEventServiceClient;
+import org.apache.asterix.event.model.AsterixInstance;
+import org.apache.asterix.event.model.AsterixInstance.State;
+import org.apache.asterix.event.model.AsterixRuntimeState;
+import org.apache.asterix.event.model.ProcessInfo;
+import org.apache.asterix.event.schema.cluster.Node;
+import org.apache.asterix.event.schema.pattern.Pattern;
+import org.apache.asterix.event.schema.pattern.Patterns;
+import org.apache.asterix.event.service.AsterixEventService;
+import org.apache.asterix.event.service.AsterixEventServiceUtil;
+import org.apache.asterix.event.service.ServiceProvider;
+import org.apache.asterix.event.util.PatternCreator;
+import org.apache.asterix.installer.driver.InstallerDriver;
+import org.apache.asterix.installer.error.InstallerException;
 
 public class StopNodeCommand extends AbstractCommand {
 
diff --git a/asterix-installer/src/main/java/org/apache/asterix/installer/command/UninstallCommand.java b/asterix-installer/src/main/java/org/apache/asterix/installer/command/UninstallCommand.java
index df576a8..9a94441 100644
--- a/asterix-installer/src/main/java/org/apache/asterix/installer/command/UninstallCommand.java
+++ b/asterix-installer/src/main/java/org/apache/asterix/installer/command/UninstallCommand.java
@@ -12,20 +12,20 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-package edu.uci.ics.asterix.installer.command;
+package org.apache.asterix.installer.command;
 
 import org.kohsuke.args4j.Option;
 
-import edu.uci.ics.asterix.event.management.AsterixEventServiceClient;
-import edu.uci.ics.asterix.event.model.AsterixInstance;
-import edu.uci.ics.asterix.event.model.AsterixInstance.State;
-import edu.uci.ics.asterix.event.schema.pattern.Patterns;
-import edu.uci.ics.asterix.event.service.AsterixEventService;
-import edu.uci.ics.asterix.event.service.AsterixEventServiceUtil;
-import edu.uci.ics.asterix.event.service.ILookupService;
-import edu.uci.ics.asterix.event.service.ServiceProvider;
-import edu.uci.ics.asterix.event.util.PatternCreator;
-import edu.uci.ics.asterix.installer.driver.InstallerDriver;
+import org.apache.asterix.event.management.AsterixEventServiceClient;
+import org.apache.asterix.event.model.AsterixInstance;
+import org.apache.asterix.event.model.AsterixInstance.State;
+import org.apache.asterix.event.schema.pattern.Patterns;
+import org.apache.asterix.event.service.AsterixEventService;
+import org.apache.asterix.event.service.AsterixEventServiceUtil;
+import org.apache.asterix.event.service.ILookupService;
+import org.apache.asterix.event.service.ServiceProvider;
+import org.apache.asterix.event.util.PatternCreator;
+import org.apache.asterix.installer.driver.InstallerDriver;
 
 public class UninstallCommand extends AbstractCommand {
 
diff --git a/asterix-installer/src/main/java/org/apache/asterix/installer/command/ValidateCommand.java b/asterix-installer/src/main/java/org/apache/asterix/installer/command/ValidateCommand.java
index 282b4d7..4881389 100644
--- a/asterix-installer/src/main/java/org/apache/asterix/installer/command/ValidateCommand.java
+++ b/asterix-installer/src/main/java/org/apache/asterix/installer/command/ValidateCommand.java
@@ -12,7 +12,7 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-package edu.uci.ics.asterix.installer.command;
+package org.apache.asterix.installer.command;
 
 import java.io.File;
 import java.util.ArrayList;
@@ -25,14 +25,14 @@
 
 import org.kohsuke.args4j.Option;
 
-import edu.uci.ics.asterix.event.management.EventUtil;
-import edu.uci.ics.asterix.event.schema.cluster.Cluster;
-import edu.uci.ics.asterix.event.schema.cluster.MasterNode;
-import edu.uci.ics.asterix.event.schema.cluster.Node;
-import edu.uci.ics.asterix.event.service.AsterixEventServiceUtil;
-import edu.uci.ics.asterix.installer.driver.InstallerDriver;
-import edu.uci.ics.asterix.installer.schema.conf.Configuration;
-import edu.uci.ics.asterix.installer.schema.conf.Zookeeper;
+import org.apache.asterix.event.management.EventUtil;
+import org.apache.asterix.event.schema.cluster.Cluster;
+import org.apache.asterix.event.schema.cluster.MasterNode;
+import org.apache.asterix.event.schema.cluster.Node;
+import org.apache.asterix.event.service.AsterixEventServiceUtil;
+import org.apache.asterix.installer.driver.InstallerDriver;
+import org.apache.asterix.installer.schema.conf.Configuration;
+import org.apache.asterix.installer.schema.conf.Zookeeper;
 
 public class ValidateCommand extends AbstractCommand {
 
diff --git a/asterix-installer/src/main/java/org/apache/asterix/installer/command/VersionCommand.java b/asterix-installer/src/main/java/org/apache/asterix/installer/command/VersionCommand.java
index 58c148c..8144b97 100644
--- a/asterix-installer/src/main/java/org/apache/asterix/installer/command/VersionCommand.java
+++ b/asterix-installer/src/main/java/org/apache/asterix/installer/command/VersionCommand.java
@@ -12,12 +12,12 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-package edu.uci.ics.asterix.installer.command;
+package org.apache.asterix.installer.command;
 
 import java.io.File;
 
-import edu.uci.ics.asterix.event.service.AsterixEventService;
-import edu.uci.ics.asterix.installer.driver.InstallerDriver;
+import org.apache.asterix.event.service.AsterixEventService;
+import org.apache.asterix.installer.driver.InstallerDriver;
 
 public class VersionCommand extends AbstractCommand {
 
diff --git a/asterix-installer/src/main/java/org/apache/asterix/installer/driver/InstallerDriver.java b/asterix-installer/src/main/java/org/apache/asterix/installer/driver/InstallerDriver.java
index 6cf31dc..58bed65 100644
--- a/asterix-installer/src/main/java/org/apache/asterix/installer/driver/InstallerDriver.java
+++ b/asterix-installer/src/main/java/org/apache/asterix/installer/driver/InstallerDriver.java
@@ -12,7 +12,7 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-package edu.uci.ics.asterix.installer.driver;
+package org.apache.asterix.installer.driver;
 
 import java.io.File;
 
@@ -21,12 +21,12 @@
 
 import org.apache.log4j.Logger;
 
-import edu.uci.ics.asterix.event.service.AsterixEventService;
-import edu.uci.ics.asterix.event.service.ILookupService;
-import edu.uci.ics.asterix.event.service.ServiceProvider;
-import edu.uci.ics.asterix.installer.command.CommandHandler;
-import edu.uci.ics.asterix.installer.command.ConfigureCommand;
-import edu.uci.ics.asterix.installer.schema.conf.Configuration;
+import org.apache.asterix.event.service.AsterixEventService;
+import org.apache.asterix.event.service.ILookupService;
+import org.apache.asterix.event.service.ServiceProvider;
+import org.apache.asterix.installer.command.CommandHandler;
+import org.apache.asterix.installer.command.ConfigureCommand;
+import org.apache.asterix.installer.schema.conf.Configuration;
 
 public class InstallerDriver {
 
diff --git a/asterix-installer/src/main/java/org/apache/asterix/installer/driver/InstallerUtil.java b/asterix-installer/src/main/java/org/apache/asterix/installer/driver/InstallerUtil.java
index 5266b92..de99a1e 100644
--- a/asterix-installer/src/main/java/org/apache/asterix/installer/driver/InstallerUtil.java
+++ b/asterix-installer/src/main/java/org/apache/asterix/installer/driver/InstallerUtil.java
@@ -12,7 +12,7 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-package edu.uci.ics.asterix.installer.driver;
+package org.apache.asterix.installer.driver;
 
 import java.io.File;
 import java.io.FileNotFoundException;
@@ -22,9 +22,9 @@
 import javax.xml.bind.JAXBException;
 import javax.xml.bind.Unmarshaller;
 
-import edu.uci.ics.asterix.common.configuration.AsterixConfiguration;
-import edu.uci.ics.asterix.event.schema.cluster.Cluster;
-import edu.uci.ics.asterix.event.schema.cluster.Node;
+import org.apache.asterix.common.configuration.AsterixConfiguration;
+import org.apache.asterix.event.schema.cluster.Cluster;
+import org.apache.asterix.event.schema.cluster.Node;
 
 public class InstallerUtil {
 
diff --git a/asterix-installer/src/main/java/org/apache/asterix/installer/error/InstallerException.java b/asterix-installer/src/main/java/org/apache/asterix/installer/error/InstallerException.java
index 14c75a8..034807a 100644
--- a/asterix-installer/src/main/java/org/apache/asterix/installer/error/InstallerException.java
+++ b/asterix-installer/src/main/java/org/apache/asterix/installer/error/InstallerException.java
@@ -12,7 +12,7 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-package edu.uci.ics.asterix.installer.error;
+package org.apache.asterix.installer.error;
 
 public class InstallerException extends Exception {
 
diff --git a/asterix-installer/src/main/java/org/apache/asterix/installer/error/OutputHandler.java b/asterix-installer/src/main/java/org/apache/asterix/installer/error/OutputHandler.java
index 5792df2..16be608 100644
--- a/asterix-installer/src/main/java/org/apache/asterix/installer/error/OutputHandler.java
+++ b/asterix-installer/src/main/java/org/apache/asterix/installer/error/OutputHandler.java
@@ -12,16 +12,16 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-package edu.uci.ics.asterix.installer.error;
+package org.apache.asterix.installer.error;
 
 import java.io.ByteArrayInputStream;
 import java.io.IOException;
 import java.util.Properties;
 
-import edu.uci.ics.asterix.event.management.IOutputHandler;
-import edu.uci.ics.asterix.event.management.OutputAnalysis;
-import edu.uci.ics.asterix.event.model.EventList.EventType;
-import edu.uci.ics.asterix.event.schema.pattern.Event;
+import org.apache.asterix.event.management.IOutputHandler;
+import org.apache.asterix.event.management.OutputAnalysis;
+import org.apache.asterix.event.model.EventList.EventType;
+import org.apache.asterix.event.schema.pattern.Event;
 
 public class OutputHandler implements IOutputHandler {
 
diff --git a/asterix-installer/src/main/resources/conf/log4j.properties b/asterix-installer/src/main/resources/conf/log4j.properties
index a233f5a..ec72fd4 100644
--- a/asterix-installer/src/main/resources/conf/log4j.properties
+++ b/asterix-installer/src/main/resources/conf/log4j.properties
@@ -19,5 +19,5 @@
 # Print the date in ISO 8601 format
 log4j.appender.A1.layout.ConversionPattern=%-p: %m%n
 
-log4j.logger.edu.uci.ics.asterix.event.management=error
+log4j.logger.org.apache.asterix.event.management=error
 log4j.logger.org.apache.zookeeper=error
diff --git a/asterix-installer/src/main/resources/scripts/managix b/asterix-installer/src/main/resources/scripts/managix
index 66a0cd3..2a6d467 100755
--- a/asterix-installer/src/main/resources/scripts/managix
+++ b/asterix-installer/src/main/resources/scripts/managix
@@ -32,4 +32,4 @@
 done
 
 MANAGIX_CLASSPATH=$MANAGIX_CLASSPATH:$MANAGIX_HOME/conf/log4j.properties
-java $JAVA_OPTS -Dlog4j.configuration=file:$MANAGIX_HOME/conf/log4j.properties -cp $MANAGIX_CLASSPATH edu.uci.ics.asterix.installer.driver.InstallerDriver $@
+java $JAVA_OPTS -Dlog4j.configuration=file:$MANAGIX_HOME/conf/log4j.properties -cp $MANAGIX_CLASSPATH org.apache.asterix.installer.driver.InstallerDriver $@
diff --git a/asterix-installer/src/test/java/org/apache/asterix/installer/test/AsterixClusterLifeCycleIT.java b/asterix-installer/src/test/java/org/apache/asterix/installer/test/AsterixClusterLifeCycleIT.java
index 8481ef7..7bf7eca 100644
--- a/asterix-installer/src/test/java/org/apache/asterix/installer/test/AsterixClusterLifeCycleIT.java
+++ b/asterix-installer/src/test/java/org/apache/asterix/installer/test/AsterixClusterLifeCycleIT.java
@@ -12,7 +12,7 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-package edu.uci.ics.asterix.installer.test;
+package org.apache.asterix.installer.test;
 
 import java.io.File;
 import java.io.IOException;
@@ -33,8 +33,8 @@
 import org.apache.commons.io.IOUtils;
 import org.apache.commons.lang3.StringUtils;
 
-import edu.uci.ics.asterix.test.aql.TestsUtils;
-import edu.uci.ics.asterix.testframework.context.TestCaseContext;
+import org.apache.asterix.test.aql.TestsUtils;
+import org.apache.asterix.testframework.context.TestCaseContext;
 
 public class AsterixClusterLifeCycleIT {
 
diff --git a/asterix-installer/src/test/java/org/apache/asterix/installer/test/AsterixExternalLibraryIT.java b/asterix-installer/src/test/java/org/apache/asterix/installer/test/AsterixExternalLibraryIT.java
index bb41b05..6bf46b6 100644
--- a/asterix-installer/src/test/java/org/apache/asterix/installer/test/AsterixExternalLibraryIT.java
+++ b/asterix-installer/src/test/java/org/apache/asterix/installer/test/AsterixExternalLibraryIT.java
@@ -12,7 +12,7 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-package edu.uci.ics.asterix.installer.test;
+package org.apache.asterix.installer.test;
 
 import java.io.File;
 import java.util.List;
@@ -22,9 +22,9 @@
 import org.junit.BeforeClass;
 import org.junit.Test;
 
-import edu.uci.ics.asterix.event.model.AsterixInstance.State;
-import edu.uci.ics.asterix.test.aql.TestsUtils;
-import edu.uci.ics.asterix.testframework.context.TestCaseContext;
+import org.apache.asterix.event.model.AsterixInstance.State;
+import org.apache.asterix.test.aql.TestsUtils;
+import org.apache.asterix.testframework.context.TestCaseContext;
 
 public class AsterixExternalLibraryIT {
 
diff --git a/asterix-installer/src/test/java/org/apache/asterix/installer/test/AsterixInstallerIntegrationUtil.java b/asterix-installer/src/test/java/org/apache/asterix/installer/test/AsterixInstallerIntegrationUtil.java
index c9a39f3..ad64319 100644
--- a/asterix-installer/src/test/java/org/apache/asterix/installer/test/AsterixInstallerIntegrationUtil.java
+++ b/asterix-installer/src/test/java/org/apache/asterix/installer/test/AsterixInstallerIntegrationUtil.java
@@ -12,7 +12,7 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-package edu.uci.ics.asterix.installer.test;
+package org.apache.asterix.installer.test;
 
 import java.io.File;
 import java.io.FileNotFoundException;
@@ -28,16 +28,16 @@
 import javax.xml.bind.Marshaller;
 import javax.xml.bind.Unmarshaller;
 
-import edu.uci.ics.asterix.event.error.VerificationUtil;
-import edu.uci.ics.asterix.event.model.AsterixInstance;
-import edu.uci.ics.asterix.event.model.AsterixInstance.State;
-import edu.uci.ics.asterix.event.model.AsterixRuntimeState;
-import edu.uci.ics.asterix.event.service.ServiceProvider;
-import edu.uci.ics.asterix.installer.command.CommandHandler;
-import edu.uci.ics.asterix.installer.driver.InstallerDriver;
-import edu.uci.ics.asterix.installer.schema.conf.Configuration;
-import edu.uci.ics.hyracks.api.client.HyracksConnection;
-import edu.uci.ics.hyracks.api.client.IHyracksClientConnection;
+import org.apache.asterix.event.error.VerificationUtil;
+import org.apache.asterix.event.model.AsterixInstance;
+import org.apache.asterix.event.model.AsterixInstance.State;
+import org.apache.asterix.event.model.AsterixRuntimeState;
+import org.apache.asterix.event.service.ServiceProvider;
+import org.apache.asterix.installer.command.CommandHandler;
+import org.apache.asterix.installer.driver.InstallerDriver;
+import org.apache.asterix.installer.schema.conf.Configuration;
+import org.apache.hyracks.api.client.HyracksConnection;
+import org.apache.hyracks.api.client.IHyracksClientConnection;
 
 public class AsterixInstallerIntegrationUtil {
 
diff --git a/asterix-installer/src/test/java/org/apache/asterix/installer/test/AsterixLifecycleIT.java b/asterix-installer/src/test/java/org/apache/asterix/installer/test/AsterixLifecycleIT.java
index fde30a9..b0bbdbe 100644
--- a/asterix-installer/src/test/java/org/apache/asterix/installer/test/AsterixLifecycleIT.java
+++ b/asterix-installer/src/test/java/org/apache/asterix/installer/test/AsterixLifecycleIT.java
@@ -12,7 +12,7 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-package edu.uci.ics.asterix.installer.test;
+package org.apache.asterix.installer.test;
 
 import java.io.File;
 import java.util.ArrayList;
@@ -27,14 +27,14 @@
 import org.junit.FixMethodOrder;
 import org.junit.runners.MethodSorters;
 
-import edu.uci.ics.asterix.event.error.VerificationUtil;
-import edu.uci.ics.asterix.event.model.AsterixInstance;
-import edu.uci.ics.asterix.event.model.AsterixInstance.State;
-import edu.uci.ics.asterix.event.model.AsterixRuntimeState;
-import edu.uci.ics.asterix.event.service.ServiceProvider;
-import edu.uci.ics.asterix.installer.command.CommandHandler;
-import edu.uci.ics.asterix.test.aql.TestsUtils;
-import edu.uci.ics.asterix.testframework.context.TestCaseContext;
+import org.apache.asterix.event.error.VerificationUtil;
+import org.apache.asterix.event.model.AsterixInstance;
+import org.apache.asterix.event.model.AsterixInstance.State;
+import org.apache.asterix.event.model.AsterixRuntimeState;
+import org.apache.asterix.event.service.ServiceProvider;
+import org.apache.asterix.installer.command.CommandHandler;
+import org.apache.asterix.test.aql.TestsUtils;
+import org.apache.asterix.testframework.context.TestCaseContext;
 
 @FixMethodOrder(MethodSorters.NAME_ASCENDING)
 
diff --git a/asterix-installer/src/test/java/org/apache/asterix/installer/transaction/DmlRecoveryIT.java b/asterix-installer/src/test/java/org/apache/asterix/installer/transaction/DmlRecoveryIT.java
index c464e68..2355250 100644
--- a/asterix-installer/src/test/java/org/apache/asterix/installer/transaction/DmlRecoveryIT.java
+++ b/asterix-installer/src/test/java/org/apache/asterix/installer/transaction/DmlRecoveryIT.java
@@ -12,7 +12,7 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-package edu.uci.ics.asterix.installer.transaction;
+package org.apache.asterix.installer.transaction;
 
 import java.io.File;
 import java.io.FilenameFilter;
@@ -33,10 +33,10 @@
 import org.junit.runners.Parameterized;
 import org.junit.runners.Parameterized.Parameters;
 
-import edu.uci.ics.asterix.test.aql.TestsUtils;
-import edu.uci.ics.asterix.testframework.context.TestCaseContext;
-import edu.uci.ics.asterix.testframework.context.TestFileContext;
-import edu.uci.ics.asterix.testframework.xml.TestCase.CompilationUnit;
+import org.apache.asterix.test.aql.TestsUtils;
+import org.apache.asterix.testframework.context.TestCaseContext;
+import org.apache.asterix.testframework.context.TestFileContext;
+import org.apache.asterix.testframework.xml.TestCase.CompilationUnit;
 
 @RunWith(Parameterized.class)
 public class DmlRecoveryIT {
diff --git a/asterix-installer/src/test/java/org/apache/asterix/installer/transaction/RecoveryIT.java b/asterix-installer/src/test/java/org/apache/asterix/installer/transaction/RecoveryIT.java
index 018cb18..b171c46 100644
--- a/asterix-installer/src/test/java/org/apache/asterix/installer/transaction/RecoveryIT.java
+++ b/asterix-installer/src/test/java/org/apache/asterix/installer/transaction/RecoveryIT.java
@@ -12,7 +12,7 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-package edu.uci.ics.asterix.installer.transaction;
+package org.apache.asterix.installer.transaction;
 
 import java.io.File;
 import java.io.FilenameFilter;
@@ -29,8 +29,8 @@
 import org.junit.runners.Parameterized;
 import org.junit.runners.Parameterized.Parameters;
 
-import edu.uci.ics.asterix.test.aql.TestsUtils;
-import edu.uci.ics.asterix.testframework.context.TestCaseContext;
+import org.apache.asterix.test.aql.TestsUtils;
+import org.apache.asterix.testframework.context.TestCaseContext;
 
 @RunWith(Parameterized.class)
 public class RecoveryIT {
diff --git a/asterix-installer/src/test/resources/integrationts/library/results/library-metadata/dataverseDataset/dataverseDataset.1.adm b/asterix-installer/src/test/resources/integrationts/library/results/library-metadata/dataverseDataset/dataverseDataset.1.adm
index 9c987ef..5574ee0 100644
--- a/asterix-installer/src/test/resources/integrationts/library/results/library-metadata/dataverseDataset/dataverseDataset.1.adm
+++ b/asterix-installer/src/test/resources/integrationts/library/results/library-metadata/dataverseDataset/dataverseDataset.1.adm
@@ -1,3 +1,3 @@
-[ { "DataverseName": "Metadata", "DataFormat": "edu.uci.ics.asterix.runtime.formats.NonTaggedDataFormat", "Timestamp": "Thu Apr 25 11:17:56 PDT 2013", "PendingOp": 0 }
-, { "DataverseName": "externallibtest", "DataFormat": "edu.uci.ics.asterix.runtime.formats.NonTaggedDataFormat", "Timestamp": "Thu Apr 25 11:18:12 PDT 2013", "PendingOp": 0 }
+[ { "DataverseName": "Metadata", "DataFormat": "org.apache.asterix.runtime.formats.NonTaggedDataFormat", "Timestamp": "Thu Apr 25 11:17:56 PDT 2013", "PendingOp": 0 }
+, { "DataverseName": "externallibtest", "DataFormat": "org.apache.asterix.runtime.formats.NonTaggedDataFormat", "Timestamp": "Thu Apr 25 11:18:12 PDT 2013", "PendingOp": 0 }
  ]
diff --git a/asterix-installer/src/test/resources/integrationts/library/results/library-metadata/functionDataset/functionDataset.1.adm b/asterix-installer/src/test/resources/integrationts/library/results/library-metadata/functionDataset/functionDataset.1.adm
index a9bcf09..686ade6 100644
--- a/asterix-installer/src/test/resources/integrationts/library/results/library-metadata/functionDataset/functionDataset.1.adm
+++ b/asterix-installer/src/test/resources/integrationts/library/results/library-metadata/functionDataset/functionDataset.1.adm
@@ -1,9 +1,9 @@
-[ { "DataverseName": "externallibtest", "Name": "testlib#addHashTags", "Arity": "1", "Params": [ "Tweet" ], "ReturnType": "ProcessedTweet", "Definition": "edu.uci.ics.asterix.external.library.AddHashTagsFactory", "Language": "JAVA", "Kind": "SCALAR" }
-, { "DataverseName": "externallibtest", "Name": "testlib#addHashTagsInPlace", "Arity": "1", "Params": [ "Tweet" ], "ReturnType": "ProcessedTweet", "Definition": "edu.uci.ics.asterix.external.library.AddHashTagsInPlaceFactory", "Language": "JAVA", "Kind": "SCALAR" }
-, { "DataverseName": "externallibtest", "Name": "testlib#allTypes", "Arity": "1", "Params": [ "AllType" ], "ReturnType": "AllType", "Definition": "edu.uci.ics.asterix.external.library.AllTypesFactory", "Language": "JAVA", "Kind": "SCALAR" }
-, { "DataverseName": "externallibtest", "Name": "testlib#echoDelay", "Arity": "1", "Params": [ "TweetMessageType" ], "ReturnType": "TweetMessageType", "Definition": "edu.uci.ics.asterix.external.library.EchoDelayFactory", "Language": "JAVA", "Kind": "SCALAR" }
-, { "DataverseName": "externallibtest", "Name": "testlib#getCapital", "Arity": "1", "Params": [ "ASTRING" ], "ReturnType": "CountryCapitalType", "Definition": "edu.uci.ics.asterix.external.library.CapitalFinderFactory", "Language": "JAVA", "Kind": "SCALAR" }
-, { "DataverseName": "externallibtest", "Name": "testlib#mysum", "Arity": "2", "Params": [ "AINT32", "AINT32" ], "ReturnType": "AINT32", "Definition": "edu.uci.ics.asterix.external.library.SumFactory", "Language": "JAVA", "Kind": "SCALAR" }
-, { "DataverseName": "externallibtest", "Name": "testlib#parseTweet", "Arity": "1", "Params": [ "TweetInputType" ], "ReturnType": "TweetOutputType", "Definition": "edu.uci.ics.asterix.external.library.ParseTweetFactory", "Language": "JAVA", "Kind": "SCALAR" }
-, { "DataverseName": "externallibtest", "Name": "testlib#toUpper", "Arity": "1", "Params": [ "TextType" ], "ReturnType": "TextType", "Definition": "edu.uci.ics.asterix.external.library.UpperCaseFactory", "Language": "JAVA", "Kind": "SCALAR" }
+[ { "DataverseName": "externallibtest", "Name": "testlib#addHashTags", "Arity": "1", "Params": [ "Tweet" ], "ReturnType": "ProcessedTweet", "Definition": "org.apache.asterix.external.library.AddHashTagsFactory", "Language": "JAVA", "Kind": "SCALAR" }
+, { "DataverseName": "externallibtest", "Name": "testlib#addHashTagsInPlace", "Arity": "1", "Params": [ "Tweet" ], "ReturnType": "ProcessedTweet", "Definition": "org.apache.asterix.external.library.AddHashTagsInPlaceFactory", "Language": "JAVA", "Kind": "SCALAR" }
+, { "DataverseName": "externallibtest", "Name": "testlib#allTypes", "Arity": "1", "Params": [ "AllType" ], "ReturnType": "AllType", "Definition": "org.apache.asterix.external.library.AllTypesFactory", "Language": "JAVA", "Kind": "SCALAR" }
+, { "DataverseName": "externallibtest", "Name": "testlib#echoDelay", "Arity": "1", "Params": [ "TweetMessageType" ], "ReturnType": "TweetMessageType", "Definition": "org.apache.asterix.external.library.EchoDelayFactory", "Language": "JAVA", "Kind": "SCALAR" }
+, { "DataverseName": "externallibtest", "Name": "testlib#getCapital", "Arity": "1", "Params": [ "ASTRING" ], "ReturnType": "CountryCapitalType", "Definition": "org.apache.asterix.external.library.CapitalFinderFactory", "Language": "JAVA", "Kind": "SCALAR" }
+, { "DataverseName": "externallibtest", "Name": "testlib#mysum", "Arity": "2", "Params": [ "AINT32", "AINT32" ], "ReturnType": "AINT32", "Definition": "org.apache.asterix.external.library.SumFactory", "Language": "JAVA", "Kind": "SCALAR" }
+, { "DataverseName": "externallibtest", "Name": "testlib#parseTweet", "Arity": "1", "Params": [ "TweetInputType" ], "ReturnType": "TweetOutputType", "Definition": "org.apache.asterix.external.library.ParseTweetFactory", "Language": "JAVA", "Kind": "SCALAR" }
+, { "DataverseName": "externallibtest", "Name": "testlib#toUpper", "Arity": "1", "Params": [ "TextType" ], "ReturnType": "TextType", "Definition": "org.apache.asterix.external.library.UpperCaseFactory", "Language": "JAVA", "Kind": "SCALAR" }
  ]
diff --git a/asterix-installer/src/test/resources/integrationts/library/testsuite.xml b/asterix-installer/src/test/resources/integrationts/library/testsuite.xml
index be9ba0e..80d5f9c 100644
--- a/asterix-installer/src/test/resources/integrationts/library/testsuite.xml
+++ b/asterix-installer/src/test/resources/integrationts/library/testsuite.xml
@@ -1,4 +1,4 @@
-<test-suite xmlns="urn:xml.testframework.asterix.ics.uci.edu" ResultOffsetPath="results" QueryOffsetPath="queries" QueryFileExtension=".aql">
+<test-suite xmlns="urn:xml.testframework.asterix.apache.org" ResultOffsetPath="results" QueryOffsetPath="queries" QueryFileExtension=".aql">
   <test-group name="library-functions">
     <test-case FilePath="library-functions">
       <compilation-unit name="mysum">
diff --git a/asterix-installer/src/test/resources/integrationts/lifecycle/results/asterix-lifecycle/backupRestore/backupRestore.1.adm b/asterix-installer/src/test/resources/integrationts/lifecycle/results/asterix-lifecycle/backupRestore/backupRestore.1.adm
index 9d3ea21..fc20754 100644
--- a/asterix-installer/src/test/resources/integrationts/lifecycle/results/asterix-lifecycle/backupRestore/backupRestore.1.adm
+++ b/asterix-installer/src/test/resources/integrationts/lifecycle/results/asterix-lifecycle/backupRestore/backupRestore.1.adm
@@ -1,2 +1,2 @@
-[ { "DataverseName": "backupDataverse", "DataFormat": "edu.uci.ics.asterix.runtime.formats.NonTaggedDataFormat", "Timestamp": "Wed Apr 24 16:13:46 PDT 2013", "PendingOp": 0 }
+[ { "DataverseName": "backupDataverse", "DataFormat": "org.apache.asterix.runtime.formats.NonTaggedDataFormat", "Timestamp": "Wed Apr 24 16:13:46 PDT 2013", "PendingOp": 0 }
  ]
diff --git a/asterix-installer/src/test/resources/integrationts/lifecycle/testsuite.xml b/asterix-installer/src/test/resources/integrationts/lifecycle/testsuite.xml
index 969da43..1278908 100644
--- a/asterix-installer/src/test/resources/integrationts/lifecycle/testsuite.xml
+++ b/asterix-installer/src/test/resources/integrationts/lifecycle/testsuite.xml
@@ -12,7 +12,7 @@
  ! See the License for the specific language governing permissions and
  ! limitations under the License.
  !-->
-<test-suite xmlns="urn:xml.testframework.asterix.ics.uci.edu" ResultOffsetPath="results" QueryOffsetPath="queries" QueryFileExtension=".aql">
+<test-suite xmlns="urn:xml.testframework.asterix.apache.org" ResultOffsetPath="results" QueryOffsetPath="queries" QueryFileExtension=".aql">
   <test-group name="lifecycle">
     <test-case FilePath="asterix-lifecycle">
       <compilation-unit name="backupRestore">
diff --git a/asterix-installer/src/test/resources/transactionts/queries/recover_after_abort/primary_index_only/primary_index_only.3.update.aql b/asterix-installer/src/test/resources/transactionts/queries/recover_after_abort/primary_index_only/primary_index_only.3.update.aql
index 6d0e431..1c2c7a3 100644
--- a/asterix-installer/src/test/resources/transactionts/queries/recover_after_abort/primary_index_only/primary_index_only.3.update.aql
+++ b/asterix-installer/src/test/resources/transactionts/queries/recover_after_abort/primary_index_only/primary_index_only.3.update.aql
@@ -7,5 +7,5 @@
 
 use dataverse recovery;
 
-load dataset Fragile_raw using "edu.uci.ics.asterix.external.dataset.adapter.NCFileSystemAdapter"
+load dataset Fragile_raw using "org.apache.asterix.external.dataset.adapter.NCFileSystemAdapter"
 (("path"="127.0.0.1://../../../../../../asterix-app/data/csv/fragile_01.csv"),("format"="delimited-text"),("delimiter"=",")) pre-sorted;
diff --git a/asterix-installer/src/test/resources/transactionts/queries/recover_after_abort/primary_plus_default_secondary_index/primary_plus_default_secondary_index.3.update.aql b/asterix-installer/src/test/resources/transactionts/queries/recover_after_abort/primary_plus_default_secondary_index/primary_plus_default_secondary_index.3.update.aql
index 5d7d6f2..b44491b 100644
--- a/asterix-installer/src/test/resources/transactionts/queries/recover_after_abort/primary_plus_default_secondary_index/primary_plus_default_secondary_index.3.update.aql
+++ b/asterix-installer/src/test/resources/transactionts/queries/recover_after_abort/primary_plus_default_secondary_index/primary_plus_default_secondary_index.3.update.aql
@@ -7,5 +7,5 @@
 
 use dataverse recovery;
 
-load dataset Fragile_raw using "edu.uci.ics.asterix.external.dataset.adapter.NCFileSystemAdapter"
+load dataset Fragile_raw using "org.apache.asterix.external.dataset.adapter.NCFileSystemAdapter"
 (("path"="127.0.0.1://../../../../../../asterix-app/data/csv/fragile_02.adm"),("format"="adm")) pre-sorted;
diff --git a/asterix-installer/src/test/resources/transactionts/queries/recover_after_abort/primary_plus_keyword_secondary_index/primary_plus_keyword_secondary_index.3.update.aql b/asterix-installer/src/test/resources/transactionts/queries/recover_after_abort/primary_plus_keyword_secondary_index/primary_plus_keyword_secondary_index.3.update.aql
index 9d9757f..2147676 100644
--- a/asterix-installer/src/test/resources/transactionts/queries/recover_after_abort/primary_plus_keyword_secondary_index/primary_plus_keyword_secondary_index.3.update.aql
+++ b/asterix-installer/src/test/resources/transactionts/queries/recover_after_abort/primary_plus_keyword_secondary_index/primary_plus_keyword_secondary_index.3.update.aql
@@ -8,5 +8,5 @@
 use dataverse recovery;
 
 
-load dataset Fragile_raw using "edu.uci.ics.asterix.external.dataset.adapter.NCFileSystemAdapter"
+load dataset Fragile_raw using "org.apache.asterix.external.dataset.adapter.NCFileSystemAdapter"
 (("path"="127.0.0.1://../../../../../../asterix-app/data/csv/fragile_02.adm"),("format"="adm")) pre-sorted;
diff --git a/asterix-installer/src/test/resources/transactionts/queries/recover_after_abort/primary_plus_multiple_secondary_indices/primary_plus_multiple_secondary_indices.3.update.aql b/asterix-installer/src/test/resources/transactionts/queries/recover_after_abort/primary_plus_multiple_secondary_indices/primary_plus_multiple_secondary_indices.3.update.aql
index 9d9757f..2147676 100644
--- a/asterix-installer/src/test/resources/transactionts/queries/recover_after_abort/primary_plus_multiple_secondary_indices/primary_plus_multiple_secondary_indices.3.update.aql
+++ b/asterix-installer/src/test/resources/transactionts/queries/recover_after_abort/primary_plus_multiple_secondary_indices/primary_plus_multiple_secondary_indices.3.update.aql
@@ -8,5 +8,5 @@
 use dataverse recovery;
 
 
-load dataset Fragile_raw using "edu.uci.ics.asterix.external.dataset.adapter.NCFileSystemAdapter"
+load dataset Fragile_raw using "org.apache.asterix.external.dataset.adapter.NCFileSystemAdapter"
 (("path"="127.0.0.1://../../../../../../asterix-app/data/csv/fragile_02.adm"),("format"="adm")) pre-sorted;
diff --git a/asterix-installer/src/test/resources/transactionts/queries/recover_after_abort/primary_plus_ngram_index/primary_plus_ngram_index.3.update.aql b/asterix-installer/src/test/resources/transactionts/queries/recover_after_abort/primary_plus_ngram_index/primary_plus_ngram_index.3.update.aql
index 5d7d6f2..b44491b 100644
--- a/asterix-installer/src/test/resources/transactionts/queries/recover_after_abort/primary_plus_ngram_index/primary_plus_ngram_index.3.update.aql
+++ b/asterix-installer/src/test/resources/transactionts/queries/recover_after_abort/primary_plus_ngram_index/primary_plus_ngram_index.3.update.aql
@@ -7,5 +7,5 @@
 
 use dataverse recovery;
 
-load dataset Fragile_raw using "edu.uci.ics.asterix.external.dataset.adapter.NCFileSystemAdapter"
+load dataset Fragile_raw using "org.apache.asterix.external.dataset.adapter.NCFileSystemAdapter"
 (("path"="127.0.0.1://../../../../../../asterix-app/data/csv/fragile_02.adm"),("format"="adm")) pre-sorted;
diff --git a/asterix-installer/src/test/resources/transactionts/queries/recover_after_abort/primary_plus_rtree_index/primary_plus_rtree_index.3.update.aql b/asterix-installer/src/test/resources/transactionts/queries/recover_after_abort/primary_plus_rtree_index/primary_plus_rtree_index.3.update.aql
index 9d9757f..2147676 100644
--- a/asterix-installer/src/test/resources/transactionts/queries/recover_after_abort/primary_plus_rtree_index/primary_plus_rtree_index.3.update.aql
+++ b/asterix-installer/src/test/resources/transactionts/queries/recover_after_abort/primary_plus_rtree_index/primary_plus_rtree_index.3.update.aql
@@ -8,5 +8,5 @@
 use dataverse recovery;
 
 
-load dataset Fragile_raw using "edu.uci.ics.asterix.external.dataset.adapter.NCFileSystemAdapter"
+load dataset Fragile_raw using "org.apache.asterix.external.dataset.adapter.NCFileSystemAdapter"
 (("path"="127.0.0.1://../../../../../../asterix-app/data/csv/fragile_02.adm"),("format"="adm")) pre-sorted;
diff --git a/asterix-installer/src/test/resources/transactionts/queries/recover_after_abort/temp_primary_index_only/primary_index_only.3.update.aql b/asterix-installer/src/test/resources/transactionts/queries/recover_after_abort/temp_primary_index_only/primary_index_only.3.update.aql
index 6d0e431..1c2c7a3 100644
--- a/asterix-installer/src/test/resources/transactionts/queries/recover_after_abort/temp_primary_index_only/primary_index_only.3.update.aql
+++ b/asterix-installer/src/test/resources/transactionts/queries/recover_after_abort/temp_primary_index_only/primary_index_only.3.update.aql
@@ -7,5 +7,5 @@
 
 use dataverse recovery;
 
-load dataset Fragile_raw using "edu.uci.ics.asterix.external.dataset.adapter.NCFileSystemAdapter"
+load dataset Fragile_raw using "org.apache.asterix.external.dataset.adapter.NCFileSystemAdapter"
 (("path"="127.0.0.1://../../../../../../asterix-app/data/csv/fragile_01.csv"),("format"="delimited-text"),("delimiter"=",")) pre-sorted;
diff --git a/asterix-installer/src/test/resources/transactionts/queries/recover_after_abort/temp_primary_plus_default_secondary_index/primary_plus_default_secondary_index.3.update.aql b/asterix-installer/src/test/resources/transactionts/queries/recover_after_abort/temp_primary_plus_default_secondary_index/primary_plus_default_secondary_index.3.update.aql
index 5d7d6f2..b44491b 100644
--- a/asterix-installer/src/test/resources/transactionts/queries/recover_after_abort/temp_primary_plus_default_secondary_index/primary_plus_default_secondary_index.3.update.aql
+++ b/asterix-installer/src/test/resources/transactionts/queries/recover_after_abort/temp_primary_plus_default_secondary_index/primary_plus_default_secondary_index.3.update.aql
@@ -7,5 +7,5 @@
 
 use dataverse recovery;
 
-load dataset Fragile_raw using "edu.uci.ics.asterix.external.dataset.adapter.NCFileSystemAdapter"
+load dataset Fragile_raw using "org.apache.asterix.external.dataset.adapter.NCFileSystemAdapter"
 (("path"="127.0.0.1://../../../../../../asterix-app/data/csv/fragile_02.adm"),("format"="adm")) pre-sorted;
diff --git a/asterix-installer/src/test/resources/transactionts/queries/recover_after_abort/temp_primary_plus_keyword_secondary_index/primary_plus_keyword_secondary_index.3.update.aql b/asterix-installer/src/test/resources/transactionts/queries/recover_after_abort/temp_primary_plus_keyword_secondary_index/primary_plus_keyword_secondary_index.3.update.aql
index 9d9757f..2147676 100644
--- a/asterix-installer/src/test/resources/transactionts/queries/recover_after_abort/temp_primary_plus_keyword_secondary_index/primary_plus_keyword_secondary_index.3.update.aql
+++ b/asterix-installer/src/test/resources/transactionts/queries/recover_after_abort/temp_primary_plus_keyword_secondary_index/primary_plus_keyword_secondary_index.3.update.aql
@@ -8,5 +8,5 @@
 use dataverse recovery;
 
 
-load dataset Fragile_raw using "edu.uci.ics.asterix.external.dataset.adapter.NCFileSystemAdapter"
+load dataset Fragile_raw using "org.apache.asterix.external.dataset.adapter.NCFileSystemAdapter"
 (("path"="127.0.0.1://../../../../../../asterix-app/data/csv/fragile_02.adm"),("format"="adm")) pre-sorted;
diff --git a/asterix-installer/src/test/resources/transactionts/queries/recover_after_abort/temp_primary_plus_multiple_secondary_indices/primary_plus_multiple_secondary_indices.3.update.aql b/asterix-installer/src/test/resources/transactionts/queries/recover_after_abort/temp_primary_plus_multiple_secondary_indices/primary_plus_multiple_secondary_indices.3.update.aql
index 9d9757f..2147676 100644
--- a/asterix-installer/src/test/resources/transactionts/queries/recover_after_abort/temp_primary_plus_multiple_secondary_indices/primary_plus_multiple_secondary_indices.3.update.aql
+++ b/asterix-installer/src/test/resources/transactionts/queries/recover_after_abort/temp_primary_plus_multiple_secondary_indices/primary_plus_multiple_secondary_indices.3.update.aql
@@ -8,5 +8,5 @@
 use dataverse recovery;
 
 
-load dataset Fragile_raw using "edu.uci.ics.asterix.external.dataset.adapter.NCFileSystemAdapter"
+load dataset Fragile_raw using "org.apache.asterix.external.dataset.adapter.NCFileSystemAdapter"
 (("path"="127.0.0.1://../../../../../../asterix-app/data/csv/fragile_02.adm"),("format"="adm")) pre-sorted;
diff --git a/asterix-installer/src/test/resources/transactionts/queries/recover_after_abort/temp_primary_plus_ngram_index/primary_plus_ngram_index.3.update.aql b/asterix-installer/src/test/resources/transactionts/queries/recover_after_abort/temp_primary_plus_ngram_index/primary_plus_ngram_index.3.update.aql
index 5d7d6f2..b44491b 100644
--- a/asterix-installer/src/test/resources/transactionts/queries/recover_after_abort/temp_primary_plus_ngram_index/primary_plus_ngram_index.3.update.aql
+++ b/asterix-installer/src/test/resources/transactionts/queries/recover_after_abort/temp_primary_plus_ngram_index/primary_plus_ngram_index.3.update.aql
@@ -7,5 +7,5 @@
 
 use dataverse recovery;
 
-load dataset Fragile_raw using "edu.uci.ics.asterix.external.dataset.adapter.NCFileSystemAdapter"
+load dataset Fragile_raw using "org.apache.asterix.external.dataset.adapter.NCFileSystemAdapter"
 (("path"="127.0.0.1://../../../../../../asterix-app/data/csv/fragile_02.adm"),("format"="adm")) pre-sorted;
diff --git a/asterix-installer/src/test/resources/transactionts/queries/recover_after_abort/temp_primary_plus_rtree_index/primary_plus_rtree_index.3.update.aql b/asterix-installer/src/test/resources/transactionts/queries/recover_after_abort/temp_primary_plus_rtree_index/primary_plus_rtree_index.3.update.aql
index 9d9757f..2147676 100644
--- a/asterix-installer/src/test/resources/transactionts/queries/recover_after_abort/temp_primary_plus_rtree_index/primary_plus_rtree_index.3.update.aql
+++ b/asterix-installer/src/test/resources/transactionts/queries/recover_after_abort/temp_primary_plus_rtree_index/primary_plus_rtree_index.3.update.aql
@@ -8,5 +8,5 @@
 use dataverse recovery;
 
 
-load dataset Fragile_raw using "edu.uci.ics.asterix.external.dataset.adapter.NCFileSystemAdapter"
+load dataset Fragile_raw using "org.apache.asterix.external.dataset.adapter.NCFileSystemAdapter"
 (("path"="127.0.0.1://../../../../../../asterix-app/data/csv/fragile_02.adm"),("format"="adm")) pre-sorted;
diff --git a/asterix-installer/src/test/resources/transactionts/queries/recovery_ddl/delete_after_recovery/delete_after_recovery.3.update.aql b/asterix-installer/src/test/resources/transactionts/queries/recovery_ddl/delete_after_recovery/delete_after_recovery.3.update.aql
index 6d0e431..1c2c7a3 100644
--- a/asterix-installer/src/test/resources/transactionts/queries/recovery_ddl/delete_after_recovery/delete_after_recovery.3.update.aql
+++ b/asterix-installer/src/test/resources/transactionts/queries/recovery_ddl/delete_after_recovery/delete_after_recovery.3.update.aql
@@ -7,5 +7,5 @@
 
 use dataverse recovery;
 
-load dataset Fragile_raw using "edu.uci.ics.asterix.external.dataset.adapter.NCFileSystemAdapter"
+load dataset Fragile_raw using "org.apache.asterix.external.dataset.adapter.NCFileSystemAdapter"
 (("path"="127.0.0.1://../../../../../../asterix-app/data/csv/fragile_01.csv"),("format"="delimited-text"),("delimiter"=",")) pre-sorted;
diff --git a/asterix-installer/src/test/resources/transactionts/queries/recovery_ddl/insert_after_recovery/insert_after_recovery.3.update.aql b/asterix-installer/src/test/resources/transactionts/queries/recovery_ddl/insert_after_recovery/insert_after_recovery.3.update.aql
index 6d0e431..1c2c7a3 100644
--- a/asterix-installer/src/test/resources/transactionts/queries/recovery_ddl/insert_after_recovery/insert_after_recovery.3.update.aql
+++ b/asterix-installer/src/test/resources/transactionts/queries/recovery_ddl/insert_after_recovery/insert_after_recovery.3.update.aql
@@ -7,5 +7,5 @@
 
 use dataverse recovery;
 
-load dataset Fragile_raw using "edu.uci.ics.asterix.external.dataset.adapter.NCFileSystemAdapter"
+load dataset Fragile_raw using "org.apache.asterix.external.dataset.adapter.NCFileSystemAdapter"
 (("path"="127.0.0.1://../../../../../../asterix-app/data/csv/fragile_01.csv"),("format"="delimited-text"),("delimiter"=",")) pre-sorted;
diff --git a/asterix-installer/src/test/resources/transactionts/queries/recovery_ddl/load_after_recovery/load_after_recovery.5.update.aql b/asterix-installer/src/test/resources/transactionts/queries/recovery_ddl/load_after_recovery/load_after_recovery.5.update.aql
index 6d0e431..1c2c7a3 100644
--- a/asterix-installer/src/test/resources/transactionts/queries/recovery_ddl/load_after_recovery/load_after_recovery.5.update.aql
+++ b/asterix-installer/src/test/resources/transactionts/queries/recovery_ddl/load_after_recovery/load_after_recovery.5.update.aql
@@ -7,5 +7,5 @@
 
 use dataverse recovery;
 
-load dataset Fragile_raw using "edu.uci.ics.asterix.external.dataset.adapter.NCFileSystemAdapter"
+load dataset Fragile_raw using "org.apache.asterix.external.dataset.adapter.NCFileSystemAdapter"
 (("path"="127.0.0.1://../../../../../../asterix-app/data/csv/fragile_01.csv"),("format"="delimited-text"),("delimiter"=",")) pre-sorted;
diff --git a/asterix-installer/src/test/resources/transactionts/queries/recovery_ddl/temp_delete_after_recovery/delete_after_recovery.3.update.aql b/asterix-installer/src/test/resources/transactionts/queries/recovery_ddl/temp_delete_after_recovery/delete_after_recovery.3.update.aql
index 6d0e431..1c2c7a3 100644
--- a/asterix-installer/src/test/resources/transactionts/queries/recovery_ddl/temp_delete_after_recovery/delete_after_recovery.3.update.aql
+++ b/asterix-installer/src/test/resources/transactionts/queries/recovery_ddl/temp_delete_after_recovery/delete_after_recovery.3.update.aql
@@ -7,5 +7,5 @@
 
 use dataverse recovery;
 
-load dataset Fragile_raw using "edu.uci.ics.asterix.external.dataset.adapter.NCFileSystemAdapter"
+load dataset Fragile_raw using "org.apache.asterix.external.dataset.adapter.NCFileSystemAdapter"
 (("path"="127.0.0.1://../../../../../../asterix-app/data/csv/fragile_01.csv"),("format"="delimited-text"),("delimiter"=",")) pre-sorted;
diff --git a/asterix-installer/src/test/resources/transactionts/queries/recovery_ddl/temp_insert_after_recovery/insert_after_recovery.3.update.aql b/asterix-installer/src/test/resources/transactionts/queries/recovery_ddl/temp_insert_after_recovery/insert_after_recovery.3.update.aql
index 6d0e431..1c2c7a3 100644
--- a/asterix-installer/src/test/resources/transactionts/queries/recovery_ddl/temp_insert_after_recovery/insert_after_recovery.3.update.aql
+++ b/asterix-installer/src/test/resources/transactionts/queries/recovery_ddl/temp_insert_after_recovery/insert_after_recovery.3.update.aql
@@ -7,5 +7,5 @@
 
 use dataverse recovery;
 
-load dataset Fragile_raw using "edu.uci.ics.asterix.external.dataset.adapter.NCFileSystemAdapter"
+load dataset Fragile_raw using "org.apache.asterix.external.dataset.adapter.NCFileSystemAdapter"
 (("path"="127.0.0.1://../../../../../../asterix-app/data/csv/fragile_01.csv"),("format"="delimited-text"),("delimiter"=",")) pre-sorted;
diff --git a/asterix-installer/src/test/resources/transactionts/queries/recovery_ddl/temp_load_after_recovery/load_after_recovery.5.update.aql b/asterix-installer/src/test/resources/transactionts/queries/recovery_ddl/temp_load_after_recovery/load_after_recovery.5.update.aql
index 6d0e431..1c2c7a3 100644
--- a/asterix-installer/src/test/resources/transactionts/queries/recovery_ddl/temp_load_after_recovery/load_after_recovery.5.update.aql
+++ b/asterix-installer/src/test/resources/transactionts/queries/recovery_ddl/temp_load_after_recovery/load_after_recovery.5.update.aql
@@ -7,5 +7,5 @@
 
 use dataverse recovery;
 
-load dataset Fragile_raw using "edu.uci.ics.asterix.external.dataset.adapter.NCFileSystemAdapter"
+load dataset Fragile_raw using "org.apache.asterix.external.dataset.adapter.NCFileSystemAdapter"
 (("path"="127.0.0.1://../../../../../../asterix-app/data/csv/fragile_01.csv"),("format"="delimited-text"),("delimiter"=",")) pre-sorted;
diff --git a/asterix-installer/src/test/resources/transactionts/testsuite.xml b/asterix-installer/src/test/resources/transactionts/testsuite.xml
index a757f5e..d64c818 100644
--- a/asterix-installer/src/test/resources/transactionts/testsuite.xml
+++ b/asterix-installer/src/test/resources/transactionts/testsuite.xml
@@ -12,7 +12,7 @@
  ! See the License for the specific language governing permissions and
  ! limitations under the License.
  !-->
-<test-suite xmlns="urn:xml.testframework.asterix.ics.uci.edu" ResultOffsetPath="results" QueryOffsetPath="queries" QueryFileExtension=".aql">
+<test-suite xmlns="urn:xml.testframework.asterix.apache.org" ResultOffsetPath="results" QueryOffsetPath="queries" QueryFileExtension=".aql">
 
   <test-group name="recover_after_abort">
 
@@ -55,42 +55,42 @@
     <test-case FilePath="recover_after_abort">
       <compilation-unit name="temp_primary_index_only">
         <output-dir compare="Text">primary_index_only</output-dir>
-        <expected-error>edu.uci.ics.hyracks.algebricks.common.exceptions.AlgebricksException</expected-error>
+        <expected-error>org.apache.hyracks.algebricks.common.exceptions.AlgebricksException</expected-error>
       </compilation-unit>
     </test-case>
 
     <test-case FilePath="recover_after_abort">
       <compilation-unit name="temp_primary_plus_default_secondary_index">
         <output-dir compare="Text">primary_plus_default_secondary_index</output-dir>
-        <expected-error>edu.uci.ics.hyracks.algebricks.common.exceptions.AlgebricksException</expected-error>
+        <expected-error>org.apache.hyracks.algebricks.common.exceptions.AlgebricksException</expected-error>
       </compilation-unit>
     </test-case>
 
     <test-case FilePath="recover_after_abort">
       <compilation-unit name="temp_primary_plus_rtree_index">
         <output-dir compare="Text">primary_plus_rtree_index</output-dir>
-        <expected-error>edu.uci.ics.hyracks.algebricks.common.exceptions.AlgebricksException</expected-error>
+        <expected-error>org.apache.hyracks.algebricks.common.exceptions.AlgebricksException</expected-error>
       </compilation-unit>
     </test-case>
 
     <test-case FilePath="recover_after_abort">
       <compilation-unit name="temp_primary_plus_keyword_secondary_index">
         <output-dir compare="Text">primary_plus_keyword_secondary_index</output-dir>
-        <expected-error>edu.uci.ics.hyracks.api.exceptions.HyracksDataException</expected-error>
+        <expected-error>org.apache.hyracks.api.exceptions.HyracksDataException</expected-error>
       </compilation-unit>
     </test-case>
       
     <test-case FilePath="recover_after_abort">
       <compilation-unit name="temp_primary_plus_ngram_index">
         <output-dir compare="Text">primary_plus_ngram_index</output-dir>
-        <expected-error>edu.uci.ics.hyracks.algebricks.common.exceptions.AlgebricksException</expected-error>
+        <expected-error>org.apache.hyracks.algebricks.common.exceptions.AlgebricksException</expected-error>
       </compilation-unit>
     </test-case>
 
     <test-case FilePath="recover_after_abort">
       <compilation-unit name="primary_plus_multiple_secondary_indices">
         <output-dir compare="Text">primary_plus_multiple_secondary_indices</output-dir>
-        <expected-error>edu.uci.ics.hyracks.algebricks.common.exceptions.AlgebricksException</expected-error>
+        <expected-error>org.apache.hyracks.algebricks.common.exceptions.AlgebricksException</expected-error>
       </compilation-unit>
     </test-case>
  </test-group>
@@ -148,35 +148,35 @@
     <test-case FilePath="recovery_ddl">
       <compilation-unit name="temp_dataset_recovery">
         <output-dir compare="Text">dataset_recovery</output-dir>
-        <expected-error>edu.uci.ics.hyracks.algebricks.common.exceptions.AlgebricksException</expected-error>
+        <expected-error>org.apache.hyracks.algebricks.common.exceptions.AlgebricksException</expected-error>
       </compilation-unit>
     </test-case>
 
     <test-case FilePath="recovery_ddl">
       <compilation-unit name="temp_delete_after_recovery">
         <output-dir compare="Text">delete_after_recovery</output-dir>
-        <expected-error>edu.uci.ics.hyracks.algebricks.common.exceptions.AlgebricksException</expected-error>
+        <expected-error>org.apache.hyracks.algebricks.common.exceptions.AlgebricksException</expected-error>
       </compilation-unit>
     </test-case>
 
     <test-case FilePath="recovery_ddl">
       <compilation-unit name="temp_insert_after_recovery">
         <output-dir compare="Text">insert_after_recovery</output-dir>
-        <expected-error>edu.uci.ics.hyracks.algebricks.common.exceptions.AlgebricksException</expected-error>
+        <expected-error>org.apache.hyracks.algebricks.common.exceptions.AlgebricksException</expected-error>
       </compilation-unit>
     </test-case>
 
     <test-case FilePath="recovery_ddl">
       <compilation-unit name="temp_load_after_recovery">
         <output-dir compare="Text">load_after_recovery</output-dir>
-        <expected-error>edu.uci.ics.hyracks.algebricks.common.exceptions.AlgebricksException</expected-error>
+        <expected-error>org.apache.hyracks.algebricks.common.exceptions.AlgebricksException</expected-error>
       </compilation-unit>
     </test-case>
 
     <test-case FilePath="recovery_ddl">
       <compilation-unit name="temp_secondary_index_recovery">
         <output-dir compare="Text">secondary_index_recovery</output-dir>
-        <expected-error>edu.uci.ics.hyracks.algebricks.common.exceptions.AlgebricksException</expected-error>
+        <expected-error>org.apache.hyracks.algebricks.common.exceptions.AlgebricksException</expected-error>
       </compilation-unit>
     </test-case>
  
