public IActionResult ConnectSuccess()
{
var bitString = "";
for (int i = 0; i < 40; i++)
{
bitString += "0";
}
_connectionService.Connect("ip address goes here", "567432" + " " + bitString);
return(View());
}
public async void ConnectToDefaultDatabaseRespondsWithActualDbName(string expectedDbName)
{
// Given connecting with empty database name will return the expected DB name
var connectionMock = new Mock <DbConnection> {
CallBase = true
};
connectionMock.Setup(c => c.Database).Returns(expectedDbName);
var mockFactory = new Mock <ISqlConnectionFactory>();
mockFactory.Setup(factory => factory.CreateSqlConnection(It.IsAny <string>()))
.Returns(connectionMock.Object);
var connectionService = new ConnectionService(mockFactory.Object);
// When I connect with an empty DB name
var connectionDetails = TestObjects.GetTestConnectionDetails();
connectionDetails.DatabaseName = string.Empty;
var connectionResult = await
connectionService
.Connect(new ConnectParams()
{
OwnerUri = "file:///my/test/file.sql",
Connection = connectionDetails
});
// Then I expect connection to succeed and the Summary to include the correct DB name
Assert.NotEmpty(connectionResult.ConnectionId);
Assert.NotNull(connectionResult.ConnectionSummary);
Assert.Equal(expectedDbName, connectionResult.ConnectionSummary.DatabaseName);
}
/// <summary>
/// Redirects the connection to the details in
/// the <see cref="ConnectionDetails"/> model.
/// </summary>
public void Redirect()
{
//absolutely critical that the encryption be uninitialized
CryptoInitializer.DecryptionInitializable.Uninitialize();
CryptoInitializer.EncryptionInitializable.Uninitialize();
ConnectionService.Connect(ConnectionDetails.IpAddress, ConnectionDetails.Port);
}
private async Task <ConnectParams> CreateAndConnectWithConnectParams()
{
ConnectParams connectParams = CreateConnectParams();
ConnectionService connService = ConnectionService.Instance;
await connService.Connect(connectParams);
return(connectParams);
}
public async void ListDatabasesOnServerForCurrentConnectionReturnsDatabaseNames()
{
// Result set for the query of database names
Dictionary <string, string>[] data =
{
new Dictionary <string, string> {
{ "name", "master" }
},
new Dictionary <string, string> {
{ "name", "model" }
},
new Dictionary <string, string> {
{ "name", "msdb" }
},
new Dictionary <string, string> {
{ "name", "tempdb" }
},
new Dictionary <string, string> {
{ "name", "mydatabase" }
},
};
// Setup mock connection factory to inject query results
var mockFactory = new Mock <ISqlConnectionFactory>();
mockFactory.Setup(factory => factory.CreateSqlConnection(It.IsAny <string>()))
.Returns(CreateMockDbConnection(new[] { data }));
var connectionService = new ConnectionService(mockFactory.Object);
// connect to a database instance
string ownerUri = "file://my/sample/file.sql";
var connectionResult = await
connectionService
.Connect(new ConnectParams()
{
OwnerUri = ownerUri,
Connection = TestObjects.GetTestConnectionDetails()
});
// verify that a valid connection id was returned
Assert.NotEmpty(connectionResult.ConnectionId);
// list databases for the connection
ListDatabasesParams parameters = new ListDatabasesParams();
parameters.OwnerUri = ownerUri;
var listDatabasesResult = connectionService.ListDatabases(parameters);
string[] databaseNames = listDatabasesResult.DatabaseNames;
Assert.Equal(databaseNames.Length, 5);
Assert.Equal(databaseNames[0], "master");
Assert.Equal(databaseNames[1], "model");
Assert.Equal(databaseNames[2], "msdb");
Assert.Equal(databaseNames[3], "tempdb");
Assert.Equal(databaseNames[4], "mydatabase");
}
public void Start()
{
Console.WriteLine("Connecting to {0}:{1}", host, port);
var client = new TcpClient(host, port);
connection.Start(client);
Console.WriteLine(".. connected");
connectionService = connection.GetImportedService <ConnectionService>();
connectionService.Connect(null, ConnectRequest.CreateBuilder().Build(), OnConnectResponse);
}
public static ConnectionInfo CreateConnectedConnectionInfo(TestResultSet[] data, bool throwOnRead, string type = ConnectionType.Default)
{
ConnectionService connectionService = ConnectionService.Instance;
connectionService.OwnerToConnectionMap.Clear();
connectionService.ConnectionFactory = CreateMockFactory(data, throwOnRead);
ConnectParams connectParams = new ConnectParams
{
Connection = StandardConnectionDetails,
OwnerUri = OwnerUri,
Type = type
};
connectionService.Connect(connectParams).Wait();
return(connectionService.OwnerToConnectionMap[OwnerUri]);
}
/// <summary>
/// Establish a connection with the device
/// </summary>
private void connect_Click(object sender, RoutedEventArgs e)
{
// TODO add a 'connecting...' prompt
var address = HostName.Text;
Connection = new ConnectionService(address, _connectionType);
var connected = Connection.Connect();
if (connected)
{
ScanDevice.IsEnabled = true;
}
// TODO change prompt to say 'connected' if successful
}
public static async Task <QueryExecutionService> GetPrimedExecutionService(ISqlConnectionFactory factory, bool isConnected, WorkspaceService <SqlToolsSettings> workspaceService)
{
var connectionService = new ConnectionService(factory);
if (isConnected)
{
await connectionService.Connect(new ConnectParams
{
Connection = GetTestConnectionDetails(),
OwnerUri = OwnerUri
});
}
return(new QueryExecutionService(connectionService, workspaceService)
{
BufferFileStreamFactory = GetFileStreamFactory()
});
}
static void Main(string[] args)
{
IConfigurationService configuration = new ConfigurationService();
IConnector connector = new ConnectionService();
IDeployer <SiteModelNode> siteDeployer = new SiteDeploymentPresenter();
IDeployer <WebModelNode> webDeployer = new WebDeploymentPresenter();
var url = configuration.GetConfigurationValue(ConfigurationDesignators.Url);
var password = configuration.GetConfigurationValue(ConfigurationDesignators.Password);
var login = configuration.GetConfigurationValue(ConfigurationDesignators.Login);
var context = connector.Connect(url, login, password);
var taxonomyCreator = new TaxonomyCreator(siteDeployer, context);
var projectListCreator = new ProjectListCreator(webDeployer, context);
var projectDocumentsListCreator = new ProjectDocumentsListCreator(webDeployer, context);
taxonomyCreator.Deploy();
projectListCreator.Deploy();
projectDocumentsListCreator.Deploy();
Console.WriteLine("Good");
Console.ReadKey();
}
/// <summary>
/// Handles a request to execute a string and return the result
/// </summary>
internal async Task HandleSimpleExecuteRequest(SimpleExecuteParams executeParams,
RequestContext <SimpleExecuteResult> requestContext)
{
try
{
string randomUri = Guid.NewGuid().ToString();
ExecuteStringParams executeStringParams = new ExecuteStringParams
{
Query = executeParams.QueryString,
// generate guid as the owner uri to make sure every query is unique
OwnerUri = randomUri
};
// get connection
ConnectionInfo connInfo;
if (!ConnectionService.TryFindConnection(executeParams.OwnerUri, out connInfo))
{
await requestContext.SendError(SR.QueryServiceQueryInvalidOwnerUri);
return;
}
ConnectParams connectParams = new ConnectParams
{
OwnerUri = randomUri,
Connection = connInfo.ConnectionDetails,
Type = ConnectionType.Default
};
Task workTask = Task.Run(async() => {
await ConnectionService.Connect(connectParams);
ConnectionInfo newConn;
ConnectionService.TryFindConnection(randomUri, out newConn);
Func <string, Task> queryCreateFailureAction = message => requestContext.SendError(message);
ResultOnlyContext <SimpleExecuteResult> newContext = new ResultOnlyContext <SimpleExecuteResult>(requestContext);
// handle sending event back when the query completes
Query.QueryAsyncEventHandler queryComplete = async query =>
{
try
{
// check to make sure any results were recieved
if (query.Batches.Length == 0 ||
query.Batches[0].ResultSets.Count == 0)
{
await requestContext.SendError(SR.QueryServiceResultSetHasNoResults);
return;
}
long rowCount = query.Batches[0].ResultSets[0].RowCount;
// check to make sure there is a safe amount of rows to load into memory
if (rowCount > Int32.MaxValue)
{
await requestContext.SendError(SR.QueryServiceResultSetTooLarge);
return;
}
SimpleExecuteResult result = new SimpleExecuteResult
{
RowCount = rowCount,
ColumnInfo = query.Batches[0].ResultSets[0].Columns,
Rows = new DbCellValue[0][]
};
if (rowCount > 0)
{
SubsetParams subsetRequestParams = new SubsetParams
{
OwnerUri = randomUri,
BatchIndex = 0,
ResultSetIndex = 0,
RowsStartIndex = 0,
RowsCount = Convert.ToInt32(rowCount)
};
// get the data to send back
ResultSetSubset subset = await InterServiceResultSubset(subsetRequestParams);
result.Rows = subset.Rows;
}
await requestContext.SendResult(result);
}
finally
{
Query removedQuery;
Task removedTask;
// remove the active query since we are done with it
ActiveQueries.TryRemove(randomUri, out removedQuery);
ActiveSimpleExecuteRequests.TryRemove(randomUri, out removedTask);
ConnectionService.Disconnect(new DisconnectParams()
{
OwnerUri = randomUri,
Type = null
});
}
};
// handle sending error back when query fails
Query.QueryAsyncErrorEventHandler queryFail = async(q, e) =>
{
await requestContext.SendError(e);
};
await InterServiceExecuteQuery(executeStringParams, newConn, newContext, null, queryCreateFailureAction, queryComplete, queryFail);
});
ActiveSimpleExecuteRequests.TryAdd(randomUri, workTask);
}
catch (Exception ex)
{
await requestContext.SendError(ex.ToString());
}
}
public void CanCancelConnectRequest()
{
var testFile = "file:///my/test/file.sql";
// Given a connection that times out and responds to cancellation
var mockConnection = new Mock <DbConnection> {
CallBase = true
};
CancellationToken token;
bool ready = false;
mockConnection.Setup(x => x.OpenAsync(Moq.It.IsAny <CancellationToken>()))
.Callback <CancellationToken>(t =>
{
// Pass the token to the return handler and signal the main thread to cancel
token = t;
ready = true;
})
.Returns(() =>
{
if (TestUtils.WaitFor(() => token.IsCancellationRequested))
{
throw new OperationCanceledException();
}
else
{
return(Task.FromResult(true));
}
});
var mockFactory = new Mock <ISqlConnectionFactory>();
mockFactory.Setup(factory => factory.CreateSqlConnection(It.IsAny <string>()))
.Returns(mockConnection.Object);
var connectionService = new ConnectionService(mockFactory.Object);
// Connect the connection asynchronously in a background thread
var connectionDetails = TestObjects.GetTestConnectionDetails();
var connectTask = Task.Run(async() =>
{
return(await connectionService
.Connect(new ConnectParams()
{
OwnerUri = testFile,
Connection = connectionDetails
}));
});
// Wait for the connection to call OpenAsync()
Assert.True(TestUtils.WaitFor(() => ready));
// Send a cancellation request
var cancelResult = connectionService
.CancelConnect(new CancelConnectParams()
{
OwnerUri = testFile
});
// Wait for the connection task to finish
connectTask.Wait();
// Verify that the connection was cancelled (no connection was created)
Assert.Null(connectTask.Result.ConnectionId);
// Verify that the cancel succeeded
Assert.True(cancelResult);
}
/// <summary>
/// This function obtains a live connection, then calls
/// an assessment operation specified by <paramref name="assessmentFunc"/>
/// </summary>
/// <typeparam name="TResult">
/// SQL Assessment result item type.
/// </typeparam>
/// <param name="requestParams">
/// Request parameters passed from the host.
/// </param>
/// <param name="connectParams">
/// Connection parameters used to identify and access the target.
/// </param>
/// <param name="taskUri">
/// An URI identifying the request task to enable concurrent execution.
/// </param>
/// <param name="assessmentFunc">
/// A function performing assessment operation for given target.
/// </param>
/// <returns>
/// Returns <see cref="AssessmentResult{TResult}"/> for given target.
/// </returns>
internal async Task <AssessmentResult <TResult> > CallAssessmentEngine <TResult>(
AssessmentParams requestParams,
ConnectParams connectParams,
string taskUri,
Func <SqlObjectLocator, Task <List <TResult> > > assessmentFunc)
where TResult : AssessmentItemInfo
{
var result = new AssessmentResult <TResult>
{
ApiVersion = ApiVersion
};
await ConnectionService.Connect(connectParams);
var connection = await ConnectionService.Instance.GetOrOpenConnection(taskUri, ConnectionType.Query);
try
{
var serverInfo = ReliableConnectionHelper.GetServerVersion(connection);
var hostInfo = ReliableConnectionHelper.GetServerHostInfo(connection);
var server = new SqlObjectLocator
{
Connection = connection,
EngineEdition = GetEngineEdition(serverInfo.EngineEditionId),
Name = serverInfo.ServerName,
ServerName = serverInfo.ServerName,
Type = SqlObjectType.Server,
Urn = serverInfo.ServerName,
Version = Version.Parse(serverInfo.ServerVersion),
Platform = hostInfo.Platform
};
switch (requestParams.TargetType)
{
case SqlObjectType.Server:
Logger.Write(
TraceEventType.Verbose,
$"SQL Assessment: running an operation on a server, platform:{server.Platform}, edition:{server.EngineEdition.ToString()}, version:{server.Version}");
result.Items.AddRange(await assessmentFunc(server));
Logger.Write(
TraceEventType.Verbose,
$"SQL Assessment: finished an operation on a server, platform:{server.Platform}, edition:{server.EngineEdition.ToString()}, version:{server.Version}");
break;
case SqlObjectType.Database:
var db = GetDatabaseLocator(server, connection.Database);
Logger.Write(
TraceEventType.Verbose,
$"SQL Assessment: running an operation on a database, platform:{server.Platform}, edition:{server.EngineEdition.ToString()}, version:{server.Version}");
result.Items.AddRange(await assessmentFunc(db));
Logger.Write(
TraceEventType.Verbose,
$"SQL Assessment: finished an operation on a database, platform:{server.Platform}, edition:{server.EngineEdition.ToString()}, version:{server.Version}");
break;
}
result.Success = true;
}
finally
{
ActiveRequests.TryRemove(taskUri, out _);
ConnectionService.Disconnect(new DisconnectParams {
OwnerUri = taskUri, Type = null
});
}
return(result);
}
public void Connection_WrongConnectionProperties()
{
ConnectionService service = new ConnectionService();
Assert.False(service.Connect(String.Empty, String.Empty, String.Empty, String.Empty));
}