ckaczor/sqltoolsservice
1
0
Fork 0
mirror of https://github.com/ckaczor/sqltoolsservice.git synced 2026-01-25 17:24:17 -05:00
Code Issues Packages Projects Releases Wiki Activity

Per editor Connect support v0.1

Browse Source 
- Basic plumbing to support connections for a URI rather than global connections. Typical use case is editor requests to connect, but this isn't the only possible use
- Tests pass but need updating to cover new functionality, and re-enable AutoCompleteService test once there is a ServiceDiscovery component that registers and returns services. This is necessary as .Instance won't allow for dependency injection and proper testing.
This commit is contained in:
Kevin Cunnane
2016-08-02 18:55:25 -07:00
committed by Mitchell Sternke
parent d191b0483c
commit 402e25f77d
13 changed files with 645 additions and 244 deletions
Download Patch File Download Diff File Expand all files Collapse all files

165
src/Microsoft.SqlTools.ServiceLayer/Connection/ConnectionService.cs
View File

@@ -17,13 +17,45 @@ using Microsoft.SqlTools.ServiceLayer.Workspace;
namespace Microsoft.SqlTools.ServiceLayer.Connection
{
public class ConnectionInfo
{
public ConnectionInfo(ISqlConnectionFactory factory, string ownerUri, ConnectionDetails details)
{
Factory = factory;
OwnerUri = ownerUri;
ConnectionDetails = details;
ConnectionId = Guid.NewGuid();
}
/// <summary>
/// Unique Id, helpful to identify a connection info object
/// </summary>
public Guid ConnectionId { get; private set; }
public string OwnerUri { get; private set; }
private ISqlConnectionFactory Factory {get; set;}
public ConnectionDetails ConnectionDetails { get; private set; }
public DbConnection SqlConnection { get; private set; }
public void OpenConnection()
{
// build the connection string from the input parameters
string connectionString = ConnectionService.BuildConnectionString(ConnectionDetails);
// create a sql connection instance
SqlConnection = Factory.CreateSqlConnection(connectionString);
SqlConnection.Open();
}
}
/// <summary>
/// Main class for the Connection Management services
/// </summary>
public class ConnectionService
{
#region Singleton Instance Implementation
/// <summary>
/// Singleton service instance
/// </summary>
@@ -40,6 +72,13 @@ namespace Microsoft.SqlTools.ServiceLayer.Connection
return instance.Value;
}
}
/// <summary>
/// The SQL connection factory object
/// </summary>
private ISqlConnectionFactory connectionFactory;
private Dictionary<string, ConnectionInfo> ownerToConnectionMap = new Dictionary<string, ConnectionInfo>();
/// <summary>
/// Default constructor is private since it's a singleton class
@@ -48,48 +87,16 @@ namespace Microsoft.SqlTools.ServiceLayer.Connection
{
}
#endregion
#region Properties
/// <summary>
/// The SQL connection factory object
/// </summary>
private ISqlConnectionFactory connectionFactory;
/// <summary>
/// The current connection id that was previously used
/// </summary>
private int maxConnectionId = 0;
/// <summary>
/// Active connections lazy dictionary instance
/// </summary>
private readonly Lazy<Dictionary<int, DbConnection>> activeConnections
= new Lazy<Dictionary<int, DbConnection>>(()
=> new Dictionary<int, DbConnection>());
/// <summary>
/// Callback for onconnection handler
/// </summary>
/// <param name="sqlConnection"></param>
public delegate Task OnConnectionHandler(DbConnection sqlConnection);
public delegate Task OnConnectionHandler(ConnectionInfo info);
/// <summary>
/// List of onconnection handlers
/// </summary>
private readonly List<OnConnectionHandler> onConnectionActivities = new List<OnConnectionHandler>();
/// <summary>
/// Gets the active connection map
/// </summary>
public Dictionary<int, DbConnection> ActiveConnections
{
get
{
return activeConnections.Value;
}
}
private readonly List<OnConnectionHandler> onConnectionActivities = new List<OnConnectionHandler>();
/// <summary>
/// Gets the SQL connection factory instance
@@ -105,9 +112,7 @@ namespace Microsoft.SqlTools.ServiceLayer.Connection
return this.connectionFactory;
}
}
#endregion
/// <summary>
/// Test constructor that injects dependency interfaces
/// </summary>
@@ -117,40 +122,62 @@ namespace Microsoft.SqlTools.ServiceLayer.Connection
this.connectionFactory = testFactory;
}
#region Public Methods
// Attempts to link a URI to an actively used connection for this URI
public bool TryFindConnection(string ownerUri, out ConnectionSummary connectionSummary)
{
connectionSummary = null;
ConnectionInfo connectionInfo;
if (this.ownerToConnectionMap.TryGetValue(ownerUri, out connectionInfo))
{
connectionSummary = CopySummary(connectionInfo.ConnectionDetails);
return true;
}
return false;
}
private static ConnectionSummary CopySummary(ConnectionSummary summary)
{
return new ConnectionSummary()
{
ServerName = summary.ServerName,
DatabaseName = summary.DatabaseName,
UserName = summary.UserName
};
}
/// <summary>
/// Open a connection with the specified connection details
/// </summary>
/// <param name="connectionDetails"></param>
public ConnectionResult Connect(ConnectionDetails connectionDetails)
/// <param name="connectionParams"></param>
public ConnectResponse Connect(ConnectParams connectionParams)
{
// build the connection string from the input parameters
string connectionString = BuildConnectionString(connectionDetails);
ConnectionInfo connectionInfo;
if (ownerToConnectionMap.TryGetValue(connectionParams.OwnerUri, out connectionInfo) )
{
// TODO disconnect
}
connectionInfo = new ConnectionInfo(this.connectionFactory, connectionParams.OwnerUri, connectionParams.Connection);
// create a sql connection instance
DbConnection connection = this.ConnectionFactory.CreateSqlConnection(connectionString);
// try to connect
connectionInfo.OpenConnection();
// TODO: check that connection worked
// open the database
connection.Open();
// map the connection id to the connection object for future lookups
this.ActiveConnections.Add(++maxConnectionId, connection);
ownerToConnectionMap[connectionParams.OwnerUri] = connectionInfo;
// invoke callback notifications
foreach (var activity in this.onConnectionActivities)
{
activity(connection);
activity(connectionInfo);
}
// return the connection result
return new ConnectionResult()
return new ConnectResponse()
{
ConnectionId = maxConnectionId
ConnectionId = connectionInfo.ConnectionId.ToString()
};
}
public void InitializeService(ServiceHost serviceHost)
public void InitializeService(IProtocolEndpoint serviceHost)
{
// Register request and event handlers with the Service Host
serviceHost.SetRequestHandler(ConnectionRequest.Type, HandleConnectRequest);
@@ -167,11 +194,7 @@ namespace Microsoft.SqlTools.ServiceLayer.Connection
{
onConnectionActivities.Add(activity);
}
#endregion
#region Request Handlers
/// <summary>
/// Handle new connection requests
/// </summary>
@@ -179,15 +202,15 @@ namespace Microsoft.SqlTools.ServiceLayer.Connection
/// <param name="requestContext"></param>
/// <returns></returns>
protected async Task HandleConnectRequest(
ConnectionDetails connectionDetails,
RequestContext<ConnectionResult> requestContext)
ConnectParams connectParams,
RequestContext<ConnectResponse> requestContext)
{
Logger.Write(LogLevel.Verbose, "HandleConnectRequest");
try
{
// open connection base on request details
ConnectionResult result = ConnectionService.Instance.Connect(connectionDetails);
ConnectResponse result = ConnectionService.Instance.Connect(connectParams);
await requestContext.SendResult(result);
}
catch(Exception ex)
@@ -195,11 +218,7 @@ namespace Microsoft.SqlTools.ServiceLayer.Connection
await requestContext.SendError(ex.Message);
}
}
#endregion
#region Handlers for Events from Other Services
public Task HandleDidChangeConfigurationNotification(
SqlToolsSettings newSettings,
SqlToolsSettings oldSettings,
@@ -207,16 +226,12 @@ namespace Microsoft.SqlTools.ServiceLayer.Connection
{
return Task.FromResult(true);
}
#endregion
#region Private Helpers
/// <summary>
/// Build a connection string from a connection details instance
/// </summary>
/// <param name="connectionDetails"></param>
private string BuildConnectionString(ConnectionDetails connectionDetails)
public static string BuildConnectionString(ConnectionDetails connectionDetails)
{
SqlConnectionStringBuilder connectionBuilder = new SqlConnectionStringBuilder();
connectionBuilder["Data Source"] = connectionDetails.ServerName;
@@ -226,7 +241,5 @@ namespace Microsoft.SqlTools.ServiceLayer.Connection
connectionBuilder["Initial Catalog"] = connectionDetails.DatabaseName;
return connectionBuilder.ToString();
}
#endregion
}
}

98
src/Microsoft.SqlTools.ServiceLayer/Connection/Contracts/ConnectionMessages.cs
View File

@@ -7,10 +7,57 @@ using Microsoft.SqlTools.ServiceLayer.Hosting.Protocol.Contracts;
namespace Microsoft.SqlTools.ServiceLayer.Connection.Contracts
{
/// <summary>
/// Message format for the initial connection request
/// <summary>
/// Parameters for the Connect Request.
/// </summary>
public class ConnectionDetails
public class ConnectParams
{
/// <summary>
/// A URI identifying the owner of the connection. This will most commonly be a file in the workspace
/// or a virtual file representing an object in a database.
/// </summary>
public string OwnerUri { get; set; }
/// <summary>
/// Contains the required parameters to initialize a connection to a database.
/// A connection will identified by its server name, database name and user name.
/// This may be changed in the future to support multiple connections with different
/// connection properties to the same database.
/// </summary>
public ConnectionDetails Connection { get; set; }
}
/// <summary>
/// Parameters for the Disconnect Request.
/// </summary>
public class DisconnectParams
{
/// <summary>
/// A URI identifying the owner of the connection. This will most commonly be a file in the workspace
/// or a virtual file representing an object in a database.
/// </summary>
public string ownerUri { get; set; }
}
/// <summary>
/// Parameters for the ConnectionChanged Notification.
/// </summary>
public class ConnectionChangedParams
{
/// <summary>
/// A URI identifying the owner of the connection. This will most commonly be a file in the workspace
/// or a virtual file representing an object in a database.
/// </summary>
public string ownerUri { get; set; }
/// <summary>
/// Contains the high-level properties about the connection, for display to the user.
/// </summary>
public ConnectionSummary Connection { get; set; }
}
/// <summary>
/// Provides high level information about a connection.
/// </summary>
public class ConnectionSummary
{
/// <summary>
/// Gets or sets the connection server name
@@ -25,39 +72,66 @@ namespace Microsoft.SqlTools.ServiceLayer.Connection.Contracts
/// <summary>
/// Gets or sets the connection user name
/// </summary>
public string UserName { get; set; }
public string UserName { get; set; }
}
/// <summary>
/// Message format for the initial connection request
/// </summary>
public class ConnectionDetails : ConnectionSummary
{
/// <summary>
/// Gets or sets the connection password
/// </summary>
/// <returns></returns>
public string Password { get; set; }
// TODO Handle full set of properties
}
/// <summary>
/// Message format for the connection result response
/// </summary>
public class ConnectionResult
public class ConnectResponse
{
/// <summary>
/// Gets or sets the connection id
/// A GUID representing a unique connection ID
/// </summary>
public int ConnectionId { get; set; }
public string ConnectionId { get; set; }
/// <summary>
/// Gets or sets any connection error messages
/// </summary>
public string Messages { get; set; }
}
}
/// <summary>
/// Connect request mapping entry
/// </summary>
public class ConnectionRequest
{
public static readonly
RequestType<ConnectionDetails, ConnectionResult> Type =
RequestType<ConnectionDetails, ConnectionResult>.Create("connection/connect");
RequestType<ConnectParams, ConnectResponse> Type =
RequestType<ConnectParams, ConnectResponse>.Create("connection/connect");
}
/// <summary>
/// Disconnect request mapping entry
/// </summary>
public class DisconnectRequest
{
public static readonly
RequestType<DisconnectParams, bool> Type =
RequestType<DisconnectParams, bool>.Create("connection/disconnect");
}
/// <summary>
/// ConnectionChanged notification mapping entry
/// </summary>
public class ConnectionChangedNotification
{
public static readonly
EventType<ConnectionChangedParams> Type =
EventType<ConnectionChangedParams>.Create("connection/connectionchanged");
}
}