public override void CreateAuthorizationFile(string answerPath, string fileContents)
{
if (_DnsClient != null)
{
throw new InvalidOperationException($"Old authorization is still pending. Call {nameof(DeleteAuthorization)}() first!");
}
var url = new UrlElements(answerPath);
if (String.IsNullOrWhiteSpace(Program.Options.AzureTenantId))
{
Program.Options.AzureTenantId = RequestViaCommandLine("Enter Azure Tenant ID: ");
}
if (String.IsNullOrWhiteSpace(Program.Options.AzureClientId))
{
Program.Options.AzureClientId = RequestViaCommandLine("Enter Azure Client ID: ");
}
if (String.IsNullOrWhiteSpace(Program.Options.AzureSecret))
{
Program.Options.AzureSecret = RequestViaCommandLine("Enter Azure Secret: ");
}
if (String.IsNullOrWhiteSpace(Program.Options.AzureSubscriptionId))
{
Program.Options.AzureSubscriptionId = RequestViaCommandLine("Enter Azure DNS Subscription ID: ");
}
if (String.IsNullOrWhiteSpace(Program.Options.AzureResourceGroupName))
{
Program.Options.AzureResourceGroupName = RequestViaCommandLine("Enter Azure DNS Resoure Group Name: ");
}
// Build the service credentials and DNS management client
var serviceCreds = ApplicationTokenProvider.LoginSilentAsync(Program.Options.AzureTenantId, Program.Options.AzureClientId, Program.Options.AzureSecret).Result;
_DnsClient = new DnsManagementClient(serviceCreds)
{
SubscriptionId = Program.Options.AzureSubscriptionId
};
// Create record set parameters
var recordSetParams = new RecordSet();
recordSetParams.TTL = 3600;
// Add records to the record set parameter object. In this case, we'll add a record of type 'TXT'
recordSetParams.TxtRecords = new List <TxtRecord>();
recordSetParams.TxtRecords.Add(new TxtRecord(new[] { fileContents }));
// Create the actual record set in Azure DNS
// Note: no ETAG checks specified, will overwrite existing record set if one exists
var recordSet = _DnsClient.RecordSets.CreateOrUpdate(Program.Options.AzureResourceGroupName, url.Domain, url.Subdomain, RecordType.TXT, recordSetParams);
}
static async Task Main(string[] args)
{
var resourceId = $"/subscriptions/{DefaultSubscription}/resourceGroups/XXX";
var credentials = await ApplicationTokenProvider.LoginSilentAsync(
TenantDomain,
ClientId,
ClientSecret);
using (var client = new ResourceManagementClient(credentials))
{
client.SubscriptionId = DefaultSubscription;
try
{
// Create Predefined Tag name and value. Predefined Tags are not automatically
// applied to existing or newly created sub resources.
// Requires contributor permission at subscription level
//var t = await client.Tags.CreateOrUpdateAsync("PredefinedTag1");
//await client.Tags.CreateOrUpdateValueAsync("PredefinedTag1", "DefaultValue");
// Tags operations, only require Tags Contributor
// 1. Create/Update Tags on subscription,
var tags = new TagsResource(
new Tags(
new Dictionary <string, string>
{
{ "environment", DateTimeOffset.Now.ToString() },
{ "department", DateTimeOffset.Now.ToString() },
{ "PredefinedTag1", "override" }
}));
var result = await client.Tags.CreateOrUpdateAtScopeAsync(resourceId, tags);
// 2. Update Tags on resource
var patchTags = new TagsPatchResource(
"Merge", // Replace, Delete
new Tags(
new Dictionary <string, string>
{
{ "environment", DateTimeOffset.Now.ToString() },
{ "department", DateTimeOffset.Now.ToString() },
{ "newTag", DateTimeOffset.Now.ToString() },
}));
result = await client.Tags.UpdateAtScopeAsync(resourceId, patchTags);
// 3. Delete all Tags on the resource
await client.Tags.DeleteAtScopeAsync(resourceId);
}
catch (Exception e)
{
System.Console.WriteLine(e.Message);
}
}
}
public async override Task ProcessHttpRequestAsync(HttpRequestMessage request, CancellationToken cancellationToken)
{
var adSettings = new ActiveDirectoryServiceSettings
{
AuthenticationEndpoint = new Uri(Environment.AuthenticationEndpoint),
TokenAudience = new Uri(Environment.ManagementEnpoint),
ValidateAuthority = true
};
string url = request.RequestUri.ToString();
if (url.StartsWith(Environment.GraphEndpoint, StringComparison.OrdinalIgnoreCase))
{
adSettings.TokenAudience = new Uri(Environment.GraphEndpoint);
}
if (!credentialsCache.ContainsKey(adSettings.TokenAudience))
{
if (servicePrincipalLoginInformation != null)
{
if (servicePrincipalLoginInformation.ClientSecret != null)
{
credentialsCache[adSettings.TokenAudience] = await ApplicationTokenProvider.LoginSilentAsync(
TenantId, servicePrincipalLoginInformation.ClientId, servicePrincipalLoginInformation.ClientSecret, adSettings, TokenCache.DefaultShared);
}
#if NET45
else if (servicePrincipalLoginInformation.X509Certificate != null)
{
credentialsCache[adSettings.TokenAudience] = await ApplicationTokenProvider.LoginSilentAsync(
TenantId, new ClientAssertionCertificate(servicePrincipalLoginInformation.ClientId, servicePrincipalLoginInformation.X509Certificate), adSettings, TokenCache.DefaultShared);
}
#endif
else
{
credentialsCache[adSettings.TokenAudience] = await ApplicationTokenProvider.LoginSilentAsync(
TenantId, servicePrincipalLoginInformation.ClientId, servicePrincipalLoginInformation.Certificate, servicePrincipalLoginInformation.CertificatePassword, TokenCache.DefaultShared);
}
}
#if !PORTABLE
else if (userLoginInformation != null)
{
credentialsCache[adSettings.TokenAudience] = await UserTokenProvider.LoginSilentAsync(
userLoginInformation.ClientId, TenantId, userLoginInformation.UserName,
userLoginInformation.Password, adSettings, TokenCache.DefaultShared);
}
#endif
#if PORTABLE
else if (deviceCredentialInformation != null)
{
credentialsCache[adSettings.TokenAudience] = await UserTokenProvider.LoginByDeviceCodeAsync(
deviceCredentialInformation.ClientId, TenantId, adSettings, TokenCache.DefaultShared, deviceCredentialInformation.DeviceCodeFlowHandler);
}
#endif
}
await credentialsCache[adSettings.TokenAudience].ProcessHttpRequestAsync(request, cancellationToken);
}
private static async Task <MonitorClient> AuthenticateWithReadOnlyClient(string tenantId, string clientId, string secret, string subscriptionId)
{
// Build the service credentials and Monitor client
var serviceCreds = await ApplicationTokenProvider.LoginSilentAsync(tenantId, clientId, secret);
var monitorClient = new MonitorClient(serviceCreds);
monitorClient.SubscriptionId = subscriptionId;
return(monitorClient);
}
static void Main(string[] args)
{
adlsAccountName = "shellpocadlsgen1";
string[] ad = new string[]
{
"[dbo].[item_dim].csv",
"[dbo].[location_dim].csv",
"[dbo].[manufacturer_dim].csv",
"[dbo].[Retail_Sales_Transaction_Data].csv",
"[dbo].[retailer_dim].csv",
"[dbo].[store_dim].csv"
};
string[] src = new string[]
{
"item.csv",
"location.csv",
"manufacturer.csv",
"trans.csv",
"retailer.csv",
"store.csv"
};
subscriptionId = "45110a54-85eb-46b4-8f41-c5d80533039c";
SynchronizationContext.SetSynchronizationContext(new SynchronizationContext());
var domain = "happiestminds.onmicrosoft.com";
var clientId = "98e780fd-9707-4690-a51e-7a05698f3f1e";
var clientSecret = "k0kmlvC7soT3cuwnxYC/10G4lOFQuHt0wt3CIFDPrbM=";
var clientCredential = new ClientCredential(clientId, clientSecret);
var creds = ApplicationTokenProvider.LoginSilentAsync(domain, clientCredential).Result;
adlsClient = new DataLakeStoreAccountManagementClient(creds);
adlsFileSystemClient = new DataLakeStoreFileSystemManagementClient(creds);
adlsClient.SubscriptionId = subscriptionId;
//string sourceFolderPath = @"D:\ADLS\";
//string sourceFolderPath = @"\\192.168.56.1\adls\";
string sourceFolderPath = @"\ADLS\";
string y = DateTime.Now.ToString("yyyy");
string m = DateTime.Now.ToString("MMMM");
string d = DateTime.Now.ToString("dd");
System.Console.WriteLine(y);
System.Console.WriteLine(m);
System.Console.WriteLine(d);
//string dataLakeStoreFolderPath = "/Development/"+y+"/"+m+"/"+d+"/";
string dataLakeStoreFolderPath = "/Development/" + y + "/" + m + "/10/";
for (int i = 0; i < 6; i++)
{
string sourceFilePath = Path.Combine(sourceFolderPath, src[i]);
string dataLakeStoreFilePath = Path.Combine(dataLakeStoreFolderPath, ad[i]);
//adlsFileSystemClient.FileSystem.UploadFile(adlsAccountName, sourceFilePath, dataLakeStoreFilePath, 1, false, true);
adlsFileSystemClient.FileSystem.DownloadFile(adlsAccountName, dataLakeStoreFilePath, sourceFilePath, 1, false, true);
}
Console.WriteLine("6. Finished!");
}
/// <summary>
/// Setsup the super client and returns
/// </summary>
/// <returns></returns>
private static AdlsClient SetupSuperClient()
{
string clientId = SdkUnitTest.ReadSetting("AccountOwnerClientId");
string clientSecret = SdkUnitTest.ReadSetting("AccountOwnerClientSecret");
string domain = SdkUnitTest.ReadSetting("Domain");
string clientAccountPath = SdkUnitTest.ReadSetting("Account");
var creds = new ClientCredential(clientId, clientSecret);
ServiceClientCredentials clientCreds = ApplicationTokenProvider.LoginSilentAsync(domain, creds).GetAwaiter().GetResult();
return(AdlsClient.CreateClient(clientAccountPath, clientCreds));
}
public async Task <MonitorClient> GetMonitorClient()
{
var serviceCreds = await ApplicationTokenProvider.LoginSilentAsync(Default.TenantId, Default.ClientId, Default.Secret);
var monitorClient = new MonitorClient(serviceCreds)
{
SubscriptionId = Default.SubscriptionId
};
return(monitorClient);
}
private async Task <MonitorClient> authenticate(string tenantId, string clientId, string secret, string subscriptionId)
{
var serviceCreds = await ApplicationTokenProvider.LoginSilentAsync(tenantId, clientId, secret);
var monitorClient = new MonitorClient(serviceCreds)
{
SubscriptionId = subscriptionId
};
return(monitorClient);
}
/// <summary>
/// Creates credentials for the Azure Media Service based on credentials from Configuration (appsettings.json)
/// </summary>
/// <returns>Generic asynchronous operation that returns type ServiceClientCredentials</returns>
private static async Task <ServiceClientCredentials> ClientCredentials()
{
if (_clientCredential == null)
{
_clientCredential = new ClientCredential(_configuration.AadClientId, _configuration.AadSecret);
}
return(await
ApplicationTokenProvider
.LoginSilentAsync(_configuration.AadTenantId, _clientCredential, ActiveDirectoryServiceSettings.Azure));
}
// </RunAsync>
/// <summary>
/// Create the ServiceClientCredentials object based on the credentials
/// supplied in local configuration file.
/// </summary>
/// <param name="config">The parm is of type ConfigWrapper. This class reads values from local configuration file.</param>
/// <returns></returns>
// <GetCredentialsAsync>
private static async Task <ServiceClientCredentials> GetCredentialsAsync(ConfigWrapper config)
{
// Use ApplicationTokenProvider.LoginSilentWithCertificateAsync or UserTokenProvider.LoginSilentAsync to get a token using service principal with certificate
//// ClientAssertionCertificate
//// ApplicationTokenProvider.LoginSilentWithCertificateAsync
// Use ApplicationTokenProvider.LoginSilentAsync to get a token using a service principal with symetric key
ClientCredential clientCredential = new ClientCredential(config.AadClientId, config.AadSecret);
return(await ApplicationTokenProvider.LoginSilentAsync(config.AadTenantId, clientCredential, ActiveDirectoryServiceSettings.Azure));
}
private static async Task <IAzureMediaServicesClient> InitializeAmsClient(ServicePrincipalAuth spAuth)
{
ClientCredential clientCredential = new ClientCredential(spAuth.AadClientId, spAuth.AadSecret);
ServiceClientCredentials serviceCredential = await ApplicationTokenProvider.LoginSilentAsync(spAuth.AadTenantId, clientCredential, Helpers.GetActiveDirectoryServiceSettings(spAuth.AADSettings));
return(new AzureMediaServicesClient(spAuth.ArmEndpoint, serviceCredential)
{
SubscriptionId = spAuth.SubscriptionId
});
}
static AzureMediaServicesClient GetV3Client(ConfigWrapper config)
{
ClientCredential clientCredential = new ClientCredential(config.AadClientId, config.AadSecret);
var credentials = ApplicationTokenProvider.LoginSilentAsync(config.AadTenantId, clientCredential, ActiveDirectoryServiceSettings.Azure).Result;
AzureMediaServicesClient v3Client = new AzureMediaServicesClient(config.ArmEndpoint, credentials)
{
SubscriptionId = config.SubscriptionId,
};
return(v3Client);
}
public static ServiceClientCredentials GetCredentialFromCertificate(string clientId, X509Certificate2 cert)
{
SynchronizationContext.SetSynchronizationContext(new SynchronizationContext());
#if net452
return(ApplicationTokenProvider.LoginSilentWithCertificateAsync(DomainOrTenantId, new ClientAssertionCertificate(clientId, cert), ServiceSettings).GetAwaiter().GetResult());
#endif
#if !net452
return(ApplicationTokenProvider.LoginSilentWithCertificateAsync(DomainOrTenantId, new Microsoft.Rest.Azure.Authentication.ClientAssertionCertificate(clientId, cert), ServiceSettings).GetAwaiter().GetResult());
#endif
}
public async Task UpdateDns(CancellationToken cancellationToken)
{
var serviceCreds = await ApplicationTokenProvider.LoginSilentAsync(_securityConfig.TenantId, _securityConfig.ClientId, _securityConfig.ClientSecret);
var dnsClient = new DnsManagementClient(serviceCreds)
{
SubscriptionId = _securityConfig.SubscriptionId
};
var currentIp = await _ipAddressLookup.GetCurrentIdAsync(cancellationToken);
foreach (var recordSetName in _dnsConfig.RecordSetNames)
{
if (cancellationToken.IsCancellationRequested)
{
_logger.LogInformation("Cancellation requested, aborting update");
return;
}
_logger.LogInformation($"Trying to update: {recordSetName}");
try
{
var recordSet = dnsClient.RecordSets.Get(_dnsConfig.ResourceGroupName, _dnsConfig.ZoneName, recordSetName, RecordType.A);
// Add a new record to the local object. Note that records in a record set must be unique/distinct
// first we check if we need to update - no need to do it all the time
var currentARecord = recordSet.ARecords.FirstOrDefault();
if (currentARecord != null)
{
if (currentARecord.Ipv4Address.Equals(currentIp))
{
_logger.LogInformation("Current IP already set, trying next recordset.");
continue;
}
}
recordSet.ARecords.Clear();
recordSet.ARecords.Add(new ARecord(currentIp));
// Update the record set in Azure DNS
// Note: ETAG check specified, update will be rejected if the record set has changed in the meantime
recordSet = await dnsClient.RecordSets.CreateOrUpdateAsync(_dnsConfig.ResourceGroupName, _dnsConfig.ZoneName, recordSetName, RecordType.A, recordSet, recordSet.Etag, cancellationToken : cancellationToken);
_logger.LogInformation($"Success - {recordSetName}");
}
catch (System.Exception e)
{
_logger.LogError(e, $"Failed - {recordSetName}");
}
}
}
private AzureMediaServicesClient GetAzureMediaServicesClient()
{
var clientCredential =
new ClientCredential(_clientSettings?.AadClientId, _clientSettings?.AadSecret);
var serviceClientCredentials = ApplicationTokenProvider.LoginSilentAsync(_clientSettings?.AadTenantId,
clientCredential, ActiveDirectoryServiceSettings.Azure).Result;
return(new AzureMediaServicesClient(_clientSettings?.ArmEndpoint, serviceClientCredentials)
{
SubscriptionId = _clientSettings?.SubscriptionId
});
}
private static ServiceClientCredentials GetCredsServicePrincipalSecretKey(string domain, Uri tokenAudience, string clientId, string secretKey)
{
SynchronizationContext.SetSynchronizationContext(new SynchronizationContext());
var serviceSettings = ActiveDirectoryServiceSettings.Azure;
serviceSettings.TokenAudience = tokenAudience;
var creds = ApplicationTokenProvider.LoginSilentAsync(domain, clientId, secretKey, serviceSettings).GetAwaiter().GetResult();
return(creds);
}
public ArmApi(string oid, HttpControllerContext ctx)
{
var task = Task.Run(async() => {
//_token was used for delegated user auth
//_token = await AdalLib.GetAccessToken(oid, ctx, "https://management.azure.com");
// Build the service credentials and DNS management client
_serviceCreds = await ApplicationTokenProvider.LoginSilentAsync(Settings.LabAdminTenantId, Settings.LabAdminClientId, Settings.LabAdminSecret);
_isInit = true;
});
task.Wait();
}
private async Task <ServiceClientCredentials> GetCredentialsAsync()
{
// Use ApplicationTokenProvider.LoginSilentAsync to get a token using a service principal with symmetric key
var clientCredential = new ClientCredential(
_amsSettings.AadClientId,
_amsSettings.AadSecret);
return(await ApplicationTokenProvider.LoginSilentAsync(
_amsSettings.AadTenantId,
clientCredential,
ActiveDirectoryServiceSettings.Azure));
}
public static async Task <HttpResponseMessage> Run(
[HttpTrigger(AuthorizationLevel.Function, "get", Route = null)] HttpRequest req,
ILogger log)
{
string ip = req.GetQueryParameterDictionary()
.FirstOrDefault(q => string.Compare(q.Key, "ip", true) == 0)
.Value;
IPAddress ipAddress;
if (ip == null || !IPAddress.TryParse(ip, out ipAddress))
{
return(new HttpResponseMessage(HttpStatusCode.BadRequest));
}
log.LogInformation("IP update request received: " + ip);
// Build the service credentials and DNS management client
var tenantId = Environment.GetEnvironmentVariable("TenantId");
var clientId = Environment.GetEnvironmentVariable("AppId");
var secret = Environment.GetEnvironmentVariable("AppSecret");
var subscriptionId = Environment.GetEnvironmentVariable("SubscriptionId");
var resourceGroupName = Environment.GetEnvironmentVariable("ResourceGroupName");
var zoneName = Environment.GetEnvironmentVariable("ZoneName");
var recordSetName = Environment.GetEnvironmentVariable("RecordSetName");
var serviceCreds = await ApplicationTokenProvider.LoginSilentAsync(tenantId, clientId, secret);
var dnsClient = new DnsManagementClient(serviceCreds);
dnsClient.SubscriptionId = subscriptionId;
var recordSet = dnsClient.RecordSets.Get(resourceGroupName, zoneName, recordSetName, RecordType.A);
// Add a new record to the local object. Note that records in a record set must be unique/distinct
var currentIp = recordSet.ARecords[0].Ipv4Address;
if (currentIp != ip)
{
recordSet.ARecords[0].Ipv4Address = ip;
// Update the record set in Azure DNS
// Note: ETAG check specified, update will be rejected if the record set has changed in the meantime
recordSet = await dnsClient.RecordSets.CreateOrUpdateAsync(resourceGroupName, zoneName, recordSetName, RecordType.A, recordSet, recordSet.Etag);
log.LogInformation("IP changed from " + currentIp + " to " + ip);
return(new HttpResponseMessage(HttpStatusCode.OK));
}
return(new HttpResponseMessage(HttpStatusCode.Accepted));
}
public static async Task <AzureMediaServicesClient> GetClientAsync(ConfigurationModel config)
{
ClientCredential clientCredentials = new ClientCredential(config.ClientId, config.ClientSecret);
ServiceClientCredentials appCredentials = await ApplicationTokenProvider.LoginSilentAsync(config.TenantId, clientCredentials, ActiveDirectoryServiceSettings.Azure);
AzureMediaServicesClient client = new AzureMediaServicesClient(config.ManagementEndpoint, appCredentials)
{
SubscriptionId = config.SubscriptionId,
};
LoggerService.Info("Created authorization client", LoggerService.Bootstrapping);
return(client);
}
/// <summary>
/// Returns a task representing the attempt to log in to Azure public as the specified
/// service principal, with the specified credential.
/// </summary>
/// <param name="certificateThumbprint"></param>
/// <returns></returns>
public static Task <ServiceClientCredentials> GetServiceCredentialsAsync(string tenantId, string applicationId, string appSecret)
{
if (_servicePrincipalCredential == null)
{
_servicePrincipalCredential = new ClientCredential(applicationId, appSecret);
}
return(ApplicationTokenProvider.LoginSilentAsync(
tenantId,
_servicePrincipalCredential,
ActiveDirectoryServiceSettings.Azure,
TokenCache.DefaultShared));
}
public Azure(Target target, AzureOptions options, DomainParser domainParser, ILookupClientProvider lookupClientProvider, ILogService log, string identifier) : base(domainParser, lookupClientProvider, log, options, identifier)
{
// Build the service credentials and DNS management client
var serviceCreds = ApplicationTokenProvider.LoginSilentAsync(
_options.TenantId,
_options.ClientId,
_options.Secret).Result;
_dnsClient = new DnsManagementClient(serviceCreds)
{
SubscriptionId = _options.SubscriptionId
};
}
public Azure(Target target)
{
// Build the service credentials and DNS management client
var serviceCreds = ApplicationTokenProvider.LoginSilentAsync(
target.DnsAzureOptions.TenantId,
target.DnsAzureOptions.ClientId,
target.DnsAzureOptions.Secret).Result;
_DnsClient = new DnsManagementClient(serviceCreds)
{
SubscriptionId = target.DnsAzureOptions.SubscriptionId
};
}
private SecretKeyAdlsCredentials([Parameter(typeof(Tenant))] string tenant,
[Parameter(typeof(TokenAudience))] string tokenAudience,
[Parameter(typeof(ClientId))] string clientId,
[Parameter(typeof(SecretKey))] string secretKey)
{
SynchronizationContext.SetSynchronizationContext(new SynchronizationContext());
var serviceSettings = ActiveDirectoryServiceSettings.Azure;
serviceSettings.TokenAudience = new Uri(tokenAudience);
Credentials = ApplicationTokenProvider.LoginSilentAsync(tenant, clientId, secretKey, serviceSettings).Result;
}
private static ServiceClientCredentials GetCredsServicePrincipalCertificate(string domain, Uri tokenAudience, string clientId, X509Certificate2 certificate)
{
SynchronizationContext.SetSynchronizationContext(new SynchronizationContext());
var clientAssertionCertificate = new Microsoft.IdentityModel.Clients.ActiveDirectory.ClientAssertionCertificate(clientId, certificate);
var serviceSettings = ActiveDirectoryServiceSettings.Azure;
serviceSettings.TokenAudience = tokenAudience;
var creds = ApplicationTokenProvider.LoginSilentWithCertificateAsync(domain, clientAssertionCertificate, serviceSettings).GetAwaiter().GetResult();
return(creds);
}
internal MediaStorage(MediaAccount mediaAccount, MediaStorageAccount storageAccount) : base(storageAccount.Type, storageAccount.Id)
{
ServiceClientCredentials clientCredentials = ApplicationTokenProvider.LoginSilentAsync(mediaAccount.DirectoryTenantId, mediaAccount.ServicePrincipalId, mediaAccount.ServicePrincipalKey).Result;
StorageManagementClient storageClient = new StorageManagementClient(clientCredentials)
{
SubscriptionId = mediaAccount.SubscriptionId
};
_storageAccountName = Path.GetFileName(storageAccount.Id);
IEnumerable <StorageAccount> storageAccounts = storageClient.StorageAccounts.List();
storageAccounts = storageAccounts.Where(s => s.Name.Equals(_storageAccountName, StringComparison.OrdinalIgnoreCase));
_storageAccount = storageAccounts.SingleOrDefault();
}
private async Task CreateMediaServiceClient()
{
var clientCredential = new ClientCredential(aadClientId, aadSecret);
var token = await ApplicationTokenProvider.LoginSilentAsync(
aadTenantId,
clientCredential,
ActiveDirectoryServiceSettings.Azure);
mediaServiceClient = new AzureMediaServicesClient(token)
{
SubscriptionId = subscriptionId
};
}
public bool RunLAQuery(string tableName)
{
try
{
// Get credentials fron config.json
var appConfig = new AppConfig();
var credentials = appConfig.GetCredentials();
customerId = credentials["workspaceId"];
clientId = credentials["clientId"];
clientSecret = credentials["clientSecret"];
domain = credentials["domain"];
var authEndpoint = "https://login.microsoftonline.com";
var tokenAudience = "https://api.loganalytics.io/";
var adSettings = new ActiveDirectoryServiceSettings
{
AuthenticationEndpoint = new Uri(authEndpoint),
TokenAudience = new Uri(tokenAudience),
ValidateAuthority = true
};
var creds = ApplicationTokenProvider.LoginSilentAsync(domain, clientId, clientSecret, adSettings).GetAwaiter().GetResult();
var laClient = new OperationalInsightsDataClient(creds);
laClient.WorkspaceId = customerId;
var path = new SampleDataPath();
var dirPath = path.GetDirPath();
tableName = tableName.Replace(dirPath, "").Replace(".json", "");
string query = tableName
+ @"| where TimeGenerated > ago(10d)
| limit 100";
var results = laClient.Query(query);
var tableCount = results.Tables.Count;
if (tableCount > 0)
{
return(true);
}
else
{
return(false);
}
}
catch (Exception ex)
{
throw new Exception("Calling Log Analytics Error " + ex.Message);
}
}
public void ValidApplicationCredentialsAuthenticateCorrectly()
{
var cache = new TestTokenCache();
var credentials = ApplicationTokenProvider.LoginSilentAsync(this._domain, this._applicationId, this._secret, cache).GetAwaiter().GetResult();
var client = new HttpClient();
var request = new HttpRequestMessage(HttpMethod.Get,
new Uri("https://management.azure.com/subscriptions?api-version=2014-04-01-preview"));
credentials.ProcessHttpRequestAsync(request, CancellationToken.None).Wait();
Assert.NotNull(request.Headers.Authorization);
var response = client.SendAsync(request).ConfigureAwait(false).GetAwaiter().GetResult();
Assert.Equal(HttpStatusCode.OK, response.StatusCode);
}
private async Task <ServiceClientCredentials> GetCredentialsAsync()
{
// Use ApplicationTokenProvider.LoginSilentWithCertificateAsync or UserTokenProvider.LoginSilentAsync to get a token using service principal with certificate
//// ClientAssertionCertificate
//// ApplicationTokenProvider.LoginSilentWithCertificateAsync
// Use ApplicationTokenProvider.LoginSilentAsync to get a token using a service principal with symmetric key
var aadClientId = "ff79ecc9-27de-43ef-91ac-f0daf5263db6";
var aadClientSecret = "8i2o07Zzl0MRgjov-M6mc.q9i~_ogAsa19";
ClientCredential clientCredential = new ClientCredential(aadClientId, aadClientSecret);
var aadTenantId = "1d9ed556-b09d-48f2-a5ba-173b21b5fea8";
return(await ApplicationTokenProvider.LoginSilentAsync(aadTenantId, clientCredential, ActiveDirectoryServiceSettings.Azure));
}
