public AzureTableServiceContext(string baseAddress, StorageCredentials credentials, IConverter converter)
: base(baseAddress, credentials)
{
_converter = converter;
WritingEntity += OnWritingEntity;
ReadingEntity += OnReadingEntity;
}
internal static void CheckAllowInsecureEndpoints(bool allowInsecureRemoteEndpoints, StorageCredentials info, Uri baseUri)
{
if (info == null)
{
throw new ArgumentNullException("info");
}
if (allowInsecureRemoteEndpoints)
{
return;
}
if (baseUri == null || string.IsNullOrEmpty(baseUri.Scheme))
{
throw new SecurityException("allowInsecureRemoteEndpoints is set to false (default setting) but the endpoint URL seems to be empty or there is no URL scheme." +
"Please configure the provider to use an https enpoint for the storage endpoint or " +
"explicitly set the configuration option allowInsecureRemoteEndpoints to true.");
}
if (baseUri.Scheme.ToUpper(CultureInfo.InvariantCulture) == Uri.UriSchemeHttps.ToUpper(CultureInfo.InvariantCulture))
{
return;
}
if (baseUri.IsLoopback)
{
return;
}
throw new SecurityException("The provider is configured with allowInsecureRemoteEndpoints set to false (default setting) but the endpoint for " +
"the storage system does not seem to be an https or local endpoint. " +
"Please configure the provider to use an https enpoint for the storage endpoint or " +
"explicitly set the configuration option allowInsecureRemoteEndpoints to true.");
}
public ComplexTypeTableServiceContext(string baseAddress, StorageCredentials credentials)
: base(baseAddress, credentials)
{
IgnoreMissingProperties = true;
ReadingEntity += OnReadingEntity;
WritingEntity += OnWritingEntity;
}
public EncryptionService()
{
var storageAccount = Microsoft.WindowsAzure.CloudStorageAccount.Parse(ConfigurationManager.ConnectionStrings["StorageConnectionString"].ConnectionString);
_baseAddress = storageAccount.TableEndpoint.AbsoluteUri;
_credentials = storageAccount.Credentials;
var section = (NameValueCollection)WebConfigurationManager.GetSection("encryption");
LoadCertificateByThumbprint(section["certificateThumbprint"]);
}
/// <summary>
/// Get analytics settings
/// </summary>
/// <param name="baseUri"></param>
/// <param name="credentials"></param>
/// <param name="useSharedKeyLite"></param>
/// <returns></returns>
public static AnalyticsSettings GetSettings(Uri baseUri, StorageCredentials credentials, bool useSharedKeyLite)
{
UriBuilder builder = new UriBuilder(baseUri);
builder.Query = string.Format(
CultureInfo.InvariantCulture,
"comp=properties&restype=service&timeout={0}",
DefaultTimeout.TotalSeconds);
HttpWebRequest request = (HttpWebRequest)HttpWebRequest.Create(builder.Uri);
request.Headers.Add(VersionHeaderName, Sep2009Version);
request.Method = "GET";
StorageCredentialsAccountAndKey accountAndKey = credentials as StorageCredentialsAccountAndKey;
if (useSharedKeyLite)
{
credentials.SignRequestLite(request);
}
else
{
credentials.SignRequest(request);
}
try
{
using (HttpWebResponse response = (HttpWebResponse)request.GetResponse())
{
Console.WriteLine("Response Request Id={0} Status={1}", response.Headers[RequestIdHeaderName], response.StatusCode);
if (HttpStatusCode.OK != response.StatusCode)
{
throw new Exception("expected HttpStatusCode.OK");
}
using (Stream stream = response.GetResponseStream())
{
using (StreamReader streamReader = new StreamReader(stream))
{
string responseString = streamReader.ReadToEnd();
Console.WriteLine(responseString);
XmlReader reader = XmlReader.Create(new MemoryStream(ASCIIEncoding.UTF8.GetBytes(responseString)));
return SettingsSerializerHelper.DeserializeAnalyticsSettings(reader);
}
}
}
}
catch (WebException e)
{
Console.WriteLine(
"Response Request Id={0} Status={1}",
e.Response != null ? e.Response.Headers[RequestIdHeaderName] : "Response is null",
e.Status);
throw;
}
}
public MetaDataContext(string baseAddress, StorageCredentials credentials)
: base(baseAddress, credentials)
{
// Alternative method of creating table
//CloudTableClient.CreateTablesFromModel(typeof(MetaDataContext),
// baseAddress, credentials);
// Prevent DataServiceQueryException when no records
// match a query
IgnoreResourceNotFoundException = true;
}
public static StorageServiceProperties GetServiceProperties(Uri baseUri, StorageCredentials creds, bool useSharedKeyLite)
{
var req = CreateServicePropertiesRequest(baseUri);
if (useSharedKeyLite) creds.SignRequestLite(req);
else creds.SignRequest(req);
using (var response = req.GetResponse())
using (var stream = response.GetResponseStream())
{
return (StorageServiceProperties)new XmlSerializer(typeof(StorageServiceProperties)).Deserialize(stream);
}
}
public static AzureContainer Connect(string containerName, string blobEndpointUri,
StorageCredentials credentials)
{
// Requirements
Require.NotEmpty(containerName, "containerName");
Require.NotEmpty(blobEndpointUri, "blobEndpointUri");
Require.NotNull(credentials, "credentials");
var blobClient = CreateBlobClient(blobEndpointUri, credentials);
var container = CreateContainer(containerName, blobClient);
return new AzureContainer(blobClient, container);
}
public SymmetricKeyService(string baseAddress, StorageCredentials credentials, X509Certificate2 certificate)
{
_certificate = certificate;
try
{
if (credentials != null)
{
_context = new SymmetricKeyContext(baseAddress, credentials);
}
}
catch (Exception ex)
{
throw ex;
}
}
private static AzureContainer SetupBlobContainer(string containerName, string blobEndpointUri, StorageCredentials credentials)
{
PrintStep("Creating " + containerName + " blob container...");
AzureContainer.Create(containerName, blobEndpointUri, credentials);
var container = AzureContainer.Connect(containerName, blobEndpointUri, credentials);
if (_doReset)
{
PrintStep(" * Resetting its content");
container.Clear();
}
PrintStep(" * Setting permissions up");
container.Permissions.PublicAccess = BlobContainerPublicAccessType.Off;
return container;
}
public TaskDataContext(string baseAddress, StorageCredentials credentials)
: base(baseAddress, credentials)
{
// we are setting up a dictionary of types to resolve in order
// to workaround a performance bug in astoria during serialization
this.resolverTypes = new Dictionary<string, Type>();
this.resolverTypes.Add(TaskTable, typeof(TaskRow));
this.resolverTypes.Add(TaskListTable, typeof(TaskListRow));
this.ResolveType = name =>
{
var parts = name.Split('.');
if (parts.Length == 2)
{
return resolverTypes[parts[1]];
}
return null;
};
}
public static void SetServiceProperties(Uri baseUri, StorageCredentials creds, StorageServiceProperties properties, bool useSharedKeyLite)
{
var req = CreateServicePropertiesRequest(baseUri);
req.Method = "PUT";
var ms = new MemoryStream();
new XmlSerializer(typeof(StorageServiceProperties)).Serialize(ms, properties);
ms.Position = 0;
req.ContentLength = ms.Length;
if (useSharedKeyLite) creds.SignRequestLite(req);
else creds.SignRequest(req);
using (var stream = req.GetRequestStream())
{
ms.CopyTo(stream);
}
using (var response = (HttpWebResponse)req.GetResponse())
{
if (response.StatusCode != HttpStatusCode.Accepted)
{
throw new Exception("Request failed to return 202 status code.");
}
}
}
public TestContext(string tableEndpoint, StorageCredentials credentials)
: base(tableEndpoint, credentials)
{
}
public SampleArchTableContext(string baseAddress, StorageCredentials credentials)
: base(baseAddress, credentials)
{
}
public FtpAccountDataContext(string baseAddress, StorageCredentials credentials)
: base(baseAddress, credentials)
{
var tableStorage = new CloudTableClient(baseAddress, credentials);
tableStorage.CreateTableIfNotExist("AzureFtpAccount");
}
public SymmetricKeyContext(string baseAddress, StorageCredentials credentials)
: base(baseAddress, credentials)
{
var storageAccount = Microsoft.WindowsAzure.CloudStorageAccount.Parse(ConfigurationManager.ConnectionStrings["StorageConnectionString"].ConnectionString);
var client = storageAccount.CreateCloudTableClient().CreateTableIfNotExist("SymmetricKeys");
}
public PlaybookTableContext(string baseAddress, StorageCredentials credentials)
: base(baseAddress, credentials)
{
}
public ViewDataContext(string baseAddress, StorageCredentials credentials)
: base(baseAddress)
{
}
public FunnyAppContext(string baseAddress, StorageCredentials credentials)
: base(baseAddress, credentials)
{
}
public EmailQueueClient(string baseAddress, StorageCredentials credentials, string queueName)
: base(baseAddress, credentials)
{
_queueName = queueName;
}
public MessageDataServiceContext(string baseAddress, StorageCredentials credentials)
: base(baseAddress, credentials)
{
}
public TrackPointsHistoryContext(string baseAddress, StorageCredentials credentials)
: base(baseAddress, credentials)
{
}
/// <summary>
/// Set analytics settings
/// </summary>
/// <param name="baseUri"></param>
/// <param name="credentials"></param>
/// <param name="settings"></param>
/// <param name="useSharedKeyLite"></param>
public static void SetSettings(Uri baseUri, StorageCredentials credentials, AnalyticsSettings settings, Boolean useSharedKeyLite)
{
UriBuilder builder = new UriBuilder(baseUri);
builder.Query = string.Format(
CultureInfo.InvariantCulture,
"comp=properties&restype=service&timeout={0}",
DefaultTimeout.TotalSeconds);
HttpWebRequest request = (HttpWebRequest)HttpWebRequest.Create(builder.Uri);
request.Headers.Add(VersionHeaderName, Sep2009Version);
request.Method = "PUT";
StorageCredentialsAccountAndKey accountAndKey = credentials as StorageCredentialsAccountAndKey;
using (MemoryStream buffer = new MemoryStream())
{
XmlTextWriter writer = new XmlTextWriter(buffer, Encoding.UTF8);
SettingsSerializerHelper.SerializeAnalyticsSettings(writer, settings);
writer.Flush();
buffer.Seek(0, SeekOrigin.Begin);
request.ContentLength = buffer.Length;
if (useSharedKeyLite)
{
credentials.SignRequestLite(request);
}
else
{
credentials.SignRequest(request);
}
using (Stream stream = request.GetRequestStream())
{
stream.Write(buffer.GetBuffer(), 0, (int)buffer.Length);
}
try
{
using (HttpWebResponse response = (HttpWebResponse)request.GetResponse())
{
Console.WriteLine("Response Request Id = {0} Status={1}", response.Headers[RequestIdHeaderName], response.StatusCode);
if (HttpStatusCode.Accepted != response.StatusCode)
{
throw new Exception("Request failed with incorrect response status.");
}
}
}
catch (WebException e)
{
Console.WriteLine(
"Response Request Id={0} Status={1}",
e.Response != null ? e.Response.Headers[RequestIdHeaderName] : "Response is null",
e.Status);
throw;
}
}
}
public MsdnQueue(string baseAddress, StorageCredentials credentials)
: base(baseAddress, credentials)
{
}
public WindowsAzureLogDataServiceContext(string baseAddress, StorageCredentials credentials)
: base(baseAddress, credentials)
{
}
public DatasetInfoDataContext(string baseAddress, StorageCredentials credentials)
: base(baseAddress, credentials)
{
}
public ExpenseDataContext(string baseAddress, StorageCredentials credentials)
: base(baseAddress, credentials)
{
ResolveType = ResolveEntityType;
}
internal static string GetInitExceptionDescription(StorageCredentials credentials, Uri tableBaseUri, Uri blobBaseUri)
{
StringBuilder builder = new StringBuilder();
builder.Append(GetInitExceptionDescription(credentials, tableBaseUri, "table storage configuration"));
builder.Append(GetInitExceptionDescription(credentials, blobBaseUri, "blob storage configuration"));
return builder.ToString();
}
/// <summary>
/// Create an instance of the FollowerDataContext class
/// and initialize the base
/// class with storage access information.
/// </summary>
/// <param name="baseAddress"></param>
/// <param name="credentials"></param>
public FollowerDataContext(string baseAddress, StorageCredentials credentials)
: base(baseAddress, credentials)
{
}
internal static string GetInitExceptionDescription(StorageCredentials info, Uri baseUri, string desc)
{
StringBuilder builder = new StringBuilder();
builder.Append("The reason for this exception is typically that the endpoints are not correctly configured. " + Environment.NewLine);
if (info == null)
{
builder.Append("The current " + desc + " is null. Please specify a table endpoint!" + Environment.NewLine);
}
else
{
builder.Append("The current " + desc + " is: " + baseUri + Environment.NewLine);
builder.Append("Please also make sure that the account name and the shared key are specified correctly. This information cannot be shown here because of security reasons.");
}
return builder.ToString();
}