activemq-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From clebertsuco...@apache.org
Subject [08/52] [abbrv] [partial] activemq-6 git commit: ACTIVEMQ6-4 Rename HornetQ* classes to ActiveMQ*
Date Tue, 18 Nov 2014 23:38:01 GMT
http://git-wip-us.apache.org/repos/asf/activemq-6/blob/034adfbf/activemq-server/src/main/java/org/apache/activemq/core/protocol/core/ServerSessionPacketHandler.java
----------------------------------------------------------------------
diff --git a/activemq-server/src/main/java/org/apache/activemq/core/protocol/core/ServerSessionPacketHandler.java b/activemq-server/src/main/java/org/apache/activemq/core/protocol/core/ServerSessionPacketHandler.java
index 0290427..764fbb8 100644
--- a/activemq-server/src/main/java/org/apache/activemq/core/protocol/core/ServerSessionPacketHandler.java
+++ b/activemq-server/src/main/java/org/apache/activemq/core/protocol/core/ServerSessionPacketHandler.java
@@ -54,13 +54,13 @@ import javax.transaction.xa.Xid;
 import org.apache.activemq.api.core.ActiveMQException;
 import org.apache.activemq.api.core.ActiveMQExceptionType;
 import org.apache.activemq.api.core.ActiveMQInternalErrorException;
-import org.apache.activemq.core.exception.HornetQXAException;
+import org.apache.activemq.core.exception.ActiveMQXAException;
 import org.apache.activemq.core.journal.IOAsyncTask;
 import org.apache.activemq.core.persistence.StorageManager;
 import org.apache.activemq.core.protocol.core.impl.PacketImpl;
 import org.apache.activemq.core.protocol.core.impl.wireformat.CreateQueueMessage;
 import org.apache.activemq.core.protocol.core.impl.wireformat.CreateSharedQueueMessage;
-import org.apache.activemq.core.protocol.core.impl.wireformat.HornetQExceptionMessage;
+import org.apache.activemq.core.protocol.core.impl.wireformat.ActiveMQExceptionMessage;
 import org.apache.activemq.core.protocol.core.impl.wireformat.NullResponseMessage;
 import org.apache.activemq.core.protocol.core.impl.wireformat.RollbackMessage;
 import org.apache.activemq.core.protocol.core.impl.wireformat.SessionAcknowledgeMessage;
@@ -99,9 +99,9 @@ import org.apache.activemq.core.protocol.core.impl.wireformat.SessionXAStartMess
 import org.apache.activemq.core.remoting.CloseListener;
 import org.apache.activemq.core.remoting.FailureListener;
 import org.apache.activemq.core.remoting.impl.netty.NettyConnection;
+import org.apache.activemq.core.server.ActiveMQServerLogger;
 import org.apache.activemq.core.server.BindingQueryResult;
-import org.apache.activemq.core.server.HornetQServerLogger;
-import org.apache.activemq.core.server.HornetQMessageBundle;
+import org.apache.activemq.core.server.ActiveMQMessageBundle;
 import org.apache.activemq.core.server.QueueQueryResult;
 import org.apache.activemq.core.server.ServerMessage;
 import org.apache.activemq.core.server.ServerSession;
@@ -164,7 +164,7 @@ public class ServerSessionPacketHandler implements ChannelHandler
 
    public void connectionFailed(final ActiveMQException exception, boolean failedOver)
    {
-      HornetQServerLogger.LOGGER.clientConnectionFailed(session.getName());
+      ActiveMQServerLogger.LOGGER.clientConnectionFailed(session.getName());
 
       try
       {
@@ -172,10 +172,10 @@ public class ServerSessionPacketHandler implements ChannelHandler
       }
       catch (Exception e)
       {
-         HornetQServerLogger.LOGGER.errorClosingSession(e);
+         ActiveMQServerLogger.LOGGER.errorClosingSession(e);
       }
 
-      HornetQServerLogger.LOGGER.clearingUpSession(session.getName());
+      ActiveMQServerLogger.LOGGER.clearingUpSession(session.getName());
    }
 
    public void close()
@@ -188,7 +188,7 @@ public class ServerSessionPacketHandler implements ChannelHandler
       }
       catch (Exception e)
       {
-         HornetQServerLogger.LOGGER.errorClosingSession(e);
+         ActiveMQServerLogger.LOGGER.errorClosingSession(e);
       }
    }
 
@@ -529,40 +529,40 @@ public class ServerSessionPacketHandler implements ChannelHandler
                   }
                   else
                   {
-                     response = new HornetQExceptionMessage(HornetQMessageBundle.BUNDLE.duplicateMetadata(message.getKey(), message.getData()));
+                     response = new ActiveMQExceptionMessage(ActiveMQMessageBundle.BUNDLE.duplicateMetadata(message.getKey(), message.getData()));
                   }
                   break;
                }
             }
          }
-         catch (HornetQXAException e)
+         catch (ActiveMQXAException e)
          {
             if (requiresResponse)
             {
-               HornetQServerLogger.LOGGER.debug("Sending exception to client", e);
+               ActiveMQServerLogger.LOGGER.debug("Sending exception to client", e);
                response = new SessionXAResponseMessage(true, e.errorCode, e.getMessage());
             }
             else
             {
-               HornetQServerLogger.LOGGER.caughtXaException(e);
+               ActiveMQServerLogger.LOGGER.caughtXaException(e);
             }
          }
          catch (ActiveMQException e)
          {
             if (requiresResponse)
             {
-               HornetQServerLogger.LOGGER.debug("Sending exception to client", e);
-               response = new HornetQExceptionMessage(e);
+               ActiveMQServerLogger.LOGGER.debug("Sending exception to client", e);
+               response = new ActiveMQExceptionMessage(e);
             }
             else
             {
                if (e.getType() == ActiveMQExceptionType.QUEUE_EXISTS)
                {
-                  HornetQServerLogger.LOGGER.debug("Caught exception", e);
+                  ActiveMQServerLogger.LOGGER.debug("Caught exception", e);
                }
                else
                {
-                  HornetQServerLogger.LOGGER.caughtException(e);
+                  ActiveMQServerLogger.LOGGER.caughtException(e);
                }
             }
          }
@@ -570,14 +570,14 @@ public class ServerSessionPacketHandler implements ChannelHandler
          {
             if (requiresResponse)
             {
-               HornetQServerLogger.LOGGER.warn("Sending unexpected exception to the client", t);
-               ActiveMQException hqe = new ActiveMQInternalErrorException();
-               hqe.initCause(t);
-               response = new HornetQExceptionMessage(hqe);
+               ActiveMQServerLogger.LOGGER.warn("Sending unexpected exception to the client", t);
+               ActiveMQException activeMQInternalErrorException = new ActiveMQInternalErrorException();
+               activeMQInternalErrorException.initCause(t);
+               response = new ActiveMQExceptionMessage(activeMQInternalErrorException);
             }
             else
             {
-               HornetQServerLogger.LOGGER.caughtException(t);
+               ActiveMQServerLogger.LOGGER.caughtException(t);
             }
          }
 
@@ -598,9 +598,9 @@ public class ServerSessionPacketHandler implements ChannelHandler
       {
          public void onError(final int errorCode, final String errorMessage)
          {
-            HornetQServerLogger.LOGGER.errorProcessingIOCallback(errorCode, errorMessage);
+            ActiveMQServerLogger.LOGGER.errorProcessingIOCallback(errorCode, errorMessage);
 
-            HornetQExceptionMessage exceptionMessage = new HornetQExceptionMessage( ActiveMQExceptionType.createException(errorCode, errorMessage));
+            ActiveMQExceptionMessage exceptionMessage = new ActiveMQExceptionMessage( ActiveMQExceptionType.createException(errorCode, errorMessage));
 
             doConfirmAndResponse(confirmPacket, exceptionMessage, flush, closeChannel);
          }

http://git-wip-us.apache.org/repos/asf/activemq-6/blob/034adfbf/activemq-server/src/main/java/org/apache/activemq/core/protocol/core/impl/ActiveMQPacketHandler.java
----------------------------------------------------------------------
diff --git a/activemq-server/src/main/java/org/apache/activemq/core/protocol/core/impl/ActiveMQPacketHandler.java b/activemq-server/src/main/java/org/apache/activemq/core/protocol/core/impl/ActiveMQPacketHandler.java
new file mode 100644
index 0000000..1b7b9af
--- /dev/null
+++ b/activemq-server/src/main/java/org/apache/activemq/core/protocol/core/impl/ActiveMQPacketHandler.java
@@ -0,0 +1,298 @@
+/*
+ * Copyright 2005-2014 Red Hat, Inc.
+ * Red Hat licenses this file to you under the Apache License, version
+ * 2.0 (the "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+ * implied.  See the License for the specific language governing
+ * permissions and limitations under the License.
+ */
+package org.apache.activemq.core.protocol.core.impl;
+
+import org.apache.activemq.api.core.ActiveMQException;
+import org.apache.activemq.api.core.ActiveMQExceptionType;
+import org.apache.activemq.api.core.ActiveMQInternalErrorException;
+import org.apache.activemq.api.core.SimpleString;
+import org.apache.activemq.core.protocol.core.Channel;
+import org.apache.activemq.core.protocol.core.ChannelHandler;
+import org.apache.activemq.core.protocol.core.CoreRemotingConnection;
+import org.apache.activemq.core.protocol.core.Packet;
+import org.apache.activemq.core.protocol.core.ServerSessionPacketHandler;
+import org.apache.activemq.core.protocol.core.impl.wireformat.CheckFailoverMessage;
+import org.apache.activemq.core.protocol.core.impl.wireformat.CheckFailoverReplyMessage;
+import org.apache.activemq.core.protocol.core.impl.wireformat.CreateQueueMessage;
+import org.apache.activemq.core.protocol.core.impl.wireformat.CreateSessionMessage;
+import org.apache.activemq.core.protocol.core.impl.wireformat.CreateSessionResponseMessage;
+import org.apache.activemq.core.protocol.core.impl.wireformat.ActiveMQExceptionMessage;
+import org.apache.activemq.core.protocol.core.impl.wireformat.ReattachSessionMessage;
+import org.apache.activemq.core.protocol.core.impl.wireformat.ReattachSessionResponseMessage;
+import org.apache.activemq.core.security.ActiveMQPrincipal;
+import org.apache.activemq.core.server.ActiveMQMessageBundle;
+import org.apache.activemq.core.server.ActiveMQServer;
+import org.apache.activemq.core.server.ActiveMQServerLogger;
+import org.apache.activemq.core.server.ServerSession;
+import org.apache.activemq.core.version.Version;
+
+/**
+ * A packet handler for all packets that need to be handled at the server level
+ *
+ * @author <a href="mailto:jmesnil@redhat.com">Jeff Mesnil</a>
+ * @author <a href="mailto:tim.fox@jboss.com">Tim Fox</a>
+ * @author <a href="ataylor@redhat.com">Andy Taylor</a>
+ */
+public class ActiveMQPacketHandler implements ChannelHandler
+{
+   private final ActiveMQServer server;
+
+   private final Channel channel1;
+
+   private final CoreRemotingConnection connection;
+
+   private final CoreProtocolManager protocolManager;
+
+   public ActiveMQPacketHandler(final CoreProtocolManager protocolManager,
+                                final ActiveMQServer server,
+                                final Channel channel1,
+                                final CoreRemotingConnection connection)
+   {
+      this.protocolManager = protocolManager;
+
+      this.server = server;
+
+      this.channel1 = channel1;
+
+      this.connection = connection;
+   }
+
+   public void handlePacket(final Packet packet)
+   {
+      byte type = packet.getType();
+
+      switch (type)
+      {
+         case PacketImpl.CREATESESSION:
+         {
+            CreateSessionMessage request = (CreateSessionMessage) packet;
+
+            handleCreateSession(request);
+
+            break;
+         }
+         case PacketImpl.CHECK_FOR_FAILOVER:
+         {
+            CheckFailoverMessage request = (CheckFailoverMessage) packet;
+
+            handleCheckForFailover(request);
+
+            break;
+         }
+         case PacketImpl.REATTACH_SESSION:
+         {
+            ReattachSessionMessage request = (ReattachSessionMessage) packet;
+
+            handleReattachSession(request);
+
+            break;
+         }
+         case PacketImpl.CREATE_QUEUE:
+         {
+            // Create queue can also be fielded here in the case of a replicated store and forward queue creation
+
+            CreateQueueMessage request = (CreateQueueMessage) packet;
+
+            handleCreateQueue(request);
+
+            break;
+         }
+         default:
+         {
+            ActiveMQServerLogger.LOGGER.invalidPacket(packet);
+         }
+      }
+   }
+
+   private void handleCheckForFailover(CheckFailoverMessage failoverMessage)
+   {
+      String nodeID = failoverMessage.getNodeID();
+      boolean okToFailover = nodeID == null ||
+            !(server.getHAPolicy().canScaleDown() && !server.hasScaledDown(new SimpleString(nodeID)));
+      channel1.send(new CheckFailoverReplyMessage(okToFailover));
+   }
+
+   private void handleCreateSession(final CreateSessionMessage request)
+   {
+      boolean incompatibleVersion = false;
+      Packet response;
+      try
+      {
+         Version version = server.getVersion();
+         if (!version.isCompatible(request.getVersion()))
+         {
+            throw ActiveMQMessageBundle.BUNDLE.incompatibleClientServer();
+         }
+
+         if (!server.isStarted())
+         {
+            throw ActiveMQMessageBundle.BUNDLE.serverNotStarted();
+         }
+
+         // XXX HORNETQ-720 Taylor commented out this test. Should be verified.
+         /*if (!server.checkActivate())
+         {
+            throw new ActiveMQException(ActiveMQException.SESSION_CREATION_REJECTED,
+                                       "Server will not accept create session requests");
+         }*/
+
+
+         if (connection.getClientVersion() == 0)
+         {
+            connection.setClientVersion(request.getVersion());
+         }
+         else if (connection.getClientVersion() != request.getVersion())
+         {
+            ActiveMQServerLogger.LOGGER.incompatibleVersionAfterConnect(request.getVersion(), connection.getClientVersion());
+         }
+
+         Channel channel = connection.getChannel(request.getSessionChannelID(), request.getWindowSize());
+
+         ActiveMQPrincipal activeMQPrincipal = null;
+
+         if (request.getUsername() == null)
+         {
+            activeMQPrincipal = connection.getDefaultActiveMQPrincipal();
+         }
+
+         ServerSession session = server.createSession(request.getName(),
+                                                      activeMQPrincipal == null ? request.getUsername() : activeMQPrincipal.getUserName(),
+                                                      activeMQPrincipal == null ? request.getPassword() : activeMQPrincipal.getPassword(),
+                                                      request.getMinLargeMessageSize(),
+                                                      connection,
+                                                      request.isAutoCommitSends(),
+                                                      request.isAutoCommitAcks(),
+                                                      request.isPreAcknowledge(),
+                                                      request.isXA(),
+                                                      request.getDefaultAddress(),
+                                                      new CoreSessionCallback(request.getName(),
+                                                                              protocolManager,
+                                                                              channel), null);
+
+         ServerSessionPacketHandler handler = new ServerSessionPacketHandler(session,
+                                                                             server.getStorageManager(),
+                                                                             channel);
+         channel.setHandler(handler);
+
+         // TODO - where is this removed?
+         protocolManager.addSessionHandler(request.getName(), handler);
+
+         response = new CreateSessionResponseMessage(server.getVersion().getIncrementingVersion());
+      }
+      catch (ActiveMQException e)
+      {
+         if (e.getType() == ActiveMQExceptionType.INCOMPATIBLE_CLIENT_SERVER_VERSIONS)
+         {
+            incompatibleVersion = true;
+            ActiveMQServerLogger.LOGGER.debug("Sending ActiveMQException after Incompatible client", e);
+         }
+         else
+         {
+            ActiveMQServerLogger.LOGGER.failedToCreateSession(e);
+         }
+
+         response = new ActiveMQExceptionMessage(e);
+      }
+      catch (Exception e)
+      {
+         ActiveMQServerLogger.LOGGER.failedToCreateSession(e);
+
+         response = new ActiveMQExceptionMessage(new ActiveMQInternalErrorException());
+      }
+
+      // send the exception to the client and destroy
+      // the connection if the client and server versions
+      // are not compatible
+      if (incompatibleVersion)
+      {
+         channel1.sendAndFlush(response);
+      }
+      else
+      {
+         channel1.send(response);
+      }
+   }
+
+   private void handleReattachSession(final ReattachSessionMessage request)
+   {
+      Packet response = null;
+
+      try
+      {
+
+         if (!server.isStarted())
+         {
+            response = new ReattachSessionResponseMessage(-1, false);
+         }
+
+         ActiveMQServerLogger.LOGGER.debug("Reattaching request from " + connection.getRemoteAddress());
+
+
+         ServerSessionPacketHandler sessionHandler = protocolManager.getSessionHandler(request.getName());
+
+         // HORNETQ-720 XXX ataylor?
+         if (/*!server.checkActivate() || */ sessionHandler == null)
+         {
+            response = new ReattachSessionResponseMessage(-1, false);
+         }
+         else
+         {
+            if (sessionHandler.getChannel().getConfirmationWindowSize() == -1)
+            {
+               // Even though session exists, we can't reattach since confi window size == -1,
+               // i.e. we don't have a resend cache for commands, so we just close the old session
+               // and let the client recreate
+
+               ActiveMQServerLogger.LOGGER.reattachRequestFailed(connection.getRemoteAddress());
+
+               sessionHandler.closeListeners();
+               sessionHandler.close();
+
+               response = new ReattachSessionResponseMessage(-1, false);
+            }
+            else
+            {
+               // Reconnect the channel to the new connection
+               int serverLastConfirmedCommandID = sessionHandler.transferConnection(connection,
+                                                                                    request.getLastConfirmedCommandID());
+
+               response = new ReattachSessionResponseMessage(serverLastConfirmedCommandID, true);
+            }
+         }
+      }
+      catch (Exception e)
+      {
+         ActiveMQServerLogger.LOGGER.failedToReattachSession(e);
+
+         response = new ActiveMQExceptionMessage(new ActiveMQInternalErrorException());
+      }
+
+      channel1.send(response);
+   }
+
+   private void handleCreateQueue(final CreateQueueMessage request)
+   {
+      try
+      {
+         server.createQueue(request.getAddress(),
+                            request.getQueueName(),
+                            request.getFilterString(),
+                            request.isDurable(),
+                            request.isTemporary());
+      }
+      catch (Exception e)
+      {
+         ActiveMQServerLogger.LOGGER.failedToHandleCreateQueue(e);
+      }
+   }
+}
\ No newline at end of file

http://git-wip-us.apache.org/repos/asf/activemq-6/blob/034adfbf/activemq-server/src/main/java/org/apache/activemq/core/protocol/core/impl/CoreProtocolManager.java
----------------------------------------------------------------------
diff --git a/activemq-server/src/main/java/org/apache/activemq/core/protocol/core/impl/CoreProtocolManager.java b/activemq-server/src/main/java/org/apache/activemq/core/protocol/core/impl/CoreProtocolManager.java
index 956b67d..add0cbe 100644
--- a/activemq-server/src/main/java/org/apache/activemq/core/protocol/core/impl/CoreProtocolManager.java
+++ b/activemq-server/src/main/java/org/apache/activemq/core/protocol/core/impl/CoreProtocolManager.java
@@ -25,7 +25,7 @@ import org.apache.activemq.api.core.Interceptor;
 import org.apache.activemq.api.core.Pair;
 import org.apache.activemq.api.core.TransportConfiguration;
 import org.apache.activemq.api.core.client.ClusterTopologyListener;
-import org.apache.activemq.api.core.client.HornetQClient;
+import org.apache.activemq.api.core.client.ActiveMQClient;
 import org.apache.activemq.api.core.client.TopologyMember;
 import org.apache.activemq.core.config.Configuration;
 import org.apache.activemq.core.protocol.ServerPacketDecoder;
@@ -42,10 +42,10 @@ import org.apache.activemq.core.protocol.core.impl.wireformat.Ping;
 import org.apache.activemq.core.protocol.core.impl.wireformat.SubscribeClusterTopologyUpdatesMessage;
 import org.apache.activemq.core.protocol.core.impl.wireformat.SubscribeClusterTopologyUpdatesMessageV2;
 import org.apache.activemq.core.remoting.CloseListener;
-import org.apache.activemq.core.remoting.impl.netty.HornetQFrameDecoder2;
+import org.apache.activemq.core.remoting.impl.netty.ActiveMQFrameDecoder2;
 import org.apache.activemq.core.remoting.impl.netty.NettyServerConnection;
-import org.apache.activemq.core.server.HornetQServer;
-import org.apache.activemq.core.server.HornetQServerLogger;
+import org.apache.activemq.core.server.ActiveMQServer;
+import org.apache.activemq.core.server.ActiveMQServerLogger;
 import org.apache.activemq.spi.core.protocol.ConnectionEntry;
 import org.apache.activemq.spi.core.protocol.MessageConverter;
 import org.apache.activemq.spi.core.protocol.ProtocolManager;
@@ -60,15 +60,15 @@ import org.apache.activemq.spi.core.remoting.Connection;
  */
 class CoreProtocolManager implements ProtocolManager
 {
-   private static final boolean isTrace = HornetQServerLogger.LOGGER.isTraceEnabled();
+   private static final boolean isTrace = ActiveMQServerLogger.LOGGER.isTraceEnabled();
 
-   private final HornetQServer server;
+   private final ActiveMQServer server;
 
    private final List<Interceptor> incomingInterceptors;
 
    private final List<Interceptor> outgoingInterceptors;
 
-   CoreProtocolManager(final HornetQServer server, final List<Interceptor> incomingInterceptors, List<Interceptor> outgoingInterceptors)
+   CoreProtocolManager(final ActiveMQServer server, final List<Interceptor> incomingInterceptors, List<Interceptor> outgoingInterceptors)
    {
       this.server = server;
 
@@ -102,11 +102,11 @@ class CoreProtocolManager implements ProtocolManager
 
       Channel channel1 = rc.getChannel(CHANNEL_ID.SESSION.id, -1);
 
-      ChannelHandler handler = new HornetQPacketHandler(this, server, channel1, rc);
+      ChannelHandler handler = new ActiveMQPacketHandler(this, server, channel1, rc);
 
       channel1.setHandler(handler);
 
-      long ttl = HornetQClient.DEFAULT_CONNECTION_TTL;
+      long ttl = ActiveMQClient.DEFAULT_CONNECTION_TTL;
 
       if (config.getConnectionTTLOverride() != -1)
       {
@@ -148,30 +148,31 @@ class CoreProtocolManager implements ProtocolManager
    @Override
    public void addChannelHandlers(ChannelPipeline pipeline)
    {
-      pipeline.addLast("hornetq-decoder", new HornetQFrameDecoder2());
+      pipeline.addLast("activemq-decoder", new ActiveMQFrameDecoder2());
    }
 
    @Override
    public boolean isProtocol(byte[] array)
    {
       String frameStart = new String(array, StandardCharsets.US_ASCII);
-      return frameStart.startsWith("HORNETQ");
+      return frameStart.startsWith("ACTIVEMQ");
    }
 
    @Override
    public void handshake(NettyServerConnection connection, ActiveMQBuffer buffer)
    {
       //if we are not an old client then handshake
-      if (buffer.getByte(0) == 'H' &&
-         buffer.getByte(1) == 'O' &&
-         buffer.getByte(2) == 'R' &&
-         buffer.getByte(3) == 'N' &&
-         buffer.getByte(4) == 'E' &&
-         buffer.getByte(5) == 'T' &&
-         buffer.getByte(6) == 'Q')
+      if (buffer.getByte(0) == 'A' &&
+         buffer.getByte(1) == 'C' &&
+         buffer.getByte(2) == 'T' &&
+         buffer.getByte(3) == 'I' &&
+         buffer.getByte(4) == 'V' &&
+         buffer.getByte(5) == 'E' &&
+         buffer.getByte(6) == 'M' &&
+         buffer.getByte(7) == 'Q')
       {
          //todo add some handshaking
-         buffer.readBytes(7);
+         buffer.readBytes(8);
       }
    }
 

http://git-wip-us.apache.org/repos/asf/activemq-6/blob/034adfbf/activemq-server/src/main/java/org/apache/activemq/core/protocol/core/impl/CoreProtocolManagerFactory.java
----------------------------------------------------------------------
diff --git a/activemq-server/src/main/java/org/apache/activemq/core/protocol/core/impl/CoreProtocolManagerFactory.java b/activemq-server/src/main/java/org/apache/activemq/core/protocol/core/impl/CoreProtocolManagerFactory.java
index 43af54c..69302b8 100644
--- a/activemq-server/src/main/java/org/apache/activemq/core/protocol/core/impl/CoreProtocolManagerFactory.java
+++ b/activemq-server/src/main/java/org/apache/activemq/core/protocol/core/impl/CoreProtocolManagerFactory.java
@@ -15,8 +15,8 @@ package org.apache.activemq.core.protocol.core.impl;
 import java.util.List;
 
 import org.apache.activemq.api.core.Interceptor;
-import org.apache.activemq.api.core.client.HornetQClient;
-import org.apache.activemq.core.server.HornetQServer;
+import org.apache.activemq.api.core.client.ActiveMQClient;
+import org.apache.activemq.core.server.ActiveMQServer;
 import org.apache.activemq.spi.core.protocol.ProtocolManager;
 import org.apache.activemq.spi.core.protocol.ProtocolManagerFactory;
 
@@ -29,9 +29,9 @@ import org.apache.activemq.spi.core.protocol.ProtocolManagerFactory;
  */
 public class CoreProtocolManagerFactory implements ProtocolManagerFactory
 {
-   private static String[] SUPPORTED_PROTOCOLS = {HornetQClient.DEFAULT_CORE_PROTOCOL};
+   private static String[] SUPPORTED_PROTOCOLS = {ActiveMQClient.DEFAULT_CORE_PROTOCOL};
 
-   public ProtocolManager createProtocolManager(final HornetQServer server, final List<Interceptor> incomingInterceptors, List<Interceptor> outgoingInterceptors)
+   public ProtocolManager createProtocolManager(final ActiveMQServer server, final List<Interceptor> incomingInterceptors, List<Interceptor> outgoingInterceptors)
    {
       return new CoreProtocolManager(server, incomingInterceptors, outgoingInterceptors);
    }

http://git-wip-us.apache.org/repos/asf/activemq-6/blob/034adfbf/activemq-server/src/main/java/org/apache/activemq/core/protocol/core/impl/CoreSessionCallback.java
----------------------------------------------------------------------
diff --git a/activemq-server/src/main/java/org/apache/activemq/core/protocol/core/impl/CoreSessionCallback.java b/activemq-server/src/main/java/org/apache/activemq/core/protocol/core/impl/CoreSessionCallback.java
index f0933fd..f5763ed 100644
--- a/activemq-server/src/main/java/org/apache/activemq/core/protocol/core/impl/CoreSessionCallback.java
+++ b/activemq-server/src/main/java/org/apache/activemq/core/protocol/core/impl/CoreSessionCallback.java
@@ -21,7 +21,7 @@ import org.apache.activemq.core.protocol.core.impl.wireformat.SessionProducerCre
 import org.apache.activemq.core.protocol.core.impl.wireformat.SessionReceiveContinuationMessage;
 import org.apache.activemq.core.protocol.core.impl.wireformat.SessionReceiveLargeMessage;
 import org.apache.activemq.core.protocol.core.impl.wireformat.SessionReceiveMessage;
-import org.apache.activemq.core.server.HornetQServerLogger;
+import org.apache.activemq.core.server.ActiveMQServerLogger;
 import org.apache.activemq.core.server.ServerConsumer;
 import org.apache.activemq.core.server.ServerMessage;
 import org.apache.activemq.spi.core.protocol.ProtocolManager;
@@ -121,7 +121,7 @@ public final class CoreSessionCallback implements SessionCallback
       }
       else
       {
-         HornetQServerLogger.LOGGER.warnDisconnectOldClient(queueName);
+         ActiveMQServerLogger.LOGGER.warnDisconnectOldClient(queueName);
       }
    }
 
@@ -130,7 +130,7 @@ public final class CoreSessionCallback implements SessionCallback
    public boolean hasCredits(ServerConsumer consumer)
    {
       // This one will always return has credits
-      // as the flow control is done by hornetq
+      // as the flow control is done by activemq
       return true;
    }
 }
\ No newline at end of file

http://git-wip-us.apache.org/repos/asf/activemq-6/blob/034adfbf/activemq-server/src/main/java/org/apache/activemq/core/protocol/core/impl/HornetQPacketHandler.java
----------------------------------------------------------------------
diff --git a/activemq-server/src/main/java/org/apache/activemq/core/protocol/core/impl/HornetQPacketHandler.java b/activemq-server/src/main/java/org/apache/activemq/core/protocol/core/impl/HornetQPacketHandler.java
deleted file mode 100644
index 231b2c6..0000000
--- a/activemq-server/src/main/java/org/apache/activemq/core/protocol/core/impl/HornetQPacketHandler.java
+++ /dev/null
@@ -1,298 +0,0 @@
-/*
- * Copyright 2005-2014 Red Hat, Inc.
- * Red Hat licenses this file to you under the Apache License, version
- * 2.0 (the "License"); you may not use this file except in compliance
- * with the License.  You may obtain a copy of the License at
- *    http://www.apache.org/licenses/LICENSE-2.0
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
- * implied.  See the License for the specific language governing
- * permissions and limitations under the License.
- */
-package org.apache.activemq.core.protocol.core.impl;
-
-import org.apache.activemq.api.core.ActiveMQException;
-import org.apache.activemq.api.core.ActiveMQExceptionType;
-import org.apache.activemq.api.core.ActiveMQInternalErrorException;
-import org.apache.activemq.api.core.SimpleString;
-import org.apache.activemq.core.protocol.core.Channel;
-import org.apache.activemq.core.protocol.core.ChannelHandler;
-import org.apache.activemq.core.protocol.core.CoreRemotingConnection;
-import org.apache.activemq.core.protocol.core.Packet;
-import org.apache.activemq.core.protocol.core.ServerSessionPacketHandler;
-import org.apache.activemq.core.protocol.core.impl.wireformat.CheckFailoverMessage;
-import org.apache.activemq.core.protocol.core.impl.wireformat.CheckFailoverReplyMessage;
-import org.apache.activemq.core.protocol.core.impl.wireformat.CreateQueueMessage;
-import org.apache.activemq.core.protocol.core.impl.wireformat.CreateSessionMessage;
-import org.apache.activemq.core.protocol.core.impl.wireformat.CreateSessionResponseMessage;
-import org.apache.activemq.core.protocol.core.impl.wireformat.HornetQExceptionMessage;
-import org.apache.activemq.core.protocol.core.impl.wireformat.ReattachSessionMessage;
-import org.apache.activemq.core.protocol.core.impl.wireformat.ReattachSessionResponseMessage;
-import org.apache.activemq.core.security.HornetQPrincipal;
-import org.apache.activemq.core.server.HornetQMessageBundle;
-import org.apache.activemq.core.server.HornetQServer;
-import org.apache.activemq.core.server.HornetQServerLogger;
-import org.apache.activemq.core.server.ServerSession;
-import org.apache.activemq.core.version.Version;
-
-/**
- * A packet handler for all packets that need to be handled at the server level
- *
- * @author <a href="mailto:jmesnil@redhat.com">Jeff Mesnil</a>
- * @author <a href="mailto:tim.fox@jboss.com">Tim Fox</a>
- * @author <a href="ataylor@redhat.com">Andy Taylor</a>
- */
-public class HornetQPacketHandler implements ChannelHandler
-{
-   private final HornetQServer server;
-
-   private final Channel channel1;
-
-   private final CoreRemotingConnection connection;
-
-   private final CoreProtocolManager protocolManager;
-
-   public HornetQPacketHandler(final CoreProtocolManager protocolManager,
-                               final HornetQServer server,
-                               final Channel channel1,
-                               final CoreRemotingConnection connection)
-   {
-      this.protocolManager = protocolManager;
-
-      this.server = server;
-
-      this.channel1 = channel1;
-
-      this.connection = connection;
-   }
-
-   public void handlePacket(final Packet packet)
-   {
-      byte type = packet.getType();
-
-      switch (type)
-      {
-         case PacketImpl.CREATESESSION:
-         {
-            CreateSessionMessage request = (CreateSessionMessage) packet;
-
-            handleCreateSession(request);
-
-            break;
-         }
-         case PacketImpl.CHECK_FOR_FAILOVER:
-         {
-            CheckFailoverMessage request = (CheckFailoverMessage) packet;
-
-            handleCheckForFailover(request);
-
-            break;
-         }
-         case PacketImpl.REATTACH_SESSION:
-         {
-            ReattachSessionMessage request = (ReattachSessionMessage) packet;
-
-            handleReattachSession(request);
-
-            break;
-         }
-         case PacketImpl.CREATE_QUEUE:
-         {
-            // Create queue can also be fielded here in the case of a replicated store and forward queue creation
-
-            CreateQueueMessage request = (CreateQueueMessage) packet;
-
-            handleCreateQueue(request);
-
-            break;
-         }
-         default:
-         {
-            HornetQServerLogger.LOGGER.invalidPacket(packet);
-         }
-      }
-   }
-
-   private void handleCheckForFailover(CheckFailoverMessage failoverMessage)
-   {
-      String nodeID = failoverMessage.getNodeID();
-      boolean okToFailover = nodeID == null ||
-            !(server.getHAPolicy().canScaleDown() && !server.hasScaledDown(new SimpleString(nodeID)));
-      channel1.send(new CheckFailoverReplyMessage(okToFailover));
-   }
-
-   private void handleCreateSession(final CreateSessionMessage request)
-   {
-      boolean incompatibleVersion = false;
-      Packet response;
-      try
-      {
-         Version version = server.getVersion();
-         if (!version.isCompatible(request.getVersion()))
-         {
-            throw HornetQMessageBundle.BUNDLE.incompatibleClientServer();
-         }
-
-         if (!server.isStarted())
-         {
-            throw HornetQMessageBundle.BUNDLE.serverNotStarted();
-         }
-
-         // XXX HORNETQ-720 Taylor commented out this test. Should be verified.
-         /*if (!server.checkActivate())
-         {
-            throw new ActiveMQException(ActiveMQException.SESSION_CREATION_REJECTED,
-                                       "Server will not accept create session requests");
-         }*/
-
-
-         if (connection.getClientVersion() == 0)
-         {
-            connection.setClientVersion(request.getVersion());
-         }
-         else if (connection.getClientVersion() != request.getVersion())
-         {
-            HornetQServerLogger.LOGGER.incompatibleVersionAfterConnect(request.getVersion(), connection.getClientVersion());
-         }
-
-         Channel channel = connection.getChannel(request.getSessionChannelID(), request.getWindowSize());
-
-         HornetQPrincipal hornetQPrincipal = null;
-
-         if (request.getUsername() == null)
-         {
-            hornetQPrincipal = connection.getDefaultHornetQPrincipal();
-         }
-
-         ServerSession session = server.createSession(request.getName(),
-                                                      hornetQPrincipal == null ? request.getUsername() : hornetQPrincipal.getUserName(),
-                                                      hornetQPrincipal == null ? request.getPassword() : hornetQPrincipal.getPassword(),
-                                                      request.getMinLargeMessageSize(),
-                                                      connection,
-                                                      request.isAutoCommitSends(),
-                                                      request.isAutoCommitAcks(),
-                                                      request.isPreAcknowledge(),
-                                                      request.isXA(),
-                                                      request.getDefaultAddress(),
-                                                      new CoreSessionCallback(request.getName(),
-                                                                              protocolManager,
-                                                                              channel), null);
-
-         ServerSessionPacketHandler handler = new ServerSessionPacketHandler(session,
-                                                                             server.getStorageManager(),
-                                                                             channel);
-         channel.setHandler(handler);
-
-         // TODO - where is this removed?
-         protocolManager.addSessionHandler(request.getName(), handler);
-
-         response = new CreateSessionResponseMessage(server.getVersion().getIncrementingVersion());
-      }
-      catch (ActiveMQException e)
-      {
-         if (e.getType() == ActiveMQExceptionType.INCOMPATIBLE_CLIENT_SERVER_VERSIONS)
-         {
-            incompatibleVersion = true;
-            HornetQServerLogger.LOGGER.debug("Sending ActiveMQException after Incompatible client", e);
-         }
-         else
-         {
-            HornetQServerLogger.LOGGER.failedToCreateSession(e);
-         }
-
-         response = new HornetQExceptionMessage(e);
-      }
-      catch (Exception e)
-      {
-         HornetQServerLogger.LOGGER.failedToCreateSession(e);
-
-         response = new HornetQExceptionMessage(new ActiveMQInternalErrorException());
-      }
-
-      // send the exception to the client and destroy
-      // the connection if the client and server versions
-      // are not compatible
-      if (incompatibleVersion)
-      {
-         channel1.sendAndFlush(response);
-      }
-      else
-      {
-         channel1.send(response);
-      }
-   }
-
-   private void handleReattachSession(final ReattachSessionMessage request)
-   {
-      Packet response = null;
-
-      try
-      {
-
-         if (!server.isStarted())
-         {
-            response = new ReattachSessionResponseMessage(-1, false);
-         }
-
-         HornetQServerLogger.LOGGER.debug("Reattaching request from " + connection.getRemoteAddress());
-
-
-         ServerSessionPacketHandler sessionHandler = protocolManager.getSessionHandler(request.getName());
-
-         // HORNETQ-720 XXX ataylor?
-         if (/*!server.checkActivate() || */ sessionHandler == null)
-         {
-            response = new ReattachSessionResponseMessage(-1, false);
-         }
-         else
-         {
-            if (sessionHandler.getChannel().getConfirmationWindowSize() == -1)
-            {
-               // Even though session exists, we can't reattach since confi window size == -1,
-               // i.e. we don't have a resend cache for commands, so we just close the old session
-               // and let the client recreate
-
-               HornetQServerLogger.LOGGER.reattachRequestFailed(connection.getRemoteAddress());
-
-               sessionHandler.closeListeners();
-               sessionHandler.close();
-
-               response = new ReattachSessionResponseMessage(-1, false);
-            }
-            else
-            {
-               // Reconnect the channel to the new connection
-               int serverLastConfirmedCommandID = sessionHandler.transferConnection(connection,
-                                                                                    request.getLastConfirmedCommandID());
-
-               response = new ReattachSessionResponseMessage(serverLastConfirmedCommandID, true);
-            }
-         }
-      }
-      catch (Exception e)
-      {
-         HornetQServerLogger.LOGGER.failedToReattachSession(e);
-
-         response = new HornetQExceptionMessage(new ActiveMQInternalErrorException());
-      }
-
-      channel1.send(response);
-   }
-
-   private void handleCreateQueue(final CreateQueueMessage request)
-   {
-      try
-      {
-         server.createQueue(request.getAddress(),
-                            request.getQueueName(),
-                            request.getFilterString(),
-                            request.isDurable(),
-                            request.isTemporary());
-      }
-      catch (Exception e)
-      {
-         HornetQServerLogger.LOGGER.failedToHandleCreateQueue(e);
-      }
-   }
-}
\ No newline at end of file

http://git-wip-us.apache.org/repos/asf/activemq-6/blob/034adfbf/activemq-server/src/main/java/org/apache/activemq/core/protocol/core/impl/wireformat/BackupRegistrationMessage.java
----------------------------------------------------------------------
diff --git a/activemq-server/src/main/java/org/apache/activemq/core/protocol/core/impl/wireformat/BackupRegistrationMessage.java b/activemq-server/src/main/java/org/apache/activemq/core/protocol/core/impl/wireformat/BackupRegistrationMessage.java
index 430b3f5..968f1eb 100644
--- a/activemq-server/src/main/java/org/apache/activemq/core/protocol/core/impl/wireformat/BackupRegistrationMessage.java
+++ b/activemq-server/src/main/java/org/apache/activemq/core/protocol/core/impl/wireformat/BackupRegistrationMessage.java
@@ -18,7 +18,7 @@ import org.apache.activemq.core.protocol.core.impl.PacketImpl;
 
 /**
  * Registers a given backup-server as the replicating backup of a live server (i.e. a regular
- * HornetQ).
+ * ActiveMQ).
  * <p>
  * If it succeeds the backup will start synchronization of its state with the new backup node, and
  * replicating any new data. If it fails the backup server will receive a message indicating

http://git-wip-us.apache.org/repos/asf/activemq-6/blob/034adfbf/activemq-server/src/main/java/org/apache/activemq/core/protocol/stomp/WebSocketServerHandler.java
----------------------------------------------------------------------
diff --git a/activemq-server/src/main/java/org/apache/activemq/core/protocol/stomp/WebSocketServerHandler.java b/activemq-server/src/main/java/org/apache/activemq/core/protocol/stomp/WebSocketServerHandler.java
index 16bd901..6a089d7 100644
--- a/activemq-server/src/main/java/org/apache/activemq/core/protocol/stomp/WebSocketServerHandler.java
+++ b/activemq-server/src/main/java/org/apache/activemq/core/protocol/stomp/WebSocketServerHandler.java
@@ -101,7 +101,7 @@ public class WebSocketServerHandler extends SimpleChannelInboundHandler<Object>
             {
                if (future.isSuccess())
                {
-                  // we need to insert an encoder that takes the underlying ChannelBuffer of a StompFrame.toHornetQBuffer and
+                  // we need to insert an encoder that takes the underlying ChannelBuffer of a StompFrame.toActiveMQBuffer and
                   // wrap it in a binary web socket frame before letting the wsencoder send it on the wire
                   future.channel().pipeline().addAfter("wsencoder", "binary-websocket-encoder", BINARY_WEBSOCKET_ENCODER);
                }

http://git-wip-us.apache.org/repos/asf/activemq-6/blob/034adfbf/activemq-server/src/main/java/org/apache/activemq/core/remoting/impl/invm/InVMAcceptor.java
----------------------------------------------------------------------
diff --git a/activemq-server/src/main/java/org/apache/activemq/core/remoting/impl/invm/InVMAcceptor.java b/activemq-server/src/main/java/org/apache/activemq/core/remoting/impl/invm/InVMAcceptor.java
index c573cab..75e0f60 100644
--- a/activemq-server/src/main/java/org/apache/activemq/core/remoting/impl/invm/InVMAcceptor.java
+++ b/activemq-server/src/main/java/org/apache/activemq/core/remoting/impl/invm/InVMAcceptor.java
@@ -19,11 +19,11 @@ import java.util.concurrent.Executor;
 
 import org.apache.activemq.api.core.ActiveMQException;
 import org.apache.activemq.api.core.SimpleString;
-import org.apache.activemq.api.core.client.HornetQClient;
+import org.apache.activemq.api.core.client.ActiveMQClient;
 import org.apache.activemq.api.core.management.CoreNotificationType;
-import org.apache.activemq.core.security.HornetQPrincipal;
-import org.apache.activemq.core.server.HornetQComponent;
-import org.apache.activemq.core.server.HornetQMessageBundle;
+import org.apache.activemq.core.security.ActiveMQPrincipal;
+import org.apache.activemq.core.server.ActiveMQComponent;
+import org.apache.activemq.core.server.ActiveMQMessageBundle;
 import org.apache.activemq.core.server.cluster.ClusterConnection;
 import org.apache.activemq.core.server.management.Notification;
 import org.apache.activemq.core.server.management.NotificationService;
@@ -63,7 +63,7 @@ public final class InVMAcceptor implements Acceptor
 
    private final Map<String, Object> configuration;
 
-   private HornetQPrincipal defaultHornetQPrincipal;
+   private ActiveMQPrincipal defaultActiveMQPrincipal;
 
    public InVMAcceptor(final ClusterConnection clusterConnection,
                        final Map<String, Object> configuration,
@@ -212,9 +212,9 @@ public final class InVMAcceptor implements Acceptor
 
       Listener connectionListener = new Listener(connector);
 
-      InVMConnection inVMConnection = new InVMConnection(id, connectionID, remoteHandler, connectionListener, clientExecutor, defaultHornetQPrincipal);
+      InVMConnection inVMConnection = new InVMConnection(id, connectionID, remoteHandler, connectionListener, clientExecutor, defaultActiveMQPrincipal);
 
-      connectionListener.connectionCreated(this, inVMConnection, HornetQClient.DEFAULT_CORE_PROTOCOL);
+      connectionListener.connectionCreated(this, inVMConnection, ActiveMQClient.DEFAULT_CORE_PROTOCOL);
    }
 
    public void disconnect(final String connectionID)
@@ -242,9 +242,9 @@ public final class InVMAcceptor implements Acceptor
       return true;
    }
 
-   public void setDefaultHornetQPrincipal(HornetQPrincipal defaultHornetQPrincipal)
+   public void setDefaultActiveMQPrincipal(ActiveMQPrincipal defaultActiveMQPrincipal)
    {
-      this.defaultHornetQPrincipal = defaultHornetQPrincipal;
+      this.defaultActiveMQPrincipal = defaultActiveMQPrincipal;
    }
 
    private class Listener implements ConnectionLifeCycleListener
@@ -258,11 +258,11 @@ public final class InVMAcceptor implements Acceptor
          this.connector = connector;
       }
 
-      public void connectionCreated(final HornetQComponent component, final Connection connection, final String protocol)
+      public void connectionCreated(final ActiveMQComponent component, final Connection connection, final String protocol)
       {
          if (connections.putIfAbsent((String) connection.getID(), connection) != null)
          {
-            throw HornetQMessageBundle.BUNDLE.connectionExists(connection.getID());
+            throw ActiveMQMessageBundle.BUNDLE.connectionExists(connection.getID());
          }
 
          listener.connectionCreated(component, connection, protocol);

http://git-wip-us.apache.org/repos/asf/activemq-6/blob/034adfbf/activemq-server/src/main/java/org/apache/activemq/core/remoting/impl/invm/InVMConnection.java
----------------------------------------------------------------------
diff --git a/activemq-server/src/main/java/org/apache/activemq/core/remoting/impl/invm/InVMConnection.java b/activemq-server/src/main/java/org/apache/activemq/core/remoting/impl/invm/InVMConnection.java
index ec4ae0a..0a2d027 100644
--- a/activemq-server/src/main/java/org/apache/activemq/core/remoting/impl/invm/InVMConnection.java
+++ b/activemq-server/src/main/java/org/apache/activemq/core/remoting/impl/invm/InVMConnection.java
@@ -24,8 +24,8 @@ import org.apache.activemq.api.core.ActiveMQBuffer;
 import org.apache.activemq.api.core.ActiveMQBuffers;
 import org.apache.activemq.api.core.ActiveMQInterruptedException;
 import org.apache.activemq.api.core.TransportConfiguration;
-import org.apache.activemq.core.security.HornetQPrincipal;
-import org.apache.activemq.core.server.HornetQServerLogger;
+import org.apache.activemq.core.security.ActiveMQPrincipal;
+import org.apache.activemq.core.server.ActiveMQServerLogger;
 import org.apache.activemq.spi.core.protocol.RemotingConnection;
 import org.apache.activemq.spi.core.remoting.BufferHandler;
 import org.apache.activemq.spi.core.remoting.Connection;
@@ -40,7 +40,7 @@ import org.apache.activemq.utils.UUIDGenerator;
  */
 public class InVMConnection implements Connection
 {
-   private static final boolean isTrace = HornetQServerLogger.LOGGER.isTraceEnabled();
+   private static final boolean isTrace = ActiveMQServerLogger.LOGGER.isTraceEnabled();
 
    private final BufferHandler handler;
 
@@ -59,7 +59,7 @@ public class InVMConnection implements Connection
 
    private volatile boolean closing;
 
-   private final HornetQPrincipal defaultHornetQPrincipal;
+   private final ActiveMQPrincipal defaultActiveMQPrincipal;
 
    private RemotingConnection protocolConnection;
 
@@ -85,7 +85,7 @@ public class InVMConnection implements Connection
                          final BufferHandler handler,
                          final ConnectionLifeCycleListener listener,
                          final Executor executor,
-                         final HornetQPrincipal defaultHornetQPrincipal)
+                         final ActiveMQPrincipal defaultActiveMQPrincipal)
    {
       this.serverID = serverID;
 
@@ -97,7 +97,7 @@ public class InVMConnection implements Connection
 
       this.executor = executor;
 
-      this.defaultHornetQPrincipal = defaultHornetQPrincipal;
+      this.defaultActiveMQPrincipal = defaultActiveMQPrincipal;
    }
 
 
@@ -181,7 +181,7 @@ public class InVMConnection implements Connection
                      copied.readInt(); // read and discard
                      if (isTrace)
                      {
-                        HornetQServerLogger.LOGGER.trace(InVMConnection.this + "::Sending inVM packet");
+                        ActiveMQServerLogger.LOGGER.trace(InVMConnection.this + "::Sending inVM packet");
                      }
                      handler.bufferReceived(id, copied);
                      if (futureListener != null)
@@ -194,14 +194,14 @@ public class InVMConnection implements Connection
                catch (Exception e)
                {
                   final String msg = "Failed to write to handler on connector " + this;
-                  HornetQServerLogger.LOGGER.errorWritingToInvmConnector(e, this);
+                  ActiveMQServerLogger.LOGGER.errorWritingToInvmConnector(e, this);
                   throw new IllegalStateException(msg, e);
                }
                finally
                {
                   if (isTrace)
                   {
-                     HornetQServerLogger.LOGGER.trace(InVMConnection.this + "::packet sent done");
+                     ActiveMQServerLogger.LOGGER.trace(InVMConnection.this + "::packet sent done");
                   }
                }
             }
@@ -222,7 +222,7 @@ public class InVMConnection implements Connection
             {
                if (!latch.await(10, TimeUnit.SECONDS))
                {
-                  HornetQServerLogger.LOGGER.timedOutFlushingInvmChannel();
+                  ActiveMQServerLogger.LOGGER.timedOutFlushingInvmChannel();
                }
             }
             catch (InterruptedException e)
@@ -262,9 +262,9 @@ public class InVMConnection implements Connection
       return false;
    }
 
-   public HornetQPrincipal getDefaultHornetQPrincipal()
+   public ActiveMQPrincipal getDefaultActiveMQPrincipal()
    {
-      return defaultHornetQPrincipal;
+      return defaultActiveMQPrincipal;
    }
 
    public static void setFlushEnabled(boolean enable)

http://git-wip-us.apache.org/repos/asf/activemq-6/blob/034adfbf/activemq-server/src/main/java/org/apache/activemq/core/remoting/impl/invm/InVMConnector.java
----------------------------------------------------------------------
diff --git a/activemq-server/src/main/java/org/apache/activemq/core/remoting/impl/invm/InVMConnector.java b/activemq-server/src/main/java/org/apache/activemq/core/remoting/impl/invm/InVMConnector.java
index d5f9480..6e187af 100644
--- a/activemq-server/src/main/java/org/apache/activemq/core/remoting/impl/invm/InVMConnector.java
+++ b/activemq-server/src/main/java/org/apache/activemq/core/remoting/impl/invm/InVMConnector.java
@@ -20,9 +20,9 @@ import java.util.concurrent.ConcurrentMap;
 import java.util.concurrent.Executor;
 
 import org.apache.activemq.api.core.ActiveMQException;
-import org.apache.activemq.core.server.HornetQComponent;
-import org.apache.activemq.core.server.HornetQServerLogger;
-import org.apache.activemq.core.server.HornetQMessageBundle;
+import org.apache.activemq.core.server.ActiveMQComponent;
+import org.apache.activemq.core.server.ActiveMQServerLogger;
+import org.apache.activemq.core.server.ActiveMQMessageBundle;
 import org.apache.activemq.spi.core.remoting.AbstractConnector;
 import org.apache.activemq.spi.core.remoting.Acceptor;
 import org.apache.activemq.spi.core.remoting.BufferHandler;
@@ -147,7 +147,7 @@ public class InVMConnector extends AbstractConnector
       {
          InVMConnector.incFailures();
 
-         HornetQServerLogger.LOGGER.debug("Returning null on InVMConnector for tests");
+         ActiveMQServerLogger.LOGGER.debug("Returning null on InVMConnector for tests");
          // For testing only
          return null;
       }
@@ -211,11 +211,11 @@ public class InVMConnector extends AbstractConnector
 
    private class Listener implements ConnectionLifeCycleListener
    {
-      public void connectionCreated(final HornetQComponent component, final Connection connection, final String protocol)
+      public void connectionCreated(final ActiveMQComponent component, final Connection connection, final String protocol)
       {
          if (connections.putIfAbsent((String)connection.getID(), connection) != null)
          {
-            throw HornetQMessageBundle.BUNDLE.connectionExists(connection.getID());
+            throw ActiveMQMessageBundle.BUNDLE.connectionExists(connection.getID());
          }
 
          listener.connectionCreated(component, connection, protocol);

http://git-wip-us.apache.org/repos/asf/activemq-6/blob/034adfbf/activemq-server/src/main/java/org/apache/activemq/core/remoting/impl/invm/InVMRegistry.java
----------------------------------------------------------------------
diff --git a/activemq-server/src/main/java/org/apache/activemq/core/remoting/impl/invm/InVMRegistry.java b/activemq-server/src/main/java/org/apache/activemq/core/remoting/impl/invm/InVMRegistry.java
index 4247aad..255bf31 100644
--- a/activemq-server/src/main/java/org/apache/activemq/core/remoting/impl/invm/InVMRegistry.java
+++ b/activemq-server/src/main/java/org/apache/activemq/core/remoting/impl/invm/InVMRegistry.java
@@ -12,7 +12,7 @@
  */
 package org.apache.activemq.core.remoting.impl.invm;
 
-import org.apache.activemq.core.server.HornetQMessageBundle;
+import org.apache.activemq.core.server.ActiveMQMessageBundle;
 
 import java.util.concurrent.ConcurrentHashMap;
 import java.util.concurrent.ConcurrentMap;
@@ -33,7 +33,7 @@ public final class InVMRegistry
    {
       if (acceptors.putIfAbsent(id, acceptor) != null)
       {
-         throw HornetQMessageBundle.BUNDLE.acceptorExists(id);
+         throw ActiveMQMessageBundle.BUNDLE.acceptorExists(id);
       }
    }
 
@@ -41,7 +41,7 @@ public final class InVMRegistry
    {
       if (acceptors.remove(id) == null)
       {
-         throw HornetQMessageBundle.BUNDLE.acceptorNotExists(id);
+         throw ActiveMQMessageBundle.BUNDLE.acceptorNotExists(id);
       }
    }
 

http://git-wip-us.apache.org/repos/asf/activemq-6/blob/034adfbf/activemq-server/src/main/java/org/apache/activemq/core/remoting/impl/netty/NettyAcceptor.java
----------------------------------------------------------------------
diff --git a/activemq-server/src/main/java/org/apache/activemq/core/remoting/impl/netty/NettyAcceptor.java b/activemq-server/src/main/java/org/apache/activemq/core/remoting/impl/netty/NettyAcceptor.java
index b490ce1..4ad7c10 100644
--- a/activemq-server/src/main/java/org/apache/activemq/core/remoting/impl/netty/NettyAcceptor.java
+++ b/activemq-server/src/main/java/org/apache/activemq/core/remoting/impl/netty/NettyAcceptor.java
@@ -58,10 +58,10 @@ import org.apache.activemq.api.core.management.CoreNotificationType;
 import org.apache.activemq.core.client.impl.ClientSessionFactoryImpl;
 import org.apache.activemq.core.protocol.ProtocolHandler;
 import org.apache.activemq.core.remoting.impl.ssl.SSLSupport;
-import org.apache.activemq.core.security.HornetQPrincipal;
-import org.apache.activemq.core.server.HornetQComponent;
-import org.apache.activemq.core.server.HornetQMessageBundle;
-import org.apache.activemq.core.server.HornetQServerLogger;
+import org.apache.activemq.core.security.ActiveMQPrincipal;
+import org.apache.activemq.core.server.ActiveMQComponent;
+import org.apache.activemq.core.server.ActiveMQMessageBundle;
+import org.apache.activemq.core.server.ActiveMQServerLogger;
 import org.apache.activemq.core.server.cluster.ClusterConnection;
 import org.apache.activemq.core.server.management.Notification;
 import org.apache.activemq.core.server.management.NotificationService;
@@ -71,7 +71,7 @@ import org.apache.activemq.spi.core.remoting.BufferHandler;
 import org.apache.activemq.spi.core.remoting.Connection;
 import org.apache.activemq.spi.core.remoting.ConnectionLifeCycleListener;
 import org.apache.activemq.utils.ConfigurationHelper;
-import org.apache.activemq.utils.HornetQThreadFactory;
+import org.apache.activemq.utils.ActiveMQThreadFactory;
 import org.apache.activemq.utils.TypedProperties;
 
 /**
@@ -316,7 +316,7 @@ public class NettyAcceptor implements Acceptor
             threadsToUse = this.nioRemotingThreads;
          }
          channelClazz = NioServerSocketChannel.class;
-         eventLoopGroup = new NioEventLoopGroup(threadsToUse, new HornetQThreadFactory("hornetq-netty-threads", true, getThisClassLoader()));
+         eventLoopGroup = new NioEventLoopGroup(threadsToUse, new ActiveMQThreadFactory("activemq-netty-threads", true, getThisClassLoader()));
       }
 
       bootstrap = new ServerBootstrap();
@@ -374,7 +374,7 @@ public class NettyAcceptor implements Acceptor
                   }
                   catch (IllegalArgumentException e)
                   {
-                     HornetQServerLogger.LOGGER.invalidCipherSuite(SSLSupport.parseArrayIntoCommandSeparatedList(engine.getSupportedCipherSuites()));
+                     ActiveMQServerLogger.LOGGER.invalidCipherSuite(SSLSupport.parseArrayIntoCommandSeparatedList(engine.getSupportedCipherSuites()));
                      throw e;
                   }
                }
@@ -387,7 +387,7 @@ public class NettyAcceptor implements Acceptor
                   }
                   catch (IllegalArgumentException e)
                   {
-                     HornetQServerLogger.LOGGER.invalidProtocol(SSLSupport.parseArrayIntoCommandSeparatedList(engine.getSupportedProtocols()));
+                     ActiveMQServerLogger.LOGGER.invalidProtocol(SSLSupport.parseArrayIntoCommandSeparatedList(engine.getSupportedProtocols()));
                      throw e;
                   }
                }
@@ -404,7 +404,7 @@ public class NettyAcceptor implements Acceptor
                {
                   if (s.equals("SSLv3") || s.equals("SSLv2Hello"))
                   {
-                     HornetQServerLogger.LOGGER.disallowedProtocol(s);
+                     ActiveMQServerLogger.LOGGER.disallowedProtocol(s);
                      continue;
                   }
                   set.add(s);
@@ -438,9 +438,9 @@ public class NettyAcceptor implements Acceptor
       bootstrap.childOption(ChannelOption.SO_REUSEADDR, true);
       bootstrap.childOption(ChannelOption.SO_KEEPALIVE, true);
       bootstrap.childOption(ChannelOption.ALLOCATOR, PartialPooledByteBufAllocator.INSTANCE);
-      channelGroup = new DefaultChannelGroup("hornetq-accepted-channels", GlobalEventExecutor.INSTANCE);
+      channelGroup = new DefaultChannelGroup("activemq-accepted-channels", GlobalEventExecutor.INSTANCE);
 
-      serverChannelGroup = new DefaultChannelGroup("hornetq-acceptor-channels", GlobalEventExecutor.INSTANCE);
+      serverChannelGroup = new DefaultChannelGroup("activemq-acceptor-channels", GlobalEventExecutor.INSTANCE);
 
       if (httpUpgradeEnabled)
       {
@@ -474,7 +474,7 @@ public class NettyAcceptor implements Acceptor
                                                                             TimeUnit.MILLISECONDS);
          }
 
-         HornetQServerLogger.LOGGER.startedNettyAcceptor(TransportConstants.NETTY_VERSION, host, port);
+         ActiveMQServerLogger.LOGGER.startedNettyAcceptor(TransportConstants.NETTY_VERSION, host, port);
       }
    }
 
@@ -543,14 +543,14 @@ public class NettyAcceptor implements Acceptor
 
       if (!future.isSuccess())
       {
-         HornetQServerLogger.LOGGER.nettyChannelGroupError();
+         ActiveMQServerLogger.LOGGER.nettyChannelGroupError();
          Iterator<Channel> iterator = future.group().iterator();
          while (iterator.hasNext())
          {
             Channel channel = iterator.next();
             if (channel.isActive())
             {
-               HornetQServerLogger.LOGGER.nettyChannelStillOpen(channel, channel.remoteAddress());
+               ActiveMQServerLogger.LOGGER.nettyChannelStillOpen(channel, channel.remoteAddress());
             }
          }
       }
@@ -612,14 +612,14 @@ public class NettyAcceptor implements Acceptor
       ChannelGroupFuture future = serverChannelGroup.close().awaitUninterruptibly();
       if (!future.isSuccess())
       {
-         HornetQServerLogger.LOGGER.nettyChannelGroupBindError();
+         ActiveMQServerLogger.LOGGER.nettyChannelGroupBindError();
          Iterator<Channel> iterator = future.group().iterator();
          while (iterator.hasNext())
          {
             Channel channel = iterator.next();
             if (channel.isActive())
             {
-               HornetQServerLogger.LOGGER.nettyChannelStillBound(channel, channel.remoteAddress());
+               ActiveMQServerLogger.LOGGER.nettyChannelStillBound(channel, channel.remoteAddress());
             }
          }
       }
@@ -634,9 +634,9 @@ public class NettyAcceptor implements Acceptor
    /**
     * not allowed
     *
-    * @param defaultHornetQPrincipal
+    * @param defaultActiveMQPrincipal
     */
-   public void setDefaultHornetQPrincipal(HornetQPrincipal defaultHornetQPrincipal)
+   public void setDefaultActiveMQPrincipal(ActiveMQPrincipal defaultActiveMQPrincipal)
    {
       throw new IllegalStateException("unsecure connections not allowed");
    }
@@ -659,17 +659,17 @@ public class NettyAcceptor implements Acceptor
 
    public ConnectionCreator createConnectionCreator()
    {
-      return new HornetQServerChannelHandler(channelGroup, handler, new Listener());
+      return new ActiveMQServerChannelHandler(channelGroup, handler, new Listener());
    }
 
    // Inner classes -----------------------------------------------------------------------------
 
-   private final class HornetQServerChannelHandler extends HornetQChannelHandler implements ConnectionCreator
+   private final class ActiveMQServerChannelHandler extends ActiveMQChannelHandler implements ConnectionCreator
    {
 
-      HornetQServerChannelHandler(final ChannelGroup group,
-                                  final BufferHandler handler,
-                                  final ConnectionLifeCycleListener listener)
+      ActiveMQServerChannelHandler(final ChannelGroup group,
+                                   final BufferHandler handler,
+                                   final ConnectionLifeCycleListener listener)
       {
          super(group, handler, listener);
       }
@@ -711,11 +711,11 @@ public class NettyAcceptor implements Acceptor
 
    private class Listener implements ConnectionLifeCycleListener
    {
-      public void connectionCreated(final HornetQComponent component, final Connection connection, final String protocol)
+      public void connectionCreated(final ActiveMQComponent component, final Connection connection, final String protocol)
       {
          if (connections.putIfAbsent(connection.getID(), (NettyServerConnection) connection) != null)
          {
-            throw HornetQMessageBundle.BUNDLE.connectionExists(connection.getID());
+            throw ActiveMQMessageBundle.BUNDLE.connectionExists(connection.getID());
          }
 
          listener.connectionCreated(component, connection, protocol);

http://git-wip-us.apache.org/repos/asf/activemq-6/blob/034adfbf/activemq-server/src/main/java/org/apache/activemq/core/remoting/server/RemotingService.java
----------------------------------------------------------------------
diff --git a/activemq-server/src/main/java/org/apache/activemq/core/remoting/server/RemotingService.java b/activemq-server/src/main/java/org/apache/activemq/core/remoting/server/RemotingService.java
index cf0b0db..f73a2ba 100644
--- a/activemq-server/src/main/java/org/apache/activemq/core/remoting/server/RemotingService.java
+++ b/activemq-server/src/main/java/org/apache/activemq/core/remoting/server/RemotingService.java
@@ -16,7 +16,7 @@ import java.util.Set;
 
 import org.apache.activemq.api.core.Interceptor;
 import org.apache.activemq.core.protocol.core.CoreRemotingConnection;
-import org.apache.activemq.core.security.HornetQPrincipal;
+import org.apache.activemq.core.security.ActiveMQPrincipal;
 import org.apache.activemq.spi.core.protocol.RemotingConnection;
 import org.apache.activemq.spi.core.remoting.Acceptor;
 
@@ -60,7 +60,7 @@ public interface RemotingService
     *
     * @param principal
     */
-   void allowInvmSecurityOverride(HornetQPrincipal principal);
+   void allowInvmSecurityOverride(ActiveMQPrincipal principal);
 
    /**
     * Freezes and then disconnects all connections except the given one and tells the client where else

http://git-wip-us.apache.org/repos/asf/activemq-6/blob/034adfbf/activemq-server/src/main/java/org/apache/activemq/core/remoting/server/impl/RemotingServiceImpl.java
----------------------------------------------------------------------
diff --git a/activemq-server/src/main/java/org/apache/activemq/core/remoting/server/impl/RemotingServiceImpl.java b/activemq-server/src/main/java/org/apache/activemq/core/remoting/server/impl/RemotingServiceImpl.java
index 7fd9a46..2ee1c3e 100644
--- a/activemq-server/src/main/java/org/apache/activemq/core/remoting/server/impl/RemotingServiceImpl.java
+++ b/activemq-server/src/main/java/org/apache/activemq/core/remoting/server/impl/RemotingServiceImpl.java
@@ -42,11 +42,11 @@ import org.apache.activemq.core.protocol.core.impl.CoreProtocolManagerFactory;
 import org.apache.activemq.core.remoting.FailureListener;
 import org.apache.activemq.core.remoting.impl.netty.TransportConstants;
 import org.apache.activemq.core.remoting.server.RemotingService;
-import org.apache.activemq.core.security.HornetQPrincipal;
-import org.apache.activemq.core.server.HornetQComponent;
-import org.apache.activemq.core.server.HornetQMessageBundle;
-import org.apache.activemq.core.server.HornetQServer;
-import org.apache.activemq.core.server.HornetQServerLogger;
+import org.apache.activemq.core.security.ActiveMQPrincipal;
+import org.apache.activemq.core.server.ActiveMQComponent;
+import org.apache.activemq.core.server.ActiveMQMessageBundle;
+import org.apache.activemq.core.server.ActiveMQServer;
+import org.apache.activemq.core.server.ActiveMQServerLogger;
 import org.apache.activemq.core.server.cluster.ClusterConnection;
 import org.apache.activemq.core.server.cluster.ClusterManager;
 import org.apache.activemq.core.server.impl.ServiceRegistry;
@@ -63,7 +63,7 @@ import org.apache.activemq.spi.core.remoting.Connection;
 import org.apache.activemq.spi.core.remoting.ConnectionLifeCycleListener;
 import org.apache.activemq.utils.ClassloadingUtil;
 import org.apache.activemq.utils.ConfigurationHelper;
-import org.apache.activemq.utils.HornetQThreadFactory;
+import org.apache.activemq.utils.ActiveMQThreadFactory;
 
 /**
  * @author <a href="mailto:jmesnil@redhat.com">Jeff Mesnil</a>
@@ -75,7 +75,7 @@ public class RemotingServiceImpl implements RemotingService, ConnectionLifeCycle
 {
    // Constants -----------------------------------------------------
 
-   private static final boolean isTrace = HornetQServerLogger.LOGGER.isTraceEnabled();
+   private static final boolean isTrace = ActiveMQServerLogger.LOGGER.isTraceEnabled();
 
    public static final long CONNECTION_TTL_CHECK_INTERVAL = 2000;
 
@@ -93,7 +93,7 @@ public class RemotingServiceImpl implements RemotingService, ConnectionLifeCycle
 
    private final Map<Object, ConnectionEntry> connections = new ConcurrentHashMap<Object, ConnectionEntry>();
 
-   private final HornetQServer server;
+   private final ActiveMQServer server;
 
    private final ManagementService managementService;
 
@@ -109,7 +109,7 @@ public class RemotingServiceImpl implements RemotingService, ConnectionLifeCycle
 
    private final Map<String, ProtocolManager> protocolMap = new ConcurrentHashMap();
 
-   private HornetQPrincipal defaultInvmSecurityPrincipal;
+   private ActiveMQPrincipal defaultInvmSecurityPrincipal;
 
    private ServiceRegistry serviceRegistry;
 
@@ -119,7 +119,7 @@ public class RemotingServiceImpl implements RemotingService, ConnectionLifeCycle
 
    public RemotingServiceImpl(final ClusterManager clusterManager,
                               final Configuration config,
-                              final HornetQServer server,
+                              final ActiveMQServer server,
                               final ManagementService managementService,
                               final ScheduledExecutorService scheduledThreadPool,
                               List<ProtocolManagerFactory> protocolManagerFactories,
@@ -144,7 +144,7 @@ public class RemotingServiceImpl implements RemotingService, ConnectionLifeCycle
       //i know there is only 1
       this.flushExecutor = flushExecutor;
 
-      HornetQServerLogger.LOGGER.addingProtocolSupport(coreProtocolManagerFactory.getProtocols()[0]);
+      ActiveMQServerLogger.LOGGER.addingProtocolSupport(coreProtocolManagerFactory.getProtocols()[0]);
       this.protocolMap.put(coreProtocolManagerFactory.getProtocols()[0],
                            coreProtocolManagerFactory.createProtocolManager(server, incomingInterceptors, outgoingInterceptors));
 
@@ -158,7 +158,7 @@ public class RemotingServiceImpl implements RemotingService, ConnectionLifeCycle
                String[] protocols = next.getProtocols();
                for (String protocol : protocols)
                {
-                  HornetQServerLogger.LOGGER.addingProtocolSupport(protocol);
+                  ActiveMQServerLogger.LOGGER.addingProtocolSupport(protocol);
                   protocolMap.put(protocol, next.createProtocolManager(server, incomingInterceptors, outgoingInterceptors));
                }
             }
@@ -172,7 +172,7 @@ public class RemotingServiceImpl implements RemotingService, ConnectionLifeCycle
             String[] protocols = protocolManagerFactory.getProtocols();
             for (String protocol : protocols)
             {
-               HornetQServerLogger.LOGGER.addingProtocolSupport(protocol);
+               ActiveMQServerLogger.LOGGER.addingProtocolSupport(protocol);
                protocolMap.put(protocol, protocolManagerFactory.createProtocolManager(server, incomingInterceptors, outgoingInterceptors));
             }
          }
@@ -219,7 +219,7 @@ public class RemotingServiceImpl implements RemotingService, ConnectionLifeCycle
       // This needs to be a different thread pool to the main thread pool especially for OIO where we may need
       // to support many hundreds of connections, but the main thread pool must be kept small for better performance
 
-      ThreadFactory tFactory = new HornetQThreadFactory("HornetQ-remoting-threads-" + server.toString() +
+      ThreadFactory tFactory = new ActiveMQThreadFactory("ActiveMQ-remoting-threads-" + server.toString() +
                                                            "-" +
                                                            System.identityHashCode(this), false, tccl);
 
@@ -244,7 +244,7 @@ public class RemotingServiceImpl implements RemotingService, ConnectionLifeCycle
 
                if (!invalid.isEmpty())
                {
-                  HornetQServerLogger.LOGGER.invalidAcceptorKeys(ConfigurationHelper.stringSetToCommaListString(invalid));
+                  ActiveMQServerLogger.LOGGER.invalidAcceptorKeys(ConfigurationHelper.stringSetToCommaListString(invalid));
 
                   continue;
                }
@@ -257,12 +257,12 @@ public class RemotingServiceImpl implements RemotingService, ConnectionLifeCycle
 
             if (protocol != null)
             {
-               HornetQServerLogger.LOGGER.warnDeprecatedProtocol();
+               ActiveMQServerLogger.LOGGER.warnDeprecatedProtocol();
                ProtocolManager protocolManager = protocolMap.get(protocol);
 
                if (protocolManager == null)
                {
-                  throw HornetQMessageBundle.BUNDLE.noProtocolManagerFound(protocol);
+                  throw ActiveMQMessageBundle.BUNDLE.noProtocolManagerFound(protocol);
                }
                else
                {
@@ -285,7 +285,7 @@ public class RemotingServiceImpl implements RemotingService, ConnectionLifeCycle
 
                      if (protocolManager == null)
                      {
-                        throw HornetQMessageBundle.BUNDLE.noProtocolManagerFound(actualProtocol);
+                        throw ActiveMQMessageBundle.BUNDLE.noProtocolManagerFound(actualProtocol);
                      }
                      else
                      {
@@ -308,7 +308,7 @@ public class RemotingServiceImpl implements RemotingService, ConnectionLifeCycle
 
             if (defaultInvmSecurityPrincipal != null && acceptor.isUnsecurable())
             {
-               acceptor.setDefaultHornetQPrincipal(defaultInvmSecurityPrincipal);
+               acceptor.setDefaultActiveMQPrincipal(defaultInvmSecurityPrincipal);
             }
 
             acceptors.put(info.getName(), acceptor);
@@ -322,7 +322,7 @@ public class RemotingServiceImpl implements RemotingService, ConnectionLifeCycle
          }
          catch (Exception e)
          {
-            HornetQServerLogger.LOGGER.errorCreatingAcceptor(e, info.getFactoryClassName());
+            ActiveMQServerLogger.LOGGER.errorCreatingAcceptor(e, info.getFactoryClassName());
          }
       }
 
@@ -339,14 +339,14 @@ public class RemotingServiceImpl implements RemotingService, ConnectionLifeCycle
       started = true;
    }
 
-   public synchronized void allowInvmSecurityOverride(HornetQPrincipal principal)
+   public synchronized void allowInvmSecurityOverride(ActiveMQPrincipal principal)
    {
       defaultInvmSecurityPrincipal = principal;
       for (Acceptor acceptor : acceptors.values())
       {
          if (acceptor.isUnsecurable())
          {
-            acceptor.setDefaultHornetQPrincipal(principal);
+            acceptor.setDefaultActiveMQPrincipal(principal);
          }
       }
    }
@@ -365,7 +365,7 @@ public class RemotingServiceImpl implements RemotingService, ConnectionLifeCycle
          }
          catch (Exception e)
          {
-            HornetQServerLogger.LOGGER.errorStoppingAcceptor();
+            ActiveMQServerLogger.LOGGER.errorStoppingAcceptor();
          }
       }
       HashMap<Object, ConnectionEntry> connectionEntries = new HashMap<Object, ConnectionEntry>(connections);
@@ -379,9 +379,9 @@ public class RemotingServiceImpl implements RemotingService, ConnectionLifeCycle
          if (conn.equals(connectionToKeepOpen))
             continue;
 
-         if (HornetQServerLogger.LOGGER.isTraceEnabled())
+         if (ActiveMQServerLogger.LOGGER.isTraceEnabled())
          {
-            HornetQServerLogger.LOGGER.trace("Sending connection.disconnection packet to " + conn);
+            ActiveMQServerLogger.LOGGER.trace("Sending connection.disconnection packet to " + conn);
          }
 
          if (!conn.isClient())
@@ -404,16 +404,16 @@ public class RemotingServiceImpl implements RemotingService, ConnectionLifeCycle
       // We need to stop them accepting first so no new connections are accepted after we send the disconnect message
       for (Acceptor acceptor : acceptors.values())
       {
-         if (HornetQServerLogger.LOGGER.isDebugEnabled())
+         if (ActiveMQServerLogger.LOGGER.isDebugEnabled())
          {
-            HornetQServerLogger.LOGGER.debug("Pausing acceptor " + acceptor);
+            ActiveMQServerLogger.LOGGER.debug("Pausing acceptor " + acceptor);
          }
          acceptor.pause();
       }
 
-      if (HornetQServerLogger.LOGGER.isDebugEnabled())
+      if (ActiveMQServerLogger.LOGGER.isDebugEnabled())
       {
-         HornetQServerLogger.LOGGER.debug("Sending disconnect on live connections");
+         ActiveMQServerLogger.LOGGER.debug("Sending disconnect on live connections");
       }
 
       HashSet<ConnectionEntry> connectionEntries = new HashSet<ConnectionEntry>(connections.values());
@@ -424,9 +424,9 @@ public class RemotingServiceImpl implements RemotingService, ConnectionLifeCycle
       {
          RemotingConnection conn = entry.connection;
 
-         if (HornetQServerLogger.LOGGER.isTraceEnabled())
+         if (ActiveMQServerLogger.LOGGER.isTraceEnabled())
          {
-            HornetQServerLogger.LOGGER.trace("Sending connection.disconnection packet to " + conn);
+            ActiveMQServerLogger.LOGGER.trace("Sending connection.disconnection packet to " + conn);
          }
 
          conn.disconnect(criticalError);
@@ -454,7 +454,7 @@ public class RemotingServiceImpl implements RemotingService, ConnectionLifeCycle
 
          if (!ok)
          {
-            HornetQServerLogger.LOGGER.timeoutRemotingThreadPool();
+            ActiveMQServerLogger.LOGGER.timeoutRemotingThreadPool();
          }
       }
 
@@ -484,7 +484,7 @@ public class RemotingServiceImpl implements RemotingService, ConnectionLifeCycle
       }
       else
       {
-         HornetQServerLogger.LOGGER.errorRemovingConnection();
+         ActiveMQServerLogger.LOGGER.errorRemovingConnection();
 
          return null;
       }
@@ -500,7 +500,7 @@ public class RemotingServiceImpl implements RemotingService, ConnectionLifeCycle
       }
       else
       {
-         HornetQServerLogger.LOGGER.errorRemovingConnection();
+         ActiveMQServerLogger.LOGGER.errorRemovingConnection();
 
          return null;
       }
@@ -525,7 +525,7 @@ public class RemotingServiceImpl implements RemotingService, ConnectionLifeCycle
       return protocolMap.get(protocol);
    }
 
-   public void connectionCreated(final HornetQComponent component, final Connection connection, final String protocol)
+   public void connectionCreated(final ActiveMQComponent component, final Connection connection, final String protocol)
    {
       if (server == null)
       {
@@ -536,14 +536,14 @@ public class RemotingServiceImpl implements RemotingService, ConnectionLifeCycle
 
       if (pmgr == null)
       {
-         throw HornetQMessageBundle.BUNDLE.unknownProtocol(protocol);
+         throw ActiveMQMessageBundle.BUNDLE.unknownProtocol(protocol);
       }
 
       ConnectionEntry entry = pmgr.createConnectionEntry((Acceptor) component, connection);
 
       if (isTrace)
       {
-         HornetQServerLogger.LOGGER.trace("Connection created " + connection);
+         ActiveMQServerLogger.LOGGER.trace("Connection created " + connection);
       }
 
       connections.put(connection.getID(), entry);
@@ -554,7 +554,7 @@ public class RemotingServiceImpl implements RemotingService, ConnectionLifeCycle
 
       if (isTrace)
       {
-         HornetQServerLogger.LOGGER.trace("Connection removed " + connectionID + " from server " + this.server, new Exception("trace"));
+         ActiveMQServerLogger.LOGGER.trace("Connection removed " + connectionID + " from server " + this.server, new Exception("trace"));
       }
 
       ConnectionEntry conn = connections.get(connectionID);
@@ -662,9 +662,9 @@ public class RemotingServiceImpl implements RemotingService, ConnectionLifeCycle
          }
          else
          {
-            if (HornetQServerLogger.LOGGER.isTraceEnabled())
+            if (ActiveMQServerLogger.LOGGER.isTraceEnabled())
             {
-               HornetQServerLogger.LOGGER.trace("ConnectionID = " + connectionID + " was already closed, so ignoring packet");
+               ActiveMQServerLogger.LOGGER.trace("ConnectionID = " + connectionID + " was already closed, so ignoring packet");
             }
          }
       }
@@ -679,7 +679,7 @@ public class RemotingServiceImpl implements RemotingService, ConnectionLifeCycle
 
       FailureCheckAndFlushThread(final long pauseInterval)
       {
-         super("hornetq-failure-check-thread");
+         super("activemq-failure-check-thread");
 
          this.pauseInterval = pauseInterval;
       }
@@ -752,7 +752,7 @@ public class RemotingServiceImpl implements RemotingService, ConnectionLifeCycle
                            }
                            catch (Throwable e)
                            {
-                              HornetQServerLogger.LOGGER.warn(e.getMessage(), e);
+                              ActiveMQServerLogger.LOGGER.warn(e.getMessage(), e);
                            }
 
                         }
@@ -765,7 +765,7 @@ public class RemotingServiceImpl implements RemotingService, ConnectionLifeCycle
                   RemotingConnection conn = getConnection(id);
                   if (conn != null)
                   {
-                     conn.fail(HornetQMessageBundle.BUNDLE.clientExited(conn.getRemoteAddress()));
+                     conn.fail(ActiveMQMessageBundle.BUNDLE.clientExited(conn.getRemoteAddress()));
                      removeConnection(id);
                   }
                }
@@ -775,7 +775,7 @@ public class RemotingServiceImpl implements RemotingService, ConnectionLifeCycle
             }
             catch (Throwable e)
             {
-               HornetQServerLogger.LOGGER.errorOnFailureCheck(e);
+               ActiveMQServerLogger.LOGGER.errorOnFailureCheck(e);
             }
          }
       }

http://git-wip-us.apache.org/repos/asf/activemq-6/blob/034adfbf/activemq-server/src/main/java/org/apache/activemq/core/replication/ReplicatedJournal.java
----------------------------------------------------------------------
diff --git a/activemq-server/src/main/java/org/apache/activemq/core/replication/ReplicatedJournal.java b/activemq-server/src/main/java/org/apache/activemq/core/replication/ReplicatedJournal.java
index eb8e2d5..765edb3 100644
--- a/activemq-server/src/main/java/org/apache/activemq/core/replication/ReplicatedJournal.java
+++ b/activemq-server/src/main/java/org/apache/activemq/core/replication/ReplicatedJournal.java
@@ -439,7 +439,7 @@ public class ReplicatedJournal implements Journal
 
    /**
     * @throws Exception
-    * @see org.apache.activemq.core.server.HornetQComponent#start()
+    * @see org.apache.activemq.core.server.ActiveMQComponent#start()
     */
    public void start() throws Exception
    {
@@ -448,7 +448,7 @@ public class ReplicatedJournal implements Journal
 
    /**
     * @throws Exception
-    * @see org.apache.activemq.core.server.HornetQComponent#stop()
+    * @see org.apache.activemq.core.server.ActiveMQComponent#stop()
     */
    public void stop() throws Exception
    {


Mime
View raw message