public void GetShouldReturnDefaultAzureServiceGivenDefaultCatalog()
{
// given
ExtensionServiceProvider provider = ExtensionServiceProvider.Create(new Assembly[]
{
typeof(IAccountManager).Assembly,
typeof(IAzureResourceManager).Assembly
});
var serverDefinition = new ServerDefinition("sqlserver", "azure");
// when I query each provider
IServerDiscoveryProvider serverDiscoveryProvider = ExtensionUtils.GetService <IServerDiscoveryProvider>(provider, serverDefinition);
// Then I get a valid provider back
Assert.NotNull(serverDiscoveryProvider);
Assert.True(serverDiscoveryProvider is AzureSqlServerDiscoveryProvider);
IDatabaseDiscoveryProvider databaseDiscoveryProvider =
ExtensionUtils.GetService <IDatabaseDiscoveryProvider>(provider, serverDefinition);
// TODO Verify account manager is detected as soon as the account manager has a real implementation
//IAccountManager accountManager = ((AzureSqlServerDiscoveryProvider)serverDiscoveryProvider).AccountManager;
//Assert.NotNull(accountManager);
//Assert.True(accountManager is IAzureAuthenticationManager);
Assert.NotNull(databaseDiscoveryProvider);
Assert.True(databaseDiscoveryProvider is AzureDatabaseDiscoveryProvider);
}
public SerializationServiceTests()
{
HostMock = new Mock<IProtocolEndpoint>();
ServiceProvider = ExtensionServiceProvider.CreateDefaultServiceProvider();
HostLoader.InitializeHostedServices(ServiceProvider, HostMock.Object);
SerializationService = ServiceProvider.GetService<SerializationService>();
}
private static void InitializeRequestHandlersAndServices(ServiceHost serviceHost, SqlToolsContext sqlToolsContext)
{
// Load extension provider, which currently finds all exports in current DLL. Can be changed to find based
// on directory or assembly list quite easily in the future
ExtensionServiceProvider serviceProvider = ExtensionServiceProvider.CreateDefaultServiceProvider();
serviceProvider.RegisterSingleService(sqlToolsContext);
serviceProvider.RegisterSingleService(serviceHost);
// Initialize and register singleton services so they're accessible for any MEF service. In the future, these
// could be updated to be IComposableServices, which would avoid the requirement to define a singleton instance
// and instead have MEF handle discovery & loading
WorkspaceService <SqlToolsSettings> .Instance.InitializeService(serviceHost);
serviceProvider.RegisterSingleService(WorkspaceService <SqlToolsSettings> .Instance);
LanguageService.Instance.InitializeService(serviceHost, sqlToolsContext);
serviceProvider.RegisterSingleService(LanguageService.Instance);
ConnectionService.Instance.InitializeService(serviceHost);
serviceProvider.RegisterSingleService(ConnectionService.Instance);
CredentialService.Instance.InitializeService(serviceHost);
serviceProvider.RegisterSingleService(CredentialService.Instance);
QueryExecutionService.Instance.InitializeService(serviceHost);
serviceProvider.RegisterSingleService(QueryExecutionService.Instance);
InitializeHostedServices(serviceProvider, serviceHost);
serviceHost.InitializeRequestHandlers();
}
/// <summary>
/// Constructs a new service host intended to be used as a JSON RPC server. StdIn is used
/// for receiving messages, StdOut is used for sending messages. Services will be
/// discovered from the assemblies in the current directory listed in
/// <paramref name="assembliesToInclude"/>
/// </summary>
/// <param name="directory">Directory to include assemblies from</param>
/// <param name="assembliesToInclude">
/// List of assembly names in the current directory to search for service exports
/// </param>
/// <returns>Service host as a JSON RPC server over StdI/O</returns>
public static ExtensibleServiceHost CreateDefaultExtensibleServer(string directory, IList <string> assembliesToInclude)
{
Validate.IsNotNull(nameof(assembliesToInclude), assembliesToInclude);
ExtensionServiceProvider serviceProvider = ExtensionServiceProvider.CreateFromAssembliesInDirectory(directory, assembliesToInclude);
return(new ExtensibleServiceHost(serviceProvider, new StdioServerChannel()));
}
public FormatterUnitTestsBase()
{
HostMock = new Mock <IProtocolEndpoint>();
WorkspaceServiceMock = new Mock <WorkspaceService <SqlToolsSettings> >();
ServiceProvider = ExtensionServiceProvider.CreateDefaultServiceProvider();
ServiceProvider.RegisterSingleService(WorkspaceServiceMock.Object);
HostLoader.InitializeHostedServices(ServiceProvider, HostMock.Object);
FormatterService = ServiceProvider.GetService <TSqlFormatterService>();
}
public void CreateDefaultServiceProviderShouldFindTypesInAllKnownAssemblies()
{
// Given a default ExtensionServiceProvider
// Then we should not find exports from a test assembly
ExtensionServiceProvider serviceProvider = ExtensionServiceProvider.CreateDefaultServiceProvider();
Assert.Empty(serviceProvider.GetServices <MyExportType>());
// But should find exports that are defined in the main assembly
Assert.NotEmpty(serviceProvider.GetServices <ASTNodeFormatterFactory>());
}
public ResourceProviderServiceTests()
{
HostMock = new Mock <IProtocolEndpoint>();
AuthenticationManagerMock = new Mock <IAzureAuthenticationManager>();
ResourceManagerMock = new Mock <IAzureResourceManager>();
ServiceProvider = ExtensionServiceProvider.CreateFromAssembliesInDirectory(ResourceProviderHostLoader.GetResourceProviderExtensionDlls());
ServiceProvider.RegisterSingleService <IAzureAuthenticationManager>(AuthenticationManagerMock.Object);
ServiceProvider.RegisterSingleService <IAzureResourceManager>(ResourceManagerMock.Object);
HostLoader.InitializeHostedServices(ServiceProvider, HostMock.Object);
ResourceProviderService = ServiceProvider.GetService <ResourceProviderService>();
}
public void GetShouldReturnImplementedAzureServiceIfFoundInCatalog()
{
//given
ExtensionServiceProvider provider = ExtensionServiceProvider.Create(typeof(FakeAzureServerDiscoveryProvider).SingleItemAsEnumerable());
//when
IServerDiscoveryProvider serverDiscoveryProvider = ExtensionUtils.GetService <IServerDiscoveryProvider>(provider, new ServerDefinition("sqlserver", "azure"));
Assert.NotNull(serverDiscoveryProvider);
Assert.True(serverDiscoveryProvider is FakeAzureServerDiscoveryProvider);
}
private static void InitializeRequestHandlersAndServices(UtilityServiceHost serviceHost, SqlToolsContext sqlToolsContext)
{
// Load extension provider, which currently finds all exports in current DLL. Can be changed to find based
// on directory or assembly list quite easily in the future
ExtensionServiceProvider serviceProvider = ExtensionServiceProvider.CreateFromAssembliesInDirectory(GetResourceProviderExtensionDlls());
serviceProvider.RegisterSingleService(sqlToolsContext);
serviceProvider.RegisterSingleService(serviceHost);
InitializeHostedServices(serviceProvider, serviceHost);
serviceHost.InitializeRequestHandlers();
}
public void ShouldFindDatabaseQuerierFromRealPath()
{
// Given the extension type loader is set to find SmoCollectionQuerier objects
IMultiServiceProvider serviceProvider = ExtensionServiceProvider.CreateDefaultServiceProvider();
// When I request a database compatible querier
SmoQuerier querier = serviceProvider.GetService <SmoQuerier>(q => q.SupportedObjectTypes.Contains(typeof(Database)));
// Then I expect to get back the SqlDatabaseQuerier
Assert.NotNull(querier);
Assert.Equal(typeof(SqlDatabaseQuerier), querier.GetType());
// And I expect the service provider to have been set by the extension code
Assert.NotNull(querier.ServiceProvider);
}
public void GetGetServiceOfExportableShouldReturnNullGivenSameTypeAsExportable()
{
//given
ExtensionServiceProvider provider = ExtensionServiceProvider.Create(typeof(FakeAzureServerDiscoveryProvider).SingleItemAsEnumerable());
//when
IServerDiscoveryProvider serverDiscoveryProvider = ExtensionUtils.GetService <IServerDiscoveryProvider>(provider, new ServerDefinition("sqlserver", "azure"));
Assert.NotNull(serverDiscoveryProvider);
FakeAzureServerDiscoveryProvider fakeAzureServerDiscovery = serverDiscoveryProvider as FakeAzureServerDiscoveryProvider;
Assert.NotNull(fakeAzureServerDiscovery);
Assert.Null(fakeAzureServerDiscovery.ServerDiscoveryProvider);
}
private SmoQuerier GetSmoQuerier(Type querierType)
{
// Given the extension type loader is set to find SmoCollectionQuerier objects
IMultiServiceProvider serviceProvider = ExtensionServiceProvider.CreateDefaultServiceProvider();
// When I request a compatible querier
SmoQuerier querier = serviceProvider.GetService <SmoQuerier>(q => q.SupportedObjectTypes.Contains(querierType));
// Then I expect to get back the Querier
Assert.NotNull(querier);
// And I expect the service provider to have been set by the extension code
Assert.NotNull(querier.ServiceProvider);
return(querier);
}
private static void InitializeRequestHandlersAndServices(CredentialsServiceHost serviceHost, SqlToolsContext sqlToolsContext)
{
// Load extension provider, which currently finds all exports in current DLL. Can be changed to find based
// on directory or assembly list quite easily in the future
ExtensionServiceProvider serviceProvider = ExtensionServiceProvider.CreateDefaultServiceProvider();
serviceProvider.RegisterSingleService(sqlToolsContext);
serviceProvider.RegisterSingleService(serviceHost);
CredentialService.Instance.InitializeService(serviceHost);
serviceProvider.RegisterSingleService(CredentialService.Instance);
InitializeHostedServices(serviceProvider, serviceHost);
serviceHost.InitializeRequestHandlers();
}
private static void VerifyQuerierLookup(Type smoType, Type querierType, bool expectExists)
{
ExtensionServiceProvider serviceProvider = ExtensionServiceProvider.Create(new Type[] {
typeof(SqlTableQuerier),
typeof(SqlLinkedServerQuerier)
});
SmoQuerier querier = serviceProvider.GetService <SmoQuerier>(q => q.SupportedObjectTypes.Contains(smoType));
if (expectExists)
{
Assert.NotNull(querier);
Assert.Equal(querierType, querier.GetType());
Assert.NotNull(querier.ServiceProvider);
}
else
{
Assert.Null(querier);
}
}
public NodeTests()
{
defaultServerInfo = TestObjects.GetTestServerInfo();
defaultConnectionDetails = new ConnectionDetails()
{
DatabaseName = "master",
ServerName = "localhost",
UserName = "******",
Password = "******"
};
defaultConnParams = new ConnectionCompleteParams()
{
ServerInfo = defaultServerInfo,
ConnectionSummary = defaultConnectionDetails,
OwnerUri = defaultOwnerUri
};
// TODO can all tests use the standard service provider?
ServiceProvider = ExtensionServiceProvider.CreateDefaultServiceProvider();
}
/// <summary>
/// Internal for testing only
/// </summary>
internal ObjectExplorerService(ExtensionServiceProvider serviceProvider)
: this()
{
SetServiceProvider(serviceProvider);
}
static void Main(string[] args)
{
try
{
// read command-line arguments
string applicationName = Path.ChangeExtension(ServiceName, ".exe");
CommandOptions commandOptions = new CommandOptions(args, applicationName);
if (commandOptions.ShouldExit)
{
return;
}
// we are in debug mode
if (commandOptions.WaitForDebugger)
{
int maxWait = 30;
int waitCount = 0;
while (!Debugger.IsAttached && waitCount < maxWait)
{
Thread.Sleep(500);
waitCount++;
}
}
// configure log file
string logFilePath = ServiceName;
if (!string.IsNullOrWhiteSpace(commandOptions.LoggingDirectory))
{
logFilePath = Path.Combine(commandOptions.LoggingDirectory, logFilePath);
}
Logger.Instance.Initialize(logFilePath: logFilePath, minimumLogLevel: MinimumLogLevel, isEnabled: commandOptions.EnableLogging);
Logger.Instance.Write(LogLevel.Normal, "Starting language server host");
// list all service assemblies that should be loaded by the host
string[] searchPath = new string[] {
"Microsoft.SqlTools.Hosting.v2.dll",
//"Microsoft.SqlTools.CoreServices.dll",
"Microsoft.SqlTools.LanguageServerProtocol.dll",
"Microsoft.SqlTools.Samples.LanguageServerHost.Services.dll",
};
ExtensionServiceProvider serviceProvider = ExtensionServiceProvider.CreateFromAssembliesInDirectory(Path.GetDirectoryName(typeof(Program).Assembly.Location), searchPath);
serviceProvider.RegisterSingleService(SettingsService <LanguageServerSettings> .Instance);
ExtensibleServiceHost host = new ExtensibleServiceHost(serviceProvider, new StdioServerChannel());
// TODO: can server capabilities be automatically determined by the registered services?
host.ServerCapabilities = new ServerCapabilities
{
TextDocumentSync = TextDocumentSyncKind.Incremental
};
Logger.Instance.Write(LogLevel.Verbose, "Starting wait loop");
host.Start();
host.WaitForExit();
}
catch (Exception e)
{
Logger.Instance.Write(LogLevel.Error, string.Format("An unhandled exception occurred: {0}", e));
Environment.Exit(1);
}
}
private static void InitializeRequestHandlersAndServices(ServiceHost serviceHost, SqlToolsContext sqlToolsContext)
{
// Load extension provider, which currently finds all exports in current DLL. Can be changed to find based
// on directory or assembly list quite easily in the future
ExtensionServiceProvider serviceProvider = ExtensionServiceProvider.CreateDefaultServiceProvider();
serviceProvider.RegisterSingleService(sqlToolsContext);
serviceProvider.RegisterSingleService(serviceHost);
// Initialize and register singleton services so they're accessible for any MEF service. In the future, these
// could be updated to be IComposableServices, which would avoid the requirement to define a singleton instance
// and instead have MEF handle discovery & loading
WorkspaceService <SqlToolsSettings> .Instance.InitializeService(serviceHost);
serviceProvider.RegisterSingleService(WorkspaceService <SqlToolsSettings> .Instance);
LanguageService.Instance.InitializeService(serviceHost, sqlToolsContext);
serviceProvider.RegisterSingleService(LanguageService.Instance);
ConnectionService.Instance.InitializeService(serviceHost);
serviceProvider.RegisterSingleService(ConnectionService.Instance);
CredentialService.Instance.InitializeService(serviceHost);
serviceProvider.RegisterSingleService(CredentialService.Instance);
QueryExecutionService.Instance.InitializeService(serviceHost);
serviceProvider.RegisterSingleService(QueryExecutionService.Instance);
EditDataService.Instance.InitializeService(serviceHost);
serviceProvider.RegisterSingleService(EditDataService.Instance);
MetadataService.Instance.InitializeService(serviceHost);
serviceProvider.RegisterSingleService(MetadataService.Instance);
ScriptingService.Instance.InitializeService(serviceHost);
serviceProvider.RegisterSingleService(ScriptingService.Instance);
AdminService.Instance.InitializeService(serviceHost);
serviceProvider.RegisterSingleService(AdminService.Instance);
AgentService.Instance.InitializeService(serviceHost);
serviceProvider.RegisterSingleService(AgentService.Instance);
DisasterRecoveryService.Instance.InitializeService(serviceHost);
serviceProvider.RegisterSingleService(DisasterRecoveryService.Instance);
FileBrowserService.Instance.InitializeService(serviceHost);
serviceProvider.RegisterSingleService(FileBrowserService.Instance);
ProfilerService.Instance.InitializeService(serviceHost);
serviceProvider.RegisterSingleService(ProfilerService.Instance);
SecurityService.Instance.InitializeService(serviceHost);
serviceProvider.RegisterSingleService(SecurityService.Instance);
DacFxService.Instance.InitializeService(serviceHost);
serviceProvider.RegisterSingleService(DacFxService.Instance);
CmsService.Instance.InitializeService(serviceHost);
serviceProvider.RegisterSingleService(CmsService.Instance);
SchemaCompare.SchemaCompareService.Instance.InitializeService(serviceHost);
serviceProvider.RegisterSingleService(SchemaCompareService.Instance);
ServerConfigService.Instance.InitializeService(serviceHost);
serviceProvider.RegisterSingleService(ServerConfigService.Instance);
ExternalLanguageService.Instance.InitializeService(serviceHost);
serviceProvider.RegisterSingleService(ExternalLanguageService.Instance);
SqlAssessmentService.Instance.InitializeService(serviceHost);
serviceProvider.RegisterSingleService(SqlAssessmentService.Instance);
InitializeHostedServices(serviceProvider, serviceHost);
serviceHost.ServiceProvider = serviceProvider;
serviceHost.InitializeRequestHandlers();
}
