/// <summary>
/// Creates and returns a new instance of the <see cref="ServerDataServiceSqlAuth"/> class which
/// connects to the specified server using the specified credentials. If the server name
/// is null, the default server name from the serviceRoot Uri will be used.
/// </summary>
/// <param name="managementServiceUri">The server's management service <see cref="Uri"/>.</param>
/// <param name="sessionActivityId">An activity ID provided by the user that should be associated with this session.</param>
/// <param name="credentials">The credentials to be used to authenticate the user.</param>
/// <param name="serverName">The name of the server to connect to. (Optional)</param>
/// <returns>An instance of <see cref="ServerDataServiceSqlAuth"/> class.</returns>
public static ServerDataServiceSqlAuth Create(
Uri managementServiceUri,
Guid sessionActivityId,
SqlAuthenticationCredentials credentials,
string serverName)
{
if (managementServiceUri == null)
{
throw new ArgumentNullException("managementServiceUri");
}
if (credentials == null)
{
throw new ArgumentNullException("credentials");
}
// Retrieve GetAccessToken operation Uri
Uri accessUri = DataConnectionUtility.GetAccessTokenUri(managementServiceUri);
// Synchronously call GetAccessToken
AccessTokenResult result = DataServiceAccess.GetAccessToken(accessUri, credentials);
// Validate the retrieved access token
AccessTokenResult.ValidateAccessToken(managementServiceUri, result);
// Create and return a ServerDataService object
return(Create(managementServiceUri, sessionActivityId, result, serverName, credentials));
}
/// <summary>
/// Process the command.
/// </summary>
protected override void ProcessRecord()
{
try
{
base.ProcessRecord();
// First obtain the Management Service Uri and the ServerName
Uri manageUrl = this.GetManageUrl(this.ParameterSetName);
Uri managementServiceUri = DataConnectionUtility.GetManagementServiceUri(manageUrl);
string serverName = this.GetServerName(manageUrl);
// Creates a new Server Data Service Context for the service
IServerDataServiceContext operationContext =
this.CreateServerDataServiceContext(serverName, managementServiceUri);
if (operationContext != null)
{
this.WriteObject(operationContext);
}
}
catch (Exception ex)
{
this.WriteError(new ErrorRecord(ex, string.Empty, ErrorCategory.CloseError, null));
}
}
/// <summary>
/// Retrieves the metadata for the context as a <see cref="XDocument"/>
/// </summary>
/// <returns>The metadata for the context as a <see cref="XDocument"/></returns>
public XDocument RetrieveMetadata()
{
// Create a new request Id for this operation
this.clientRequestId = SqlDatabaseCmdletBase.GenerateClientTracingId();
XDocument doc = DataConnectionUtility.GetMetadata(this, EnhanceRequest);
return(doc);
}
/// <summary>
/// Gets a sql auth connection context.
/// </summary>
/// <param name="cmdlet">The cmdlet requesting the context</param>
/// <param name="serverName">The name of the server to connect to</param>
/// <param name="manageUrl">The manage url of the server</param>
/// <param name="credentials">The credentials to connect to the server</param>
/// <param name="sessionActivityId">The session activity ID</param>
/// <param name="managementServiceUri">The URI for management service</param>
/// <returns>The connection context</returns>
public static IServerDataServiceContext GetContext(
PSCmdlet cmdlet,
string serverName,
Uri manageUrl,
SqlAuthenticationCredentials credentials,
Guid sessionActivityId,
Uri managementServiceUri)
{
Version version;
// If a version was specified (by tests) us it.
if (sqlVersion == SqlVersion.v2)
{
version = new Version(11, 0);
}
else if (sqlVersion == SqlVersion.v12)
{
version = new Version(12, 0);
}
else // If no version specified, determine the version by querying the server.
{
version = GetVersion(manageUrl, credentials);
}
sqlVersion = SqlVersion.None;
IServerDataServiceContext context = null;
if (version.Major >= 12)
{
context = new TSqlConnectionContext(
sessionActivityId,
manageUrl.Host,
credentials,
serverName);
}
else
{
context = ServerDataServiceSqlAuth.Create(
managementServiceUri,
sessionActivityId,
credentials,
serverName);
// Retrieve $metadata to verify model version compatibility
XDocument metadata = ((ServerDataServiceSqlAuth)context).RetrieveMetadata();
XDocument filteredMetadata = DataConnectionUtility.FilterMetadataDocument(metadata);
string metadataHash = DataConnectionUtility.GetDocumentHash(filteredMetadata);
if (!((ServerDataServiceSqlAuth)context).metadataHashes.Any(knownHash => metadataHash == knownHash))
{
cmdlet.WriteWarning(Resources.WarningModelOutOfDate);
}
((ServerDataServiceSqlAuth)context).MergeOption = MergeOption.PreserveChanges;
}
return(context);
}
/// <summary>
/// Connect to a Azure Sql Server with the given ManagementService Uri using
/// Sql Authentication credentials.
/// </summary>
/// <param name="serverName">The server name.</param>
/// <param name="managementServiceUri">The server's ManagementService Uri.</param>
/// <param name="credentials">The Sql Authentication credentials for the server.</param>
/// <returns>A new <see cref="ServerDataServiceSqlAuth"/> context,
/// or <c>null</c> if an error occurred.</returns>
internal ServerDataServiceSqlAuth GetServerDataServiceBySqlAuth(
string serverName,
Uri managementServiceUri,
SqlAuthenticationCredentials credentials)
{
ServerDataServiceSqlAuth context = null;
Guid sessionActivityId = Guid.NewGuid();
try
{
context = ServerDataServiceSqlAuth.Create(
managementServiceUri,
sessionActivityId,
credentials,
serverName);
// Retrieve $metadata to verify model version compativility
XDocument metadata = context.RetrieveMetadata();
XDocument filteredMetadata = DataConnectionUtility.FilterMetadataDocument(metadata);
string metadataHash = DataConnectionUtility.GetDocumentHash(filteredMetadata);
if (!context.metadataHashes.Any(knownHash => metadataHash == knownHash))
{
this.WriteWarning(Resources.WarningModelOutOfDate);
}
context.MergeOption = MergeOption.PreserveChanges;
}
catch (Exception ex)
{
SqlDatabaseExceptionHandler.WriteErrorDetails(
this,
sessionActivityId.ToString(),
ex);
// The context is not in an valid state because of the error, set the context
// back to null.
context = null;
}
return(context);
}
