Introduce a ConnectionManager.

Remove most references to Server.

Change-Id: I8888522d58ff4d332c4a477702442c29a82d12ff
Depends-On: Ic0e6e5f95adc30e773945c95e73d321d589503d2
Reviewed-on: http://gerrit.dmdirc.com/3872
Automatic-Compile: DMDirc Build Manager
Reviewed-by: Greg Holmes <greg@dmdirc.com>

src/com/dmdirc/ClientModule.java

 import com.dmdirc.config.InvalidIdentityFileException;
 import com.dmdirc.interfaces.ActionController;
 import com.dmdirc.interfaces.CommandController;
+import com.dmdirc.interfaces.ConnectionManager;
 import com.dmdirc.interfaces.LifecycleController;
-import com.dmdirc.interfaces.ServerFactory;
+import com.dmdirc.interfaces.ConnectionFactory;
 import com.dmdirc.interfaces.config.AggregateConfigProvider;
 import com.dmdirc.interfaces.config.ConfigProvider;
 import com.dmdirc.interfaces.config.IdentityController;
     /** The object graph to inject where necessary. */
     private ObjectGraph objectGraph;
 
+    @Provides
+    public ConnectionManager getConnectionManager(final ServerManager serverManager) {
+        return serverManager;
+    }
+
     @Provides
     @Singleton
     public DMDircMBassador getMBassador() {
     @Provides
     @Singleton
     public CommandManager getCommandManager(
-            final ServerManager serverManager,
+            final ConnectionManager connectionManager,
             @GlobalConfig final AggregateConfigProvider globalConfig) {
-        final CommandManager manager = new CommandManager(serverManager);
+        final CommandManager manager = new CommandManager(connectionManager);
         manager.initialise(globalConfig);
         return manager;
     }
     }
 
     @Provides
-    public ServerFactory getServerFactory(final ServerManager serverManager) {
-        return serverManager;
+    public ConnectionFactory getServerFactory(final ConnectionManager connectionManager) {
+        return connectionManager;
     }
 
     @Provides

src/com/dmdirc/Main.java

 import com.dmdirc.events.FeedbackNagEvent;
 import com.dmdirc.events.FirstRunEvent;
 import com.dmdirc.interfaces.CommandController.CommandDetails;
+import com.dmdirc.interfaces.ConnectionManager;
 import com.dmdirc.interfaces.Migrator;
 import com.dmdirc.interfaces.SystemLifecycleComponent;
 import com.dmdirc.interfaces.config.IdentityController;
     /** The identity manager the client will use. */
     private final IdentityController identityManager;
     /** The server manager the client will use. */
-    private final ServerManager serverManager;
+    private final ConnectionManager connectionManager;
     /** The action manager the client will use. */
     private final ActionManager actionManager;
     /** The command-line parser used for this instance. */
      * Creates a new instance of {@link Main}.
      *
      * @param identityManager        The identity manager the client will use.
-     * @param serverManager          The server manager the client will use.
+     * @param connectionManager          The server manager the client will use.
      * @param actionManager          The action manager the client will use.
      * @param commandLineParser      The command-line parser used for this instance.
      * @param pluginManager          The plugin manager the client will use.
     @Inject
     public Main(
             final IdentityController identityManager,
-            final ServerManager serverManager,
+            final ConnectionManager connectionManager,
             final ActionManager actionManager,
             final CommandLineParser commandLineParser,
             final PluginManager pluginManager,
             final DMDircMBassador eventBus,
             final Set<CommandDetails> commands) {
         this.identityManager = identityManager;
-        this.serverManager = serverManager;
+        this.connectionManager = connectionManager;
         this.actionManager = actionManager;
         this.commandLineParser = commandLineParser;
         this.pluginManager = pluginManager;
         actionManager.loadUserActions();
         eventBus.publishAsync(new ClientOpenedEvent());
 
-        commandLineParser.processArguments(serverManager);
+        commandLineParser.processArguments(connectionManager);
 
         globalWindowManager.init();
 
                 }
 
                 eventBus.publishAsync(new ClientClosedEvent());
-                serverManager.disconnectAll("Unexpected shutdown");
+                connectionManager.disconnectAll("Unexpected shutdown");
                 identityManager.saveAll();
             }
         }, "Shutdown thread"));

src/com/dmdirc/ServerManager.java

 import com.dmdirc.events.UserErrorEvent;
 import com.dmdirc.interfaces.CommandController;
 import com.dmdirc.interfaces.Connection;
-import com.dmdirc.interfaces.ServerFactory;
+import com.dmdirc.interfaces.ConnectionManager;
 import com.dmdirc.interfaces.config.ConfigProvider;
 import com.dmdirc.interfaces.config.ConfigProviderMigrator;
 import com.dmdirc.interfaces.config.IdentityController;
  * them.
  */
 @Singleton
-public class ServerManager implements ServerFactory {
+public class ServerManager implements ConnectionManager {
 
     /** All servers that currently exist. */
     private final Set<Server> servers = new CopyOnWriteArraySet<>();
         servers.remove(server);
     }
 
-    /**
-     * Returns a list of all servers.
-     *
-     * @return A list of all servers
-     */
-    public List<Connection> getServers() {
+    @Override
+    public List<Connection> getConnections() {
         return new ArrayList<Connection>(servers);
     }
 
-    /**
-     * Makes all servers disconnected with the specified quit message.
-     *
-     * @param message The quit message to send to the IRC servers
-     */
+    @Override
     public void disconnectAll(final String message) {
         for (Server server : servers) {
             server.disconnect(message);
         }
     }
 
-    /**
-     * Closes all servers with the specified quit message.
-     *
-     * @param message The quit message to send to the IRC servers
-     */
+    @Override
     public void closeAll(final String message) {
         for (Server server : servers) {
             server.disconnect(message);
         }
     }
 
-    /**
-     * Returns the number of servers that are registered with the manager.
-     *
-     * @return number of registered servers
-     */
-    public int numServers() {
+    @Override
+    public int getConnectionCount() {
         return servers.size();
     }
 
-    /**
-     * Retrieves a list of servers connected to the specified network.
-     *
-     * @param network The network to search for
-     *
-     * @return A list of servers connected to the network
-     */
-    public List<Connection> getServersByNetwork(final String network) {
+    @Override
+    public List<Connection> getConnectionsByNetwork(final String network) {
         final List<Connection> res = new ArrayList<>();
 
         for (Server server : servers) {
         return res;
     }
 
-    /**
-     * Creates a new server which will connect to the specified URI with the default profile.
-     *
-     * @param uri The URI to connect to
-     *
-     * @return The server which will be connecting
-     *
-     * @since 0.6.3
-     */
+    @Override
     public Connection connectToAddress(final URI uri) {
         return connectToAddress(uri,
                 identityController.getProvidersByType("profile").get(0));
     }
 
-    /**
-     * Creates a new server which will connect to the specified URI with the specified profile.
-     *
-     * @param uri     The URI to connect to
-     * @param profile The profile to use
-     *
-     * @return The server which will be connecting
-     *
-     * @since 0.6.3
-     */
-    public Server connectToAddress(final URI uri, final ConfigProvider profile) {
+    @Override
+    public Connection connectToAddress(final URI uri, final ConfigProvider profile) {
         checkArgument(profile.isProfile());
-        Server server = null;
+        Connection server = null;
 
         for (Server loopServer : servers) {
             if (loopServer.compareURI(uri)) {
         return server;
     }
 
-    /**
-     * Connects the user to Quakenet if necessary and joins #DMDirc.
-     */
+    @Override
     public void joinDevChat() {
-        final List<Connection> qnetServers = getServersByNetwork("Quakenet");
+        final List<Connection> qnetServers = getConnectionsByNetwork("Quakenet");
 
         Connection connectedServer = null;
 

src/com/dmdirc/SystemLifecycleController.java

 package com.dmdirc;
 
 import com.dmdirc.ClientModule.GlobalConfig;
+import com.dmdirc.interfaces.ConnectionManager;
 import com.dmdirc.interfaces.LifecycleController;
 import com.dmdirc.interfaces.config.AggregateConfigProvider;
 
     /** Controller to retrieve settings from. */
     private final AggregateConfigProvider configProvider;
     /** Manager to use to disconnect servers. */
-    private final ServerManager serverManager;
+    private final ConnectionManager connectionManager;
 
     @Inject
     public SystemLifecycleController(
             @GlobalConfig final AggregateConfigProvider configProvider,
-            final ServerManager serverManager) {
+            final ConnectionManager connectionManager) {
         this.configProvider = configProvider;
-        this.serverManager = serverManager;
+        this.connectionManager = connectionManager;
     }
 
     @Override
 
     @Override
     public void quit(final String reason, final int exitCode) {
-        serverManager.disconnectAll(reason);
+        connectionManager.disconnectAll(reason);
 
         System.exit(exitCode);
     }

src/com/dmdirc/commandline/CommandLineParser.java

 package com.dmdirc.commandline;
 
 import com.dmdirc.ClientModule.GlobalConfig;
-import com.dmdirc.ServerManager;
+import com.dmdirc.interfaces.ConnectionManager;
 import com.dmdirc.interfaces.config.AggregateConfigProvider;
 import com.dmdirc.logger.ErrorLevel;
 import com.dmdirc.logger.Logger;
     /** A list of addresses to autoconnect to. */
     private final List<URI> addresses = new ArrayList<>();
     /** Provider to use to get server managers. */
-    @Nullable private final Provider<ServerManager> serverManagerProvider;
+    @Nullable private final Provider<ConnectionManager> serverManagerProvider;
     /** Provider to use to get the global config. */
     @Nullable private final Provider<AggregateConfigProvider> globalConfigProvider;
     /** The parser to use for URIs. */
      */
     @Inject
     public CommandLineParser(
-            @Nullable final Provider<ServerManager> serverManagerProvider,
+            @Nullable final Provider<ConnectionManager> serverManagerProvider,
             @Nullable @GlobalConfig final Provider<AggregateConfigProvider> globalConfigProvider,
             @Nullable final URIParser uriParser) {
         this.serverManagerProvider = serverManagerProvider;
      * Processes arguments once the client has been loaded properly. This allows us to auto-connect
      * to servers, etc.
      *
-     * @param serverManager The server manager to use to connect servers.
+     * @param connectionManager The server manager to use to connect servers.
      */
-    public void processArguments(final ServerManager serverManager) {
+    public void processArguments(final ConnectionManager connectionManager) {
         for (URI address : addresses) {
-            serverManager.connectToAddress(address);
+            connectionManager.connectToAddress(address);
         }
     }
 

src/com/dmdirc/commandline/RemoteServer.java

 
 package com.dmdirc.commandline;
 
-import com.dmdirc.ServerManager;
+import com.dmdirc.interfaces.ConnectionManager;
 import com.dmdirc.logger.ErrorLevel;
 import com.dmdirc.logger.Logger;
 
     /** The maximum port to use for RMI binding. */
     private static final int MAXPORT = MINPORT + 5;
     /** Provider for the server manager to use to connect. */
-    private final Provider<ServerManager> serverManager;
+    private final Provider<ConnectionManager> serverManager;
 
     /**
      * Crate a new RemoteServer.
      *
      * @param serverManager Provider of a server manager to use to connect.
      */
-    public RemoteServer(final Provider<ServerManager> serverManager) {
+    public RemoteServer(final Provider<ConnectionManager> serverManager) {
         this.serverManager = serverManager;
     }
 

src/com/dmdirc/commandparser/CommandManager.java

 package com.dmdirc.commandparser;
 
 import com.dmdirc.Query;
-import com.dmdirc.ServerManager;
 import com.dmdirc.commandparser.commands.Command;
 import com.dmdirc.commandparser.parsers.CommandParser;
 import com.dmdirc.config.ConfigBinding;
 import com.dmdirc.interfaces.CommandController;
 import com.dmdirc.interfaces.Connection;
+import com.dmdirc.interfaces.ConnectionManager;
 import com.dmdirc.interfaces.config.AggregateConfigProvider;
 import com.dmdirc.ui.input.TabCompleter;
 import com.dmdirc.ui.input.TabCompletionType;
     /** A list of command parsers that have been instantiated. */
     private final MapList<CommandType, CommandParser> parsers = new MapList<>();
     /** The manager to use to iterate servers. */
-    private final ServerManager serverManager;
+    private final ConnectionManager connectionManager;
     /** The command char we're using. */
     @ConfigBinding(domain = "general", key = "commandchar")
     private char commandChar;
     /**
      * Creates a new instance of the Command Manager.
      *
-     * @param serverManager the manager to use to iterate servers.
+     * @param connectionManager the manager to use to iterate servers.
      */
-    public CommandManager(final ServerManager serverManager) {
-        this.serverManager = serverManager;
+    public CommandManager(final ConnectionManager connectionManager) {
+        this.connectionManager = connectionManager;
     }
 
     @Override
         final String commandName = getCommandChar() + command.getName();
 
         // TODO: This logic is probably in two places. Abstract it.
-        for (Connection server : serverManager.getServers()) {
+        for (Connection server : connectionManager.getConnections()) {
             if (command.getType() == CommandType.TYPE_SERVER
                     || command.getType() == CommandType.TYPE_GLOBAL) {
                 registerCommandName(server.getWindowModel().getTabCompleter(),

src/com/dmdirc/commandparser/commands/global/AllServers.java

 package com.dmdirc.commandparser.commands.global;
 
 import com.dmdirc.FrameContainer;
-import com.dmdirc.ServerManager;
 import com.dmdirc.commandparser.BaseCommandInfo;
 import com.dmdirc.commandparser.CommandArguments;
 import com.dmdirc.commandparser.CommandInfo;
 import com.dmdirc.commandparser.commands.context.CommandContext;
 import com.dmdirc.interfaces.CommandController;
 import com.dmdirc.interfaces.Connection;
+import com.dmdirc.interfaces.ConnectionManager;
 import com.dmdirc.ui.input.AdditionalTabTargets;
 import com.dmdirc.ui.input.TabCompleterUtils;
 
             "allservers <command> - executes the command as though it had"
             + " been entered on all servers", CommandType.TYPE_GLOBAL);
     /** Server manager to use to iterate servers. */
-    private final ServerManager serverManager;
+    private final ConnectionManager connectionManager;
 
     /**
      * Creates a new instance of the {@link AllServers} command.
      *
      * @param controller    The controller that owns this command.
-     * @param serverManager The server manager to use to iterate servers.
+     * @param connectionManager The server manager to use to iterate servers.
      */
     @Inject
-    public AllServers(final CommandController controller, final ServerManager serverManager) {
+    public AllServers(final CommandController controller, final ConnectionManager connectionManager) {
         super(controller);
-        this.serverManager = serverManager;
+        this.connectionManager = connectionManager;
     }
 
     @Override
             final CommandArguments args, final CommandContext context) {
         final String command = args.getArgumentsAsString();
 
-        for (Connection target : serverManager.getServers()) {
+        for (Connection target : connectionManager.getConnections()) {
             target.getWindowModel().getCommandParser()
                     .parseCommand(target.getWindowModel(), command);
         }

src/com/dmdirc/commandparser/commands/global/NewServer.java

 package com.dmdirc.commandparser.commands.global;
 
 import com.dmdirc.FrameContainer;
-import com.dmdirc.Server;
 import com.dmdirc.commandparser.BaseCommandInfo;
 import com.dmdirc.commandparser.CommandArguments;
 import com.dmdirc.commandparser.CommandInfo;
 import com.dmdirc.commandparser.commands.IntelligentCommand;
 import com.dmdirc.commandparser.commands.context.CommandContext;
 import com.dmdirc.interfaces.CommandController;
-import com.dmdirc.interfaces.ServerFactory;
+import com.dmdirc.interfaces.Connection;
+import com.dmdirc.interfaces.ConnectionFactory;
 import com.dmdirc.interfaces.config.IdentityController;
-import com.dmdirc.logger.ErrorLevel;
-import com.dmdirc.logger.Logger;
 import com.dmdirc.plugins.PluginManager;
 import com.dmdirc.plugins.Service;
 import com.dmdirc.ui.input.AdditionalTabTargets;
             "newserver <host[:[+]port]> [password] - connect to a new server",
             CommandType.TYPE_GLOBAL);
     /** The factory to use to construct servers. */
-    private final ServerFactory serverFactory;
+    private final ConnectionFactory connectionFactory;
     /** Plugin manager to query for available services. */
     private final PluginManager pluginManager;
     /** Identity controller to use to find profiles. */
      * Creates a new newserver command which will use the specified factory to construct servers.
      *
      * @param controller         The controller to use for command information.
-     * @param serverFactory      The factory to use to construct servers.
+     * @param connectionFactory      The factory to use to construct servers.
      * @param pluginManager      The plugin manager to use to query available services.
      * @param identityController Identity controller to use to find profiles.
      * @param uriParser          The parser to use for user input.
     @Inject
     public NewServer(
             final CommandController controller,
-            final ServerFactory serverFactory,
+            final ConnectionFactory connectionFactory,
             final PluginManager pluginManager,
             final IdentityController identityController,
             final URIParser uriParser) {
         super(controller);
-        this.serverFactory = serverFactory;
+        this.connectionFactory = connectionFactory;
         this.pluginManager = pluginManager;
         this.identityController = identityController;
         this.uriParser = uriParser;
 
         try {
             final URI address = uriParser.parseFromText(args.getArgumentsAsString());
-            final Server server = serverFactory.createServer(address,
+            final Connection server = connectionFactory.createServer(address,
                     identityController.getProvidersByType("profile").get(0));
             server.connect();
         } catch (InvalidURIException ex) {
-            if (origin == null) {
-                Logger.userError(ErrorLevel.LOW, "Invalid URI given to /newserver", ex);
-            } else {
-                origin.addLine(FORMAT_ERROR, "Invalid URI: " + ex.getMessage()
-                        + (ex.getCause() == null ? "" : ": " + ex.getCause().getMessage()));
-            }
+            origin.addLine(FORMAT_ERROR, "Invalid URI: " + ex.getMessage()
+                    + (ex.getCause() == null ? "" : ": " + ex.getCause().getMessage()));
         }
     }
 

src/com/dmdirc/interfaces/ServerFactory.java → src/com/dmdirc/interfaces/ConnectionFactory.java

 
 package com.dmdirc.interfaces;
 
-import com.dmdirc.Server;
 import com.dmdirc.interfaces.config.ConfigProvider;
 
 import java.net.URI;
 
 /**
- * Interface for factories which create new {@link Server}s.
+ * Interface for factories which create new {@link Connection}s.
  */
-public interface ServerFactory {
+public interface ConnectionFactory {
 
     /**
-     * Creates a new server which will connect to the specified URL with the specified profile.
+     * Creates a new connection which will connect to the specified URL with the specified profile.
      *
      * @param uri     The address of the server to connect to
      * @param profile The profile to use
      *
-     * @return A new {@link Server} instance with the appropriate configuration
+     * @return A new {@link Connection} instance with the appropriate configuration
      */
-    Server createServer(final URI uri, final ConfigProvider profile);
+    Connection createServer(final URI uri, final ConfigProvider profile);
 
 }

src/com/dmdirc/interfaces/ConnectionManager.java

+/*
+ * Copyright (c) 2006-2014 DMDirc Developers
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+
+package com.dmdirc.interfaces;
+
+import com.dmdirc.interfaces.config.ConfigProvider;
+
+import java.net.URI;
+import java.util.List;
+
+/**
+ * Manager of {@link Connection}s.
+ */
+public interface ConnectionManager extends ConnectionFactory {
+
+    /**
+     * Returns a list of all connections.
+     *
+     * @return A list of all connections
+     */
+    List<Connection> getConnections();
+
+    /**
+     * Makes all connections disconnect with the specified quit message.
+     *
+     * @param message The quit message to send to the connections
+     */
+    void disconnectAll(String message);
+
+    /**
+     * Closes all connections with the specified quit message.
+     *
+     * @param message The quit message to send to the IRC servers
+     */
+    void closeAll(String message);
+
+    /**
+     * Returns the number of connections that are registered with the manager.
+     *
+     * @return number of registered connections
+     */
+    int getConnectionCount();
+
+    /**
+     * Retrieves a list of connections connected to the specified network.
+     *
+     * @param network The network to search for
+     *
+     * @return A list of servers connected to the network
+     */
+    List<Connection> getConnectionsByNetwork(String network);
+
+    /**
+     * Creates a new connection which will connect to the specified URI with the default profile.
+     *
+     * @param uri The URI to connect to
+     *
+     * @return The new connection.
+     *
+     * @since 0.6.3
+     */
+    Connection connectToAddress(URI uri);
+
+    /**
+     * Creates a new connection which will connect to the specified URI with the specified profile.
+     *
+     * @param uri     The URI to connect to
+     * @param profile The profile to use
+     *
+     * @return The server which will be connecting
+     *
+     * @since 0.6.3
+     */
+    Connection connectToAddress(URI uri, ConfigProvider profile);
+
+    /**
+     * Connects the user to Quakenet if necessary and joins #DMDirc.
+     */
+    void joinDevChat();
+}

src/com/dmdirc/plugins/PluginInjectorInitialiser.java

 
 import com.dmdirc.ClientModule.GlobalConfig;
 import com.dmdirc.DMDircMBassador;
-import com.dmdirc.ServerManager;
 import com.dmdirc.actions.ActionFactory;
 import com.dmdirc.actions.ActionManager;
 import com.dmdirc.actions.ActionSubstitutorFactory;
 import com.dmdirc.actions.wrappers.PerformWrapper;
 import com.dmdirc.commandparser.CommandManager;
 import com.dmdirc.config.prefs.PreferencesManager;
+import com.dmdirc.interfaces.ConnectionManager;
 import com.dmdirc.interfaces.LifecycleController;
 import com.dmdirc.interfaces.config.IdentityController;
 import com.dmdirc.messages.MessageSinkManager;
     private final ActionFactory actionFactory;
     private final PluginManager pluginManager;
     private final IdentityController identityController;
-    private final ServerManager serverManager;
+    private final ConnectionManager connectionManager;
     private final ThemeManager themeManager;
     private final CommandManager commandManager;
     private final MessageSinkManager messageSinkManager;
             final ActionFactory actionFactory,
             final PluginManager pluginManager,
             final IdentityController identityController,
-            final ServerManager serverManager,
+            final ConnectionManager connectionManager,
             final ThemeManager themeManager,
             final CommandManager commandManager,
             final MessageSinkManager messageSinkManager,
         this.actionFactory = actionFactory;
         this.pluginManager = pluginManager;
         this.identityController = identityController;
-        this.serverManager = serverManager;
+        this.connectionManager = connectionManager;
         this.themeManager = themeManager;
         this.commandManager = commandManager;
         this.messageSinkManager = messageSinkManager;
         injector.addParameter(actionManager);
         injector.addParameter(PluginManager.class, pluginManager);
         injector.addParameter(identityController);
-        injector.addParameter(ServerManager.class, serverManager);
+        injector.addParameter(ConnectionManager.class, connectionManager);
         injector.addParameter(commandManager);
         injector.addParameter(MessageSinkManager.class, messageSinkManager);
         injector.addParameter(WindowManager.class, windowManager);

src/com/dmdirc/ui/core/feedback/CoreFeedbackDialogModel.java

 package com.dmdirc.ui.core.feedback;
 
 import com.dmdirc.ClientModule;
-import com.dmdirc.ServerManager;
 import com.dmdirc.commandline.CommandLineOptionsModule.Directory;
 import com.dmdirc.commandline.CommandLineOptionsModule.DirectoryType;
 import com.dmdirc.interfaces.Connection;
+import com.dmdirc.interfaces.ConnectionManager;
 import com.dmdirc.interfaces.config.AggregateConfigProvider;
 import com.dmdirc.interfaces.ui.FeedbackDialogModel;
 import com.dmdirc.interfaces.ui.FeedbackDialogModelListener;
     private final FeedbackSenderFactory feedbackSenderFactory;
     private final ListenerList listeners;
     private final AggregateConfigProvider config;
-    private final ServerManager serverManager;
+    private final ConnectionManager connectionManager;
     private final String configDirectory;
     private Optional<String> name;
     private Optional<String> email;
 
     @Inject
     public CoreFeedbackDialogModel(@ClientModule.GlobalConfig final AggregateConfigProvider config,
-            final ServerManager serverManager, final FeedbackSenderFactory feedbackSenderFactory,
+            final ConnectionManager connectionManager, final FeedbackSenderFactory feedbackSenderFactory,
             @Directory(DirectoryType.BASE) final String configDirectory) {
-        this.serverManager = serverManager;
+        this.connectionManager = connectionManager;
         this.configDirectory = configDirectory;
         this.feedbackSenderFactory = feedbackSenderFactory;
         this.config = config;
         final StringBuilder serverInfo = new StringBuilder(255);
         final StringBuilder dmdircInfo = new StringBuilder(255);
         if (getIncludeServerInfo()) {
-            for (Connection connection : serverManager.getServers()) {
+            for (Connection connection : connectionManager.getConnections()) {
                 if (connection.getState().isDisconnected()) {
                     continue;
                 }

src/com/dmdirc/ui/core/newserver/CoreNewServerDialogModel.java

 
 import com.dmdirc.ClientModule.GlobalConfig;
 import com.dmdirc.ClientModule.UserConfig;
-import com.dmdirc.ServerManager;
+import com.dmdirc.interfaces.ConnectionManager;
 import com.dmdirc.interfaces.config.AggregateConfigProvider;
 import com.dmdirc.interfaces.config.ConfigProvider;
 import com.dmdirc.interfaces.config.ConfigProviderListener;
     private final ListenerList listeners;
     private final AggregateConfigProvider globalConfig;
     private final ConfigProvider userConfig;
-    private final ServerManager serverManager;
+    private final ConnectionManager connectionManager;
     private final IdentityController controller;
     private final List<ConfigProvider> profiles;
     private Optional<ConfigProvider> selectedProfile;
             @GlobalConfig final AggregateConfigProvider globalConfig,
             @UserConfig final ConfigProvider userConfig,
             final IdentityController identityController,
-            final ServerManager serverManager) {
+            final ConnectionManager connectionManager) {
         this.globalConfig = globalConfig;
         this.userConfig = userConfig;
         this.controller = identityController;
-        this.serverManager = serverManager;
+        this.connectionManager = connectionManager;
         listeners = new ListenerList();
         profiles = new ArrayList<>(5);
         selectedProfile = Optional.absent();
         }
         try {
             if (selectedProfile.isPresent()) {
-                serverManager.connectToAddress(getServerURI(), selectedProfile.get());
+                connectionManager.connectToAddress(getServerURI(), selectedProfile.get());
             } else {
-                serverManager.connectToAddress(getServerURI());
+                connectionManager.connectToAddress(getServerURI());
             }
         } catch (URISyntaxException ex) {
             //This is tested in isSaveAllowed, shouldn't happen here.

src/com/dmdirc/ui/core/util/URLHandler.java

 package com.dmdirc.ui.core.util;
 
 import com.dmdirc.DMDircMBassador;
-import com.dmdirc.ServerManager;
 import com.dmdirc.events.UnknownURLEvent;
 import com.dmdirc.events.UserErrorEvent;
+import com.dmdirc.interfaces.ConnectionManager;
 import com.dmdirc.interfaces.config.AggregateConfigProvider;
 import com.dmdirc.logger.ErrorLevel;
 import com.dmdirc.ui.StatusMessage;
     /** Config manager. */
     private final AggregateConfigProvider config;
     /** Server manager to use to connect to servers. */
-    private final ServerManager serverManager;
+    private final ConnectionManager connectionManager;
     /** Status bar manager to use to show messages. */
     private final StatusBarManager statusBarManager;
     /** Desktop handler. */
      *
      * @param eventBus         Event bus to fire unknown protocol errors on.
      * @param globalConfig     Config to retrieve settings from
-     * @param serverManager    Server manager to connect to servers
+     * @param connectionManager    Server manager to connect to servers
      * @param statusBarManager Status bar manager used to show messages
      */
     @Inject
     public URLHandler(
             final DMDircMBassador eventBus,
             final AggregateConfigProvider globalConfig,
-            final ServerManager serverManager,
+            final ConnectionManager connectionManager,
             final StatusBarManager statusBarManager) {
         this.eventBus = eventBus;
         this.config = globalConfig;
-        this.serverManager = serverManager;
+        this.connectionManager = connectionManager;
         this.statusBarManager = statusBarManager;
         this.desktop = Desktop.isDesktopSupported() ? Desktop.getDesktop() : null;
     }
                 statusBarManager.setMessage(
                         new StatusMessage("Connecting to: " + uri.toString(),
                                 config));
-                serverManager.connectToAddress(uri);
+                connectionManager.connectToAddress(uri);
                 break;
             case "BROWSER":
                 statusBarManager.setMessage(

test/com/dmdirc/ServerManagerTest.java

     @Test
     public void testRegisterServer() {
         serverManager.registerServer(server);
-        assertEquals(1, serverManager.numServers());
+        assertEquals(1, serverManager.getConnectionCount());
     }
 
     @Test
     public void testUnregisterServer() {
         serverManager.registerServer(server);
         serverManager.unregisterServer(server);
-        assertEquals(0, serverManager.numServers());
+        assertEquals(0, serverManager.getConnectionCount());
     }
 
     @Test
     public void testNumServers() {
-        assertEquals(serverManager.getServers().size(), serverManager.numServers());
+        assertEquals(serverManager.getConnections().size(), serverManager.getConnectionCount());
         serverManager.registerServer(server);
-        assertEquals(serverManager.getServers().size(), serverManager.numServers());
+        assertEquals(serverManager.getConnections().size(), serverManager.getConnectionCount());
         serverManager.unregisterServer(server);
-        assertEquals(serverManager.getServers().size(), serverManager.numServers());
+        assertEquals(serverManager.getConnections().size(), serverManager.getConnectionCount());
     }
 
     @Test
         serverManager.registerServer(serverB);
         serverManager.registerServer(serverC);
 
-        assertEquals(1, serverManager.getServersByNetwork("Net1").size());
-        assertEquals(serverA, serverManager.getServersByNetwork("Net1").get(0));
+        assertEquals(1, serverManager.getConnectionsByNetwork("Net1").size());
+        assertEquals(serverA, serverManager.getConnectionsByNetwork("Net1").get(0));
 
-        assertEquals(2, serverManager.getServersByNetwork("Net2").size());
-        assertEquals(serverB, serverManager.getServersByNetwork("Net2").get(0));
-        assertEquals(serverC, serverManager.getServersByNetwork("Net2").get(1));
+        assertEquals(2, serverManager.getConnectionsByNetwork("Net2").size());
+        assertEquals(serverB, serverManager.getConnectionsByNetwork("Net2").get(0));
+        assertEquals(serverC, serverManager.getConnectionsByNetwork("Net2").get(1));
 
-        assertEquals(0, serverManager.getServersByNetwork("Net3").size());
+        assertEquals(0, serverManager.getConnectionsByNetwork("Net3").size());
     }
 
     @Test
 
         serverManager.joinDevChat();
 
-        assertEquals(3, serverManager.numServers());
+        assertEquals(3, serverManager.getConnectionCount());
 
         URI serverUri = uriCaptor.getValue();
         assertEquals("irc", serverUri.getScheme());

test/com/dmdirc/WritableFrameContainerTest.java

 import com.dmdirc.commandparser.CommandManager;
 import com.dmdirc.config.ConfigBinder;
 import com.dmdirc.harness.TestWritableFrameContainer;
+import com.dmdirc.interfaces.ConnectionManager;
 import com.dmdirc.interfaces.config.AggregateConfigProvider;
 import com.dmdirc.messages.MessageSinkManager;
 import com.dmdirc.util.URLBuilder;
 public class WritableFrameContainerTest {
 
     @Mock private AggregateConfigProvider acp;
-    @Mock private ServerManager serverManager;
+    @Mock private ConnectionManager connectionManager;
     @Mock private MessageSinkManager messageSinkManager;
     @Mock private URLBuilder urlBuilder;
     @Mock private DMDircMBassador eventBus;
         when(acp.getOption("general", "commandchar")).thenReturn("/");
         final ConfigBinder binder = new ConfigBinder(acp);
         when(acp.getBinder()).thenReturn(binder);
-        commands = new CommandManager(serverManager);
+        commands = new CommandManager(connectionManager);
         commands.initialise(acp);
     }
 

test/com/dmdirc/commandparser/commands/global/NewServerTest.java

 import com.dmdirc.commandparser.CommandArguments;
 import com.dmdirc.commandparser.commands.context.CommandContext;
 import com.dmdirc.interfaces.CommandController;
-import com.dmdirc.interfaces.ServerFactory;
+import com.dmdirc.interfaces.ConnectionFactory;
 import com.dmdirc.interfaces.config.ConfigProvider;
 import com.dmdirc.interfaces.config.IdentityController;
 import com.dmdirc.plugins.PluginManager;
     @Mock private ConfigProvider identity;
     @Mock private FrameContainer container;
     @Mock private PluginManager pluginManager;
-    @Mock private ServerFactory factory;
+    @Mock private ConnectionFactory factory;
     @Mock private Server server;
     private NewServer command;
 

test/com/dmdirc/ui/core/feedback/CoreFeedbackDialogModelTest.java

 
 package com.dmdirc.ui.core.feedback;
 
-import com.dmdirc.ServerManager;
+import com.dmdirc.interfaces.ConnectionManager;
 import com.dmdirc.interfaces.config.AggregateConfigProvider;
 import com.dmdirc.interfaces.ui.FeedbackDialogModelListener;
 
 public class CoreFeedbackDialogModelTest {
 
     @Mock private AggregateConfigProvider config;
-    @Mock private ServerManager serverManager;
+    @Mock private ConnectionManager connectionManager;
     @Mock private FeedbackSenderFactory feedbackSenderFactory;
     @Mock private FeedbackDialogModelListener listener;
     private final String name = "Bob Dole";
 
     @Test
     public void testName() {
-        final CoreFeedbackDialogModel instance = new CoreFeedbackDialogModel(config, serverManager,
+        final CoreFeedbackDialogModel instance = new CoreFeedbackDialogModel(config,
+                connectionManager,
                 feedbackSenderFactory, "configDirectory");
         assertEquals("testName", Optional.absent(), instance.getName());
         instance.setName(Optional.fromNullable(name));
 
     @Test
     public void testEmail() {
-        final CoreFeedbackDialogModel instance = new CoreFeedbackDialogModel(config, serverManager,
+        final CoreFeedbackDialogModel instance = new CoreFeedbackDialogModel(config,
+                connectionManager,
                 feedbackSenderFactory, "configDirectory");
         assertEquals("testEmail", Optional.absent(), instance.getEmail());
         instance.setEmail(Optional.fromNullable(email));
 
     @Test
     public void testFeedback() {
-        final CoreFeedbackDialogModel instance = new CoreFeedbackDialogModel(config, serverManager,
+        final CoreFeedbackDialogModel instance = new CoreFeedbackDialogModel(config,
+                connectionManager,
                 feedbackSenderFactory, "configDirectory");
         assertEquals("testFeedback", Optional.absent(), instance.getFeedback());
         instance.setFeedback(Optional.fromNullable(feedback));
 
     @Test
     public void testServerInfo() {
-        final CoreFeedbackDialogModel instance = new CoreFeedbackDialogModel(config, serverManager,
+        final CoreFeedbackDialogModel instance = new CoreFeedbackDialogModel(config,
+                connectionManager,
                 feedbackSenderFactory, "configDirectory");
         assertEquals("testServerInfo", false, instance.getIncludeServerInfo());
         instance.setIncludeServerInfo(true);
 
     @Test
     public void testDMDircInfo() {
-        final CoreFeedbackDialogModel instance = new CoreFeedbackDialogModel(config, serverManager,
+        final CoreFeedbackDialogModel instance = new CoreFeedbackDialogModel(config,
+                connectionManager,
                 feedbackSenderFactory, "configDirectory");
         assertEquals("testDMDircInfo", false, instance.getIncludeDMDircInfo());
         instance.setIncludeDMDircInfo(true);
 
     @Test
     public void testNameListener() {
-        final CoreFeedbackDialogModel instance = new CoreFeedbackDialogModel(config, serverManager,
+        final CoreFeedbackDialogModel instance = new CoreFeedbackDialogModel(config,
+                connectionManager,
                 feedbackSenderFactory, "configDirectory");
         instance.addListener(listener);
         instance.setName(Optional.fromNullable("Bob Dole"));
 
     @Test
     public void testEmailListener() {
-        final CoreFeedbackDialogModel instance = new CoreFeedbackDialogModel(config, serverManager,
+        final CoreFeedbackDialogModel instance = new CoreFeedbackDialogModel(config,
+                connectionManager,
                 feedbackSenderFactory, "configDirectory");
         instance.addListener(listener);
         instance.setEmail(Optional.fromNullable("bob@dole.com"));
 
     @Test
     public void testFeedbackListener() {
-        final CoreFeedbackDialogModel instance = new CoreFeedbackDialogModel(config, serverManager,
+        final CoreFeedbackDialogModel instance = new CoreFeedbackDialogModel(config,
+                connectionManager,
                 feedbackSenderFactory, "configDirectory");
         instance.addListener(listener);
         instance.setFeedback(Optional.fromNullable("DMDirc Rocks."));
 
     @Test
     public void testServerInfoListener() {
-        final CoreFeedbackDialogModel instance = new CoreFeedbackDialogModel(config, serverManager,
+        final CoreFeedbackDialogModel instance = new CoreFeedbackDialogModel(config,
+                connectionManager,
                 feedbackSenderFactory, "configDirectory");
         instance.addListener(listener);
         instance.setIncludeServerInfo(true);
 
     @Test
     public void testDMDircInfoListener() {
-        final CoreFeedbackDialogModel instance = new CoreFeedbackDialogModel(config, serverManager,
+        final CoreFeedbackDialogModel instance = new CoreFeedbackDialogModel(config,
+                connectionManager,
                 feedbackSenderFactory, "configDirectory");
         instance.addListener(listener);
         instance.setIncludeDMDircInfo(true);

test/com/dmdirc/ui/core/newserver/CoreNewServerDialogModelTest.java

 
 package com.dmdirc.ui.core.newserver;
 
-import com.dmdirc.ServerManager;
+import com.dmdirc.interfaces.ConnectionManager;
 import com.dmdirc.interfaces.config.AggregateConfigProvider;
 import com.dmdirc.interfaces.config.ConfigProvider;
 import com.dmdirc.interfaces.config.IdentityController;
     @Mock private AggregateConfigProvider globalConfig;
     @Mock private ConfigProvider userConfig;
     @Mock private IdentityController controller;
-    @Mock private ServerManager serverManager;
+    @Mock private ConnectionManager connectionManager;
     @Mock private ConfigProvider profile1;
     @Mock private ConfigProvider profile2;
     @Mock private NewServerDialogModelListener listener;
     @Test
     public void testGetProfiles() {
         CoreNewServerDialogModel instance = new CoreNewServerDialogModel(globalConfig, userConfig,
-                controller, serverManager);
+                controller, connectionManager);
         instance.loadModel();
         assertEquals("loadModel: ", Lists.newArrayList(profile1, profile2), instance.
                 getProfileList());
     @Test
     public void testSelectedProfile() {
         CoreNewServerDialogModel instance = new CoreNewServerDialogModel(globalConfig, userConfig,
-                controller, serverManager);
+                controller, connectionManager);
         instance.loadModel();
         assertEquals("testSelectedProfile: ", Optional.absent(), instance.getSelectedProfile());
         instance.setSelectedProfile(Optional.fromNullable(profile1));
         when(controller.getProvidersByType("profile")).thenReturn(
                 Lists.<ConfigProvider>newArrayList());
         CoreNewServerDialogModel instance = new CoreNewServerDialogModel(globalConfig, userConfig,
-                controller, serverManager);
+                controller, connectionManager);
         instance.loadModel();
         assertFalse("testProfileValidatorEmpty: ", instance.isProfileListValid());
     }
         when(controller.getProvidersByType("profile")).thenReturn(
                 Lists.newArrayList(profile1, profile2));
         CoreNewServerDialogModel instance = new CoreNewServerDialogModel(globalConfig, userConfig,
-                controller, serverManager);
+                controller, connectionManager);
         instance.loadModel();
         assertTrue("testProfileValidatorNotEmpty: ", instance.isProfileListValid());
     }
     @Test
     public void testHostname() {
         CoreNewServerDialogModel instance = new CoreNewServerDialogModel(globalConfig, userConfig,
-                controller, serverManager);
+                controller, connectionManager);
         instance.loadModel();
         assertEquals("testHostname: ", Optional.fromNullable("hostname"), instance.getHostname());
         instance.setHostname(Optional.fromNullable("test"));
     public void testHostnameValidatorValid() {
         when(globalConfig.getOption("newserver", "hostname")).thenReturn("hostname");
         CoreNewServerDialogModel instance = new CoreNewServerDialogModel(globalConfig, userConfig,
-                controller, serverManager);
+                controller, connectionManager);
         instance.loadModel();
         assertTrue("testHostnameValidatorValid: ", instance.isHostnameValid());
     }
     public void testHostnameValidatorInvalid() {
         when(globalConfig.getOption("newserver", "hostname")).thenReturn("~!£$^£$%^&");
         CoreNewServerDialogModel instance = new CoreNewServerDialogModel(globalConfig, userConfig,
-                controller, serverManager);
+                controller, connectionManager);
         instance.loadModel();
         assertFalse("testHostnameValidatorInvalid: ", instance.isHostnameValid());
     }
     @Test
     public void testPort() {
         CoreNewServerDialogModel instance = new CoreNewServerDialogModel(globalConfig, userConfig,
-                controller, serverManager);
+                controller, connectionManager);
         instance.loadModel();
         assertEquals("testPort: ", Optional.fromNullable(1111), instance.getPort());
         instance.setPort(Optional.fromNullable(5678));
     public void testPortValidatorValid() {
         when(globalConfig.getOptionInt("newserver", "port")).thenReturn(1111);
         CoreNewServerDialogModel instance = new CoreNewServerDialogModel(globalConfig, userConfig,
-                controller, serverManager);
+                controller, connectionManager);
         instance.loadModel();
         assertTrue("testPortValidatorValid: ", instance.isPortValid());
     }
     public void testPortValidatorTooLow() {
         when(globalConfig.getOptionInt("newserver", "port")).thenReturn(-1);
         CoreNewServerDialogModel instance = new CoreNewServerDialogModel(globalConfig, userConfig,
-                controller, serverManager);
+                controller, connectionManager);
         instance.loadModel();
         assertFalse("testPortValidatorTooLow: ", instance.isPortValid());
     }
     public void testPortValidatorTooHigh() {
         when(globalConfig.getOptionInt("newserver", "port")).thenReturn(65536);
         CoreNewServerDialogModel instance = new CoreNewServerDialogModel(globalConfig, userConfig,
-                controller, serverManager);
+                controller, connectionManager);
         instance.loadModel();
         assertFalse("testPortValidatorTooHigh: ", instance.isPortValid());
     }
     @Test
     public void testPassword() {
         CoreNewServerDialogModel instance = new CoreNewServerDialogModel(globalConfig, userConfig,
-                controller, serverManager);
+                controller, connectionManager);
         instance.loadModel();
         assertEquals("testPassword: ", Optional.fromNullable("password"), instance.getPassword());
         instance.setPassword(Optional.fromNullable("test"));
     public void testPasswordValidatorValid() {
         when(globalConfig.getOption("newserver", "password")).thenReturn("password");
         CoreNewServerDialogModel instance = new CoreNewServerDialogModel(globalConfig, userConfig,
-                controller, serverManager);
+                controller, connectionManager);
         instance.loadModel();
         assertTrue("testPasswordValidatorValid: ", instance.isPortValid());
     }
     @Test
     public void testSSL() {
         CoreNewServerDialogModel instance = new CoreNewServerDialogModel(globalConfig, userConfig,
-                controller, serverManager);
+                controller, connectionManager);
         instance.loadModel();
         assertTrue("testSSL: ", instance.getSSL());
         instance.setSSL(false);
     @Test
     public void testSaveAsDefault() {
         CoreNewServerDialogModel instance = new CoreNewServerDialogModel(globalConfig, userConfig,
-                controller, serverManager);
+                controller, connectionManager);
         instance.loadModel();
         assertFalse("testSaveAsDefault:", instance.getSaveAsDefault());
         instance.setSaveAsDefault(true);
     public void testIsSaveAllowedValid() {
         when(globalConfig.getOption("newserver", "hostname")).thenReturn("hostname");
         CoreNewServerDialogModel instance = new CoreNewServerDialogModel(globalConfig, userConfig,
-                controller, serverManager);
+                controller, connectionManager);
         instance.loadModel();
         assertTrue("testIsSaveAllowedValid: ", instance.isSaveAllowed());
     }
     public void testIsSaveAllowedInvalidHostname() {
         when(globalConfig.getOption("newserver", "hostname")).thenReturn("~!£$^£$%^&");
         CoreNewServerDialogModel instance = new CoreNewServerDialogModel(globalConfig, userConfig,
-                controller, serverManager);
+                controller, connectionManager);
         instance.loadModel();
         assertFalse("testIsSaveAllowedInvalidHostname: ", instance.isSaveAllowed());
     }
     public void testIsSaveAllowedInvalidPort() {
         when(globalConfig.getOption("newserver", "hostname")).thenReturn("-1");
         CoreNewServerDialogModel instance = new CoreNewServerDialogModel(globalConfig, userConfig,
-                controller, serverManager);
+                controller, connectionManager);
         instance.loadModel();
         assertFalse("testIsSaveAllowedInvalidPort: ", instance.isSaveAllowed());
     }
     @Test
     public void testSaveSaveDefaults() {
         CoreNewServerDialogModel instance = new CoreNewServerDialogModel(globalConfig, userConfig,
-                controller, serverManager);
+                controller, connectionManager);
         instance.loadModel();
         instance.setSaveAsDefault(true);
         instance.save();
     @Test
     public void testSaveNotDefaults() {
         CoreNewServerDialogModel instance = new CoreNewServerDialogModel(globalConfig, userConfig,
-                controller, serverManager);
+                controller, connectionManager);
         instance.loadModel();
         instance.setSaveAsDefault(false);
         instance.save();
     @Test
     public void testSaveConnectWithoutProfile() throws URISyntaxException {
         CoreNewServerDialogModel instance = new CoreNewServerDialogModel(globalConfig, userConfig,
-                controller, serverManager);
+                controller, connectionManager);
         instance.loadModel();
         instance.save();
-        verify(serverManager).connectToAddress(new URI("ircs://password@hostname:1111"));
-        verify(serverManager, never()).connectToAddress(any(URI.class), any(ConfigProvider.class));
+        verify(connectionManager).connectToAddress(new URI("ircs://password@hostname:1111"));
+        verify(connectionManager, never()).connectToAddress(any(URI.class), any(ConfigProvider.class));
     }
 
     @Test
     public void testSaveConnectWithProfile() throws URISyntaxException {
         CoreNewServerDialogModel instance = new CoreNewServerDialogModel(globalConfig, userConfig,
-                controller, serverManager);
+                controller, connectionManager);
         instance.loadModel();
         instance.setSelectedProfile(Optional.fromNullable(profile1));
         instance.save();
-        verify(serverManager, never()).connectToAddress(any(URI.class));
-        verify(serverManager).connectToAddress(new URI("ircs://password@hostname:1111"), profile1);
+        verify(connectionManager, never()).connectToAddress(any(URI.class));
+        verify(connectionManager).connectToAddress(new URI("ircs://password@hostname:1111"), profile1);
     }
 
     @Test
     public void testAddConfigProvider() {
         when(controller.getProvidersByType("profile")).thenReturn(Lists.newArrayList(profile1));
         CoreNewServerDialogModel instance = new CoreNewServerDialogModel(globalConfig, userConfig,
-                controller, serverManager);
+                controller, connectionManager);
         instance.loadModel();
         assertEquals("testAddConfigProvider:", Lists.newArrayList(profile1),
                 instance.getProfileList());
         when(controller.getProvidersByType("profile")).thenReturn(
                 Lists.newArrayList(profile1, profile2));
         CoreNewServerDialogModel instance = new CoreNewServerDialogModel(globalConfig, userConfig,
-                controller, serverManager);
+                controller, connectionManager);
         instance.loadModel();
         assertEquals("testRemoveConfigProvider:", Lists.newArrayList(profile1, profile2),
                 instance.getProfileList());
         when(controller.getProvidersByType("profile")).thenReturn(
                 Lists.newArrayList(profile1, profile2));
         CoreNewServerDialogModel instance = new CoreNewServerDialogModel(globalConfig, userConfig,
-                controller, serverManager);
+                controller, connectionManager);
         instance.loadModel();
         instance.setSelectedProfile(Optional.fromNullable(profile2));
         assertEquals("testRemoveConfigProviderSelectedProfile:",
     @Test
     public void testListenerSelectedProfileChanged() {
         CoreNewServerDialogModel instance = new CoreNewServerDialogModel(globalConfig, userConfig,
-                controller, serverManager);
+                controller, connectionManager);
         instance.loadModel();
         assertEquals("testListenerSelectedProfileChanged: ", Optional.<ConfigProvider>absent(),
                 instance.getSelectedProfile());
     @Test
     public void testListenerProfileListChangedRemoved() {
         CoreNewServerDialogModel instance = new CoreNewServerDialogModel(globalConfig, userConfig,
-                controller, serverManager);
+                controller, connectionManager);
         instance.loadModel();
         instance.addListener(listener);
         assertEquals("testListenerProfileListChangedRemoved: ",
         when(controller.getProvidersByType("profile"))
                 .thenReturn(Lists.newArrayList(profile1));
         CoreNewServerDialogModel instance = new CoreNewServerDialogModel(globalConfig, userConfig,
-                controller, serverManager);
+                controller, connectionManager);
         instance.loadModel();
         instance.addListener(listener);
         assertEquals("testListenerProfileListChangedAdded: ", Lists.newArrayList(profile1),
     @Test
     public void testListenerServerDetailsChangedPort() {
         CoreNewServerDialogModel instance = new CoreNewServerDialogModel(globalConfig, userConfig,
-                controller, serverManager);
+                controller, connectionManager);
         instance.loadModel();
         instance.addListener(listener);
         instance.setPort(Optional.fromNullable(9999));
     @Test
     public void testListenerServerDetailsChangedPassword() {
         CoreNewServerDialogModel instance = new CoreNewServerDialogModel(globalConfig, userConfig,
-                controller, serverManager);
+                controller, connectionManager);
         instance.loadModel();
         instance.addListener(listener);
         instance.setPassword(Optional.fromNullable("password-test"));
     @Test
     public void testListenerServerDetailsChangedSSL() {
         CoreNewServerDialogModel instance = new CoreNewServerDialogModel(globalConfig, userConfig,
-                controller, serverManager);
+                controller, connectionManager);
         instance.loadModel();
         instance.addListener(listener);
         instance.setSSL(false);
     @Test
     public void testListenerServerDetailsChangedSaveAsDefault() {
         CoreNewServerDialogModel instance = new CoreNewServerDialogModel(globalConfig, userConfig,
-                controller, serverManager);
+                controller, connectionManager);
         instance.loadModel();
         instance.addListener(listener);
         instance.setSaveAsDefault(true);
     @Test
     public void testRemoveListener() {
         CoreNewServerDialogModel instance = new CoreNewServerDialogModel(globalConfig, userConfig,
-                controller, serverManager);
+                controller, connectionManager);
         instance.loadModel();
         instance.addListener(listener);
         instance.setSaveAsDefault(true);
     @Test
     public void testSaveDefaults() throws URISyntaxException {
         CoreNewServerDialogModel instance = new CoreNewServerDialogModel(globalConfig, userConfig,
-                controller, serverManager);
+                controller, connectionManager);
         instance.loadModel();
         instance.setSelectedProfile(Optional.fromNullable(profile1));
         instance.setSaveAsDefault(true);
     @Test
     public void testNoSaveDefaults() throws URISyntaxException {
         CoreNewServerDialogModel instance = new CoreNewServerDialogModel(globalConfig, userConfig,
-                controller, serverManager);
+                controller, connectionManager);
         instance.loadModel();
         instance.setSelectedProfile(Optional.fromNullable(profile1));
         instance.setSaveAsDefault(false);