private async Task <ConnectionCompleteParams> Connect(ConnectParams connectParams, string uri)
{
string connectionErrorMessage = string.Empty;
try
{
// open connection based on request details
ConnectionCompleteParams result = await connectionService.Connect(connectParams);
connectionErrorMessage = result != null ? $"{result.Messages} error code:{result.ErrorNumber}" : string.Empty;
if (result != null && !string.IsNullOrEmpty(result.ConnectionId))
{
return(result);
}
else
{
await SendSessionFailedNotification(uri, result.ErrorMessage);
return(null);
}
}
catch (Exception ex)
{
await SendSessionFailedNotification(uri, ex.ToString());
return(null);
}
}
public static async Task <TestConnectionResult> InitLiveConnectionInfoAsync(string databaseName = null, string ownerUri = null)
{
ScriptFile scriptFile = null;
if (string.IsNullOrEmpty(ownerUri))
{
string sqlFilePath = GetTestSqlFile();
scriptFile = TestServiceProvider.Instance.WorkspaceService.Workspace.GetFile(sqlFilePath);
ownerUri = scriptFile.ClientFilePath;
}
ConnectParams connectParams = TestServiceProvider.Instance.ConnectionProfileService.GetConnectionParameters(TestServerType.OnPrem, databaseName);
var connectionService = GetLiveTestConnectionService();
var connectionResult =
await connectionService
.Connect(new ConnectParams
{
OwnerUri = ownerUri,
Connection = connectParams.Connection
});
if (!string.IsNullOrEmpty(connectionResult.ErrorMessage))
{
Console.WriteLine(connectionResult.ErrorMessage);
}
ConnectionInfo connInfo = null;
connectionService.TryFindConnection(ownerUri, out connInfo);
return(new TestConnectionResult()
{
ConnectionInfo = connInfo, ScriptFile = scriptFile
});
}
/// <summary>
/// Create a connection parameters object
/// </summary>
private ConnectParams CreateConnectParams(InstanceInfo connectionProfile, string key, string databaseName)
{
ConnectParams connectParams = new ConnectParams();
connectParams.Connection = new ConnectionDetails();
connectParams.Connection.ServerName = connectionProfile.ServerName;
connectParams.Connection.DatabaseName = connectionProfile.Database;
connectParams.Connection.DatabaseDisplayName = connectionProfile.Database;
connectParams.Connection.UserName = connectionProfile.User;
connectParams.Connection.Password = connectionProfile.Password;
connectParams.Connection.MaxPoolSize = 200;
connectParams.Connection.AuthenticationType = connectionProfile.AuthenticationType.ToString();
if (!string.IsNullOrEmpty(databaseName))
{
connectParams.Connection.DatabaseName = databaseName;
connectParams.Connection.DatabaseDisplayName = databaseName;
}
if (key == DefaultSqlAzureInstanceKey || key == DefaultSqlAzureV12InstanceKey)
{
connectParams.Connection.ConnectTimeout = 30;
connectParams.Connection.Encrypt = true;
connectParams.Connection.TrustServerCertificate = false;
}
return(connectParams);
}
/// <summary>
/// Check that the fields in ConnectParams are all valid
/// </summary>
public static bool IsValid(this ConnectParams parameters, out string errorMessage)
{
errorMessage = string.Empty;
if (string.IsNullOrEmpty(parameters.OwnerUri))
{
errorMessage = SR.ConnectionParamsValidateNullOwnerUri;
}
else if (parameters.Connection == null)
{
errorMessage = SR.ConnectionParamsValidateNullConnection;
}
else if (!string.IsNullOrEmpty(parameters.Connection.ConnectionString))
{
// Do not check other connection parameters if a connection string is present
return(string.IsNullOrEmpty(errorMessage));
}
else if (string.IsNullOrEmpty(parameters.Connection.ServerName))
{
errorMessage = SR.ConnectionParamsValidateNullServerName;
}
else if (string.IsNullOrEmpty(parameters.Connection.AuthenticationType) || parameters.Connection.AuthenticationType == "SqlLogin")
{
// For SqlLogin, username cannot be empty
if (string.IsNullOrEmpty(parameters.Connection.UserName))
{
errorMessage = SR.ConnectionParamsValidateNullSqlAuth("UserName");
}
}
return(string.IsNullOrEmpty(errorMessage));
}
public static TestConnectionResult InitLiveConnectionInfo(string databaseName = null, string ownerUri = null)
{
ScriptFile scriptFile = null;
ConnectParams connectParams = TestServiceProvider.Instance.ConnectionProfileService.GetConnectionParameters(TestServerType.OnPrem, databaseName);
if (string.IsNullOrEmpty(ownerUri))
{
ownerUri = GetTestSqlFile();
scriptFile = TestServiceProvider.Instance.WorkspaceService.Workspace.GetFile(ownerUri);
ownerUri = scriptFile.ClientUri;
}
var connectionService = GetLiveTestConnectionService();
var connectionResult =
connectionService
.Connect(new ConnectParams
{
OwnerUri = ownerUri,
Connection = connectParams.Connection
});
connectionResult.Wait();
ConnectionInfo connInfo = null;
connectionService.TryFindConnection(ownerUri, out connInfo);
return(new TestConnectionResult()
{
ConnectionInfo = connInfo, ScriptFile = scriptFile
});
}
public static TestConnectionResult InitLiveConnectionInfo()
{
string sqlFilePath = GetTestSqlFile();
ScriptFile scriptFile = TestServiceProvider.Instance.WorkspaceService.Workspace.GetFile(sqlFilePath);
ConnectParams connectParams = TestServiceProvider.Instance.ConnectionProfileService.GetConnectionParameters(TestServerType.OnPrem);
string ownerUri = scriptFile.ClientFilePath;
var connectionService = TestObjects.GetLiveTestConnectionService();
var connectionResult =
connectionService
.Connect(new ConnectParams()
{
OwnerUri = ownerUri,
Connection = connectParams.Connection
});
connectionResult.Wait();
ConnectionInfo connInfo = null;
connectionService.TryFindConnection(ownerUri, out connInfo);
return(new TestConnectionResult()
{
ConnectionInfo = connInfo, ScriptFile = scriptFile
});
}
/// <summary>
/// Example test that performs a connect, then disconnect.
/// All tests must have the same signature of returning an async Task
/// and taking in a ServiceTestDriver as a parameter.
/// </summary>
public async Task ConnectDisconnectTest(ServiceTestDriver driver)
{
var connectParams = new ConnectParams();
connectParams.OwnerUri = "file";
connectParams.Connection = new ConnectionDetails();
connectParams.Connection.ServerName = "localhost";
connectParams.Connection.AuthenticationType = "Integrated";
var result = await driver.SendRequest(ConnectionRequest.Type, connectParams);
if (result)
{
await driver.WaitForEvent(ConnectionCompleteNotification.Type);
var disconnectParams = new DisconnectParams();
disconnectParams.OwnerUri = "file";
var result2 = await driver.SendRequest(DisconnectRequest.Type, disconnectParams);
if (result2)
{
Console.WriteLine("success");
}
}
}
private void RunConnectRequestHandlerTask(ConnectParams connectParams)
{
// create a task to connect asynchronously so that other requests are not blocked in the meantime
Task.Run(async() =>
{
try
{
// result is null if the ConnectParams was successfully validated
ConnectionCompleteParams result = ValidateConnectParams(connectParams);
if (result != null)
{
await ServiceHost.SendEvent(ConnectionCompleteNotification.Type, result);
return;
}
// open connection based on request details
result = await Connect(connectParams);
await ServiceHost.SendEvent(ConnectionCompleteNotification.Type, result);
}
catch (Exception ex)
{
ConnectionCompleteParams result = new ConnectionCompleteParams()
{
Messages = ex.ToString()
};
await ServiceHost.SendEvent(ConnectionCompleteNotification.Type, result);
}
});
}
/// <summary>
/// Check that the fields in ConnectParams are all valid
/// </summary>
public static bool IsValid(this ConnectParams parameters, out string errorMessage)
{
errorMessage = string.Empty;
if (string.IsNullOrEmpty(parameters.OwnerUri))
{
errorMessage = SR.ConnectionParamsValidateNullOwnerUri;
}
else if (parameters.Connection == null)
{
errorMessage = SR.ConnectionParamsValidateNullConnection;
}
else if (string.IsNullOrEmpty(parameters.Connection.ServerName))
{
errorMessage = SR.ConnectionParamsValidateNullServerName;
}
else if (string.IsNullOrEmpty(parameters.Connection.AuthenticationType) || parameters.Connection.AuthenticationType == "SqlLogin")
{
// For SqlLogin, username/password cannot be empty
if (string.IsNullOrEmpty(parameters.Connection.UserName))
{
errorMessage = SR.ConnectionParamsValidateNullSqlAuth("UserName");
}
else if (string.IsNullOrEmpty(parameters.Connection.Password))
{
errorMessage = SR.ConnectionParamsValidateNullSqlAuth("Password");
}
}
return(string.IsNullOrEmpty(errorMessage));
}
/// <summary>
/// Establishes a new session and stores its information
/// </summary>
/// <returns><see cref="ObjectExplorerSession"/> object if successful, null if unsuccessful</returns>
internal async Task <ObjectExplorerSession> DoCreateSession(ConnectionDetails connectionDetails, string uri)
{
try
{
ObjectExplorerSession session;
connectionDetails.PersistSecurityInfo = true;
ConnectParams connectParams = new ConnectParams()
{
OwnerUri = uri, Connection = connectionDetails
};
ConnectionCompleteParams connectionResult = await Connect(connectParams, uri);
if (connectionResult == null)
{
// Connection failed and notification is already sent
return(null);
}
session = ObjectExplorerSession.CreateSession(connectionResult, serviceProvider);
sessionMap.AddOrUpdate(uri, session, (key, oldSession) => session);
return(session);
}
catch (Exception ex)
{
await SendSessionFailedNotification(uri, ex.Message);
return(null);
}
}
/// <summary>
/// Extract QML debug connection parameters from command line args
/// </summary>
public static bool ParseCommandLine(
string execPath,
string args,
out ushort portFrom,
out ushort portTo,
out string hostName,
out string fileName,
out bool block)
{
portFrom = portTo = 0;
hostName = fileName = "";
block = false;
ConnectParams connParams = ConnectParamsParser
.Parse(args)
.GetValues <ConnectParams>(TokenId.ConnectParams)
.FirstOrDefault();
if (connParams == null)
{
return(false);
}
portFrom = connParams.Port;
if (connParams.MaxPort.HasValue)
{
portTo = connParams.MaxPort.Value;
}
hostName = connParams.Host;
fileName = connParams.File;
block = connParams.Block;
return(true);
}
private async void TestAddCMS()
{
string name = "TestAddCMS" + DateTime.Now.ToString();
ConnectParams connectParams = CreateConnectParams();
// Prepare for list servers (may or may not have servers but will have listCmsServersResult)
var requestContext = new Mock <RequestContext <ListRegisteredServersResult> >();
requestContext.Setup((RequestContext <ListRegisteredServersResult> x) => x.SendResult(It.Is <ListRegisteredServersResult>((listCmsServersResult) => listCmsServersResult.RegisteredServersList != null))).Returns(Task.FromResult(new object()));
CreateCentralManagementServerParams connectToCMS = new CreateCentralManagementServerParams
{
RegisteredServerName = name,
RegisteredServerDescription = "My Registered Test Server",
ConnectParams = connectParams
};
// Actual test after preparation start here
CmsService cmsService = CmsService.Instance;
// Connect to CMS
await cmsService.HandleCreateCentralManagementServerRequest(connectToCMS, requestContext.Object);
await cmsService.CmsTask;
requestContext.VerifyAll();
}
private static async Task <AssessmentResult <TResult> > CallAssessment <TResult>(
string methodName,
SqlObjectType sqlObjectType,
LiveConnectionHelper.TestConnectionResult liveConnection)
where TResult : AssessmentItemInfo
{
var connInfo = liveConnection.ConnectionInfo;
AssessmentResult <TResult> response;
using (var service = new SqlAssessmentService(
TestServiceProvider.Instance.ConnectionService,
TestServiceProvider.Instance.WorkspaceService))
{
AddTestRules(service);
string randomUri = Guid.NewGuid().ToString();
AssessmentParams requestParams =
new AssessmentParams {
OwnerUri = randomUri, TargetType = sqlObjectType
};
ConnectParams connectParams = new ConnectParams
{
OwnerUri = requestParams.OwnerUri,
Connection = connInfo.ConnectionDetails,
Type = ConnectionType.Default
};
var methodInfo = typeof(SqlAssessmentService).GetMethod(
methodName,
BindingFlags.Instance | BindingFlags.NonPublic);
Assert.NotNull(methodInfo);
var func = (AssessmentMethod <TResult>)Delegate.CreateDelegate(
typeof(AssessmentMethod <TResult>),
service,
methodInfo);
response = await service.CallAssessmentEngine <TResult>(
requestParams,
connectParams,
randomUri,
t => func(t));
}
Assert.NotNull(response);
if (response.Success)
{
Assert.All(
response.Items,
i =>
{
Assert.Equal(sqlObjectType, i.TargetType);
Assert.Contains(i.Level, AllowedSeverityLevels);
});
}
return(response);
}
private async void TestAddRemoveServerGroup()
{
string name = "TestAddRemoveServerGroup" + DateTime.Now.ToString();
ConnectParams connectParams = await CreateAndConnectWithConnectParams();
// Prepare for Server group add
var requestContext1 = new Mock <RequestContext <bool> >();
requestContext1.Setup((RequestContext <bool> x) => x.SendResult(It.Is <bool>((result) => result == true))).Returns(Task.FromResult(new object()));
AddServerGroupParams addRegServerParams = new AddServerGroupParams
{
GroupName = name,
GroupDescription = "My Registered Test Server Group",
ParentOwnerUri = connectParams.OwnerUri,
RelativePath = null,
};
// prepare for Server group list
var requestContext2 = new Mock <RequestContext <ListRegisteredServersResult> >();
requestContext2.Setup((RequestContext <ListRegisteredServersResult> x) => x.SendResult(It.Is <ListRegisteredServersResult>((listCmsServersResult) => listCmsServersResult.RegisteredServerGroups.Find(p => p.Name.Contains(name)) != null))).Returns(Task.FromResult(new object()));
ListRegisteredServersParams listServersParams = new ListRegisteredServersParams
{
ParentOwnerUri = connectParams.OwnerUri,
RelativePath = null
};
// prepare for server group remove
var requestContext3 = new Mock <RequestContext <bool> >();
requestContext1.Setup((RequestContext <bool> x) => x.SendResult(It.Is <bool>((result) => result == true))).Returns(Task.FromResult(new object()));
RemoveServerGroupParams removeRegServerParams = new RemoveServerGroupParams
{
ParentOwnerUri = connectParams.OwnerUri,
GroupName = name,
RelativePath = null
};
// Actual test start here
CmsService cmsService = CmsService.Instance;
await cmsService.HandleAddServerGroupRequest(addRegServerParams, requestContext1.Object);
await cmsService.CmsTask;
requestContext1.VerifyAll();
await cmsService.HandleListRegisteredServersRequest(listServersParams, requestContext2.Object);
await cmsService.CmsTask;
requestContext2.VerifyAll();
await cmsService.HandleRemoveServerGroupRequest(removeRegServerParams, requestContext3.Object);
await cmsService.CmsTask;
requestContext3.VerifyAll();
}
private async Task <ConnectParams> CreateAndConnectWithConnectParams()
{
ConnectParams connectParams = CreateConnectParams();
ConnectionService connService = ConnectionService.Instance;
await connService.Connect(connectParams);
return(connectParams);
}
private bool IsConnectionChanged(ConnectParams connectionParams, ConnectionInfo connectionInfo)
{
if (connectionInfo.HasConnectionType(connectionParams.Type) &&
!connectionInfo.ConnectionDetails.IsComparableTo(connectionParams.Connection))
{
return(true);
}
return(false);
}
/// <summary>
/// Open a connection with the specified ConnectParams
/// </summary>
public virtual async Task <ConnectionCompleteParams> Connect(ConnectParams connectionParams)
{
// Validate parameters
ConnectionCompleteParams validationResults = ValidateConnectParams(connectionParams);
if (validationResults != null)
{
return(validationResults);
}
// If there is no ConnectionInfo in the map, create a new ConnectionInfo,
// but wait until later when we are connected to add it to the map.
ConnectionInfo connectionInfo;
bool connectionChanged = false;
if (!ownerToConnectionMap.TryGetValue(connectionParams.OwnerUri, out connectionInfo))
{
connectionInfo = new ConnectionInfo(ConnectionFactory, connectionParams.OwnerUri, connectionParams.Connection);
}
else if (IsConnectionChanged(connectionParams, connectionInfo))
{
// We are actively changing the connection information for this connection. We must disconnect
// all active connections, since it represents a full context change
connectionChanged = true;
}
DisconnectExistingConnectionIfNeeded(connectionParams, connectionInfo, disconnectAll: connectionChanged);
if (connectionChanged)
{
connectionInfo = new ConnectionInfo(ConnectionFactory, connectionParams.OwnerUri, connectionParams.Connection);
}
// Try to open a connection with the given ConnectParams
ConnectionCompleteParams response = await TryOpenConnection(connectionInfo, connectionParams);
if (response != null)
{
return(response);
}
// If this is the first connection for this URI, add the ConnectionInfo to the map
bool addToMap = connectionChanged || !ownerToConnectionMap.ContainsKey(connectionParams.OwnerUri);
if (addToMap)
{
ownerToConnectionMap[connectionParams.OwnerUri] = connectionInfo;
}
// Return information about the connected SQL Server instance
ConnectionCompleteParams completeParams = GetConnectionCompleteParams(connectionParams.Type, connectionInfo);
// Invoke callback notifications
InvokeOnConnectionActivities(connectionInfo, connectionParams);
return(completeParams);
}
// public
public static void Connect(Socket connectingSocket, IPEndPoint connectEndPoint, int connectTimeout)
{
ConnectParams connectParams = new ConnectParams(connectingSocket, connectEndPoint, connectTimeout);
Thread connectingThread = new Thread(new ParameterizedThreadStart(ConnectThread));
connectingThread.Start(connectParams);
connectingThread.Join();
}
internal static async Task ExecuteQuery(string query)
{
// create a temporary "workspace" file
using (SelfCleaningTempFile queryTempFile = new SelfCleaningTempFile())
// create the client helper which wraps the client driver objects
using (ClientHelper testHelper = new ClientHelper())
{
// connnection details
ConnectParams connectParams = new ConnectParams();
connectParams.Connection = new ConnectionDetails();
connectParams.Connection.ServerName = "localhost";
connectParams.Connection.DatabaseName = "master";
connectParams.Connection.AuthenticationType = "Integrated";
// connect to the database
await testHelper.Connect(queryTempFile.FilePath, connectParams);
// execute the query
QueryExecuteCompleteParams queryComplete =
await testHelper.RunQuery(queryTempFile.FilePath, query);
if (queryComplete.BatchSummaries != null && queryComplete.BatchSummaries.Length > 0)
{
var batch = queryComplete.BatchSummaries[0];
if (batch.ResultSetSummaries != null && batch.ResultSetSummaries.Length > 0)
{
var resultSet = batch.ResultSetSummaries[0];
// retrive the results
QueryExecuteSubsetResult querySubset = await testHelper.ExecuteSubset(
queryTempFile.FilePath, batch.Id,
resultSet.Id, 0, (int)resultSet.RowCount);
// print the header
foreach (var column in resultSet.ColumnInfo)
{
Console.Write(column.ColumnName + ", ");
}
Console.Write(Environment.NewLine);
// print the rows
foreach (var row in querySubset.ResultSubset.Rows)
{
for (int i = 0; i < resultSet.ColumnInfo.Length; ++i)
{
Console.Write(row.GetValue(i) + ", ");
}
Console.Write(Environment.NewLine);
}
}
}
// close database connection
await testHelper.Disconnect(queryTempFile.FilePath);
}
}
public async void ConnectingTwiceWithTheSameUriDoesNotCreateAnotherDbConnection()
{
// Setup the connect and disconnect params
var connectParamsSame1 = new ConnectParams()
{
OwnerUri = "connectParamsSame",
Connection = TestObjects.GetTestConnectionDetails()
};
var connectParamsSame2 = new ConnectParams()
{
OwnerUri = "connectParamsSame",
Connection = TestObjects.GetTestConnectionDetails()
};
var disconnectParamsSame = new DisconnectParams()
{
OwnerUri = connectParamsSame1.OwnerUri
};
var connectParamsDifferent = new ConnectParams()
{
OwnerUri = "connectParamsDifferent",
Connection = TestObjects.GetTestConnectionDetails()
};
var disconnectParamsDifferent = new DisconnectParams()
{
OwnerUri = connectParamsDifferent.OwnerUri
};
// Given a request to connect to a database, there should be no initial connections in the map
var service = TestObjects.GetTestConnectionService();
Dictionary <string, ConnectionInfo> ownerToConnectionMap = service.OwnerToConnectionMap;
Assert.Equal(0, ownerToConnectionMap.Count);
// If we connect to the service, there should be 1 connection
await service.Connect(connectParamsSame1);
Assert.Equal(1, ownerToConnectionMap.Count);
// If we connect again with the same URI, there should still be 1 connection
await service.Connect(connectParamsSame2);
Assert.Equal(1, ownerToConnectionMap.Count);
// If we connect with a different URI, there should be 2 connections
await service.Connect(connectParamsDifferent);
Assert.Equal(2, ownerToConnectionMap.Count);
// If we disconnect with the unique URI, there should be 1 connection
service.Disconnect(disconnectParamsDifferent);
Assert.Equal(1, ownerToConnectionMap.Count);
// If we disconnect with the duplicate URI, there should be 0 connections
service.Disconnect(disconnectParamsSame);
Assert.Equal(0, ownerToConnectionMap.Count);
}
private ConnectParams CreateConnectParams()
{
ConnectParams connectParams = TestServiceProvider.Instance.ConnectionProfileService.GetConnectionParameters(TestServerType.OnPrem, "master");
connectParams.OwnerUri = LiveConnectionHelper.GetTestSqlFile();
connectParams.Connection.DatabaseName = null;
connectParams.Connection.DatabaseDisplayName = null;
return(connectParams);
}
/// <summary>
/// Gets the existing connection with the given URI and connection type string. If none exists,
/// creates a new connection. This cannot be used to create a default connection or to create a
/// connection if a default connection does not exist.
/// </summary>
/// <param name="ownerUri">URI identifying the resource mapped to this connection</param>
/// <param name="connectionType">
/// What the purpose for this connection is. A single resource
/// such as a SQL file may have multiple connections - one for Intellisense, another for query execution
/// </param>
/// <param name="alwaysPersistSecurity">
/// Workaround for .Net Core clone connection issues: should persist security be used so that
/// when SMO clones connections it can do so without breaking on SQL Password connections.
/// This should be removed once the core issue is resolved and clone works as expected
/// </param>
/// <returns>A DB connection for the connection type requested</returns>
public async Task <DbConnection> GetOrOpenConnection(string ownerUri, string connectionType, bool alwaysPersistSecurity = false)
{
Validate.IsNotNullOrEmptyString(nameof(ownerUri), ownerUri);
Validate.IsNotNullOrEmptyString(nameof(connectionType), connectionType);
// Try to get the ConnectionInfo, if it exists
ConnectionInfo connectionInfo;
if (!ownerToConnectionMap.TryGetValue(ownerUri, out connectionInfo))
{
throw new ArgumentOutOfRangeException(SR.ConnectionServiceListDbErrorNotConnected(ownerUri));
}
// Make sure a default connection exists
DbConnection defaultConnection;
if (!connectionInfo.TryGetConnection(ConnectionType.Default, out defaultConnection))
{
throw new InvalidOperationException(SR.ConnectionServiceDbErrorDefaultNotConnected(ownerUri));
}
// Try to get the DbConnection
DbConnection connection;
if (!connectionInfo.TryGetConnection(connectionType, out connection) && ConnectionType.Default != connectionType)
{
// If the DbConnection does not exist and is not the default connection, create one.
// We can't create the default (initial) connection here because we won't have a ConnectionDetails
// if Connect() has not yet been called.
bool?originalPersistSecurityInfo = connectionInfo.ConnectionDetails.PersistSecurityInfo;
if (alwaysPersistSecurity)
{
connectionInfo.ConnectionDetails.PersistSecurityInfo = true;
}
ConnectParams connectParams = new ConnectParams
{
OwnerUri = ownerUri,
Connection = connectionInfo.ConnectionDetails,
Type = connectionType
};
try
{
await Connect(connectParams);
}
finally
{
connectionInfo.ConnectionDetails.PersistSecurityInfo = originalPersistSecurityInfo;
}
connectionInfo.TryGetConnection(connectionType, out connection);
}
return(connection);
}
/// <summary>
/// Establishes a new session and stores its information
/// </summary>
/// <returns><see cref="ObjectExplorerSession"/> object if successful, null if unsuccessful</returns>
internal async Task <ObjectExplorerSession> DoCreateSession(ConnectionDetails connectionDetails, string uri)
{
try
{
ObjectExplorerSession session = null;
connectionDetails.PersistSecurityInfo = true;
ConnectParams connectParams = new ConnectParams()
{
OwnerUri = uri, Connection = connectionDetails, Type = Connection.ConnectionType.ObjectExplorer
};
bool isDefaultOrSystemDatabase = DatabaseUtils.IsSystemDatabaseConnection(connectionDetails.DatabaseName) || string.IsNullOrWhiteSpace(connectionDetails.DatabaseDisplayName);
ConnectionInfo connectionInfo;
ConnectionCompleteParams connectionResult = await Connect(connectParams, uri);
if (!connectionService.TryFindConnection(uri, out connectionInfo))
{
return(null);
}
if (connectionResult == null)
{
// Connection failed and notification is already sent
return(null);
}
int timeout = (int)TimeSpan.FromSeconds(settings?.CreateSessionTimeout ?? ObjectExplorerSettings.DefaultCreateSessionTimeout).TotalMilliseconds;
QueueItem queueItem = bindingQueue.QueueBindingOperation(
key: bindingQueue.AddConnectionContext(connectionInfo, connectionName),
bindingTimeout: timeout,
waitForLockTimeout: timeout,
bindOperation: (bindingContext, cancelToken) =>
{
session = ObjectExplorerSession.CreateSession(connectionResult, serviceProvider, bindingContext.ServerConnection, isDefaultOrSystemDatabase);
session.ConnectionInfo = connectionInfo;
sessionMap.AddOrUpdate(uri, session, (key, oldSession) => session);
return(session);
});
queueItem.ItemProcessed.WaitOne();
if (queueItem.GetResultAsT <ObjectExplorerSession>() != null)
{
session = queueItem.GetResultAsT <ObjectExplorerSession>();
}
return(session);
}
catch (Exception ex)
{
await SendSessionFailedNotification(uri, ex.Message);
return(null);
}
}
private async Task <ObjectExplorerSession> CreateSession(string databaseName)
{
ConnectParams connectParams = TestServiceProvider.Instance.ConnectionProfileService.GetConnectionParameters(TestServerType.OnPrem, databaseName);
//connectParams.Connection.Pooling = false;
ConnectionDetails details = connectParams.Connection;
string uri = ObjectExplorerService.GenerateUri(details);
var session = await _service.DoCreateSession(details, uri);
Console.WriteLine(string.Format(CultureInfo.InvariantCulture, "OE session created for database: {0}", databaseName));
return(session);
}
/// <summary>
/// Create a connection parameters object
/// </summary>
public static ConnectParams CreateConnectParams(string server, string database, string username, string password)
{
ConnectParams connectParams = new ConnectParams();
connectParams.Connection = new ConnectionDetails();
connectParams.Connection.ServerName = server;
connectParams.Connection.DatabaseName = database;
connectParams.Connection.UserName = username;
connectParams.Connection.Password = password;
connectParams.Connection.AuthenticationType = "SqlLogin";
return(connectParams);
}
/// <summary>
/// Open a connection with the specified ConnectParams
/// </summary>
public async Task <ConnectionCompleteParams> Connect(ConnectParams connectionParams)
{
// Validate parameters
ConnectionCompleteParams validationResults = ValidateConnectParams(connectionParams);
if (validationResults != null)
{
return(validationResults);
}
// If there is no ConnectionInfo in the map, create a new ConnectionInfo,
// but wait until later when we are connected to add it to the map.
ConnectionInfo connectionInfo;
if (!ownerToConnectionMap.TryGetValue(connectionParams.OwnerUri, out connectionInfo))
{
connectionInfo = new ConnectionInfo(ConnectionFactory, connectionParams.OwnerUri, connectionParams.Connection);
}
// Resolve if it is an existing connection
// Disconnect active connection if the URI is already connected for this connection type
DbConnection existingConnection;
if (connectionInfo.TryGetConnection(connectionParams.Type, out existingConnection))
{
var disconnectParams = new DisconnectParams()
{
OwnerUri = connectionParams.OwnerUri,
Type = connectionParams.Type
};
Disconnect(disconnectParams);
}
// Try to open a connection with the given ConnectParams
ConnectionCompleteParams response = await TryOpenConnection(connectionInfo, connectionParams);
if (response != null)
{
return(response);
}
// If this is the first connection for this URI, add the ConnectionInfo to the map
if (!ownerToConnectionMap.ContainsKey(connectionParams.OwnerUri))
{
ownerToConnectionMap[connectionParams.OwnerUri] = connectionInfo;
}
// Invoke callback notifications
InvokeOnConnectionActivities(connectionInfo, connectionParams);
// Return information about the connected SQL Server instance
return(GetConnectionCompleteParams(connectionParams.Type, connectionInfo));
}
public ConnectParams GetConnectionParameters(string key = DefaultSql2016InstanceKey, string databaseName = null)
{
InstanceInfo instanceInfo = GetInstance(key);
if (instanceInfo != null)
{
ConnectParams connectParam = CreateConnectParams(instanceInfo, key, databaseName);
return(connectParam);
}
return(null);
}
private async Task HandleAssessmentRequest <TResult>(
RequestContext <AssessmentResult <TResult> > requestContext,
AssessmentParams requestParams,
Func <SqlObjectLocator, Task <List <TResult> > > assessmentFunction)
where TResult : AssessmentItemInfo
{
try
{
string randomUri = Guid.NewGuid().ToString();
// get connection
if (!ConnectionService.TryFindConnection(requestParams.OwnerUri, out var connInfo))
{
await requestContext.SendError(SR.SqlAssessmentQueryInvalidOwnerUri);
return;
}
ConnectParams connectParams = new ConnectParams
{
OwnerUri = randomUri,
Connection = connInfo.ConnectionDetails,
Type = ConnectionType.Default
};
if (!connInfo.TryGetConnection(ConnectionType.Default, out var connection))
{
await requestContext.SendError(SR.SqlAssessmentConnectingError);
}
var workTask = CallAssessmentEngine <TResult>(
requestParams,
connectParams,
randomUri,
assessmentFunction)
.ContinueWith(async tsk =>
{
await requestContext.SendResult(tsk.Result);
});
ActiveRequests.TryAdd(randomUri, workTask);
}
catch (Exception ex)
{
if (ex is StackOverflowException || ex is OutOfMemoryException)
{
throw;
}
await requestContext.SendError(ex.ToString());
}
}
/// <summary>
/// Invokes the initial on-connect activities if the provided ConnectParams represents the default
/// connection.
/// </summary>
private void InvokeOnConnectionActivities(ConnectionInfo connectionInfo, ConnectParams connectParams)
{
if (connectParams.Type != ConnectionType.Default)
{
return;
}
foreach (var activity in this.onConnectionActivities)
{
// not awaiting here to allow handlers to run in the background
activity(connectionInfo);
}
}
/// <summary>
/// Handle new connection requests
/// </summary>
/// <param name="connectParams"></param>
/// <param name="requestContext"></param>
/// <returns></returns>
protected async Task HandleConnectRequest(
ConnectParams connectParams,
RequestContext <bool> requestContext)
{
Logger.Write(LogLevel.Verbose, "HandleConnectRequest");
try
{
RunConnectRequestHandlerTask(connectParams);
await requestContext.SendResult(true);
}
catch
{
await requestContext.SendResult(false);
}
}
/// <summary>
/// Request a new connection to be created
/// </summary>
/// <returns>True if the connection completed successfully</returns>
public async Task <bool> Connect(string ownerUri, ConnectParams connectParams, int timeout = 15000)
{
connectParams.OwnerUri = ownerUri;
var connectResult = await Driver.SendRequest(ConnectionRequest.Type, connectParams);
if (connectResult)
{
var completeEvent = await Driver.WaitForEvent(ConnectionCompleteNotification.Type, timeout);
return(!string.IsNullOrEmpty(completeEvent.ConnectionId));
}
else
{
return(false);
}
}
private static PopSession ConnectCore(ConnectParams @params)
{
PopSession session = null;
try {
session = PopSessionCreator.CreateSession(@params.Profile,
@params.AuthMechanism,
@params.CreateSslStreamCallback ?? PopConnection.CreateSslStream);
}
finally {
@params.Profile.SetCredentials(null);
}
return session;
}
private static ImapSession ConnectCore(ConnectParams @params)
{
ImapSession session = null;
try {
session = ImapSessionCreator.CreateSession(@params.Profile,
@params.AuthMechanism,
@params.CreateSslStreamCallback ?? ImapConnection.CreateSslStream);
}
finally {
@params.Profile.SetCredentials(null);
}
// update server info
if (session.ServerCapabilities.Has(ImapCapability.Namespace))
session.Namespace();
if (session.ServerCapabilities.Has(ImapCapability.ID))
session.ID(null); // TODO: client ID
session.UpdateSelectedMailboxSizeAndStatus = false;
return session;
}
private IAsyncResult BeginConnect(ConnectParams @params,
AsyncCallback asyncCallback,
object asyncState)
{
ThrowIfAlreadyConnectedOrAsyncConnectRunning();
connectAsyncResult = new ConnectAsyncResult();
connectAsyncResult.BeginConnect(@params, asyncCallback, asyncState);
return connectAsyncResult;
}
internal void BeginConnect(ConnectParams @params,
AsyncCallback asyncCallback,
object asyncState)
{
var proc = (ConnectProc)ImapClient.ConnectCore;
this.asyncCallback = asyncCallback;
this.asyncState = asyncState;
innerAsyncResult = (AsyncResult)proc.BeginInvoke(@params, Callback, null);
}
