protected override void ProcessRecord()
{
if (ParameterSetName.Equals(BlobParameterSetName, StringComparison.InvariantCultureIgnoreCase))
{
var toAdd = new StorageAccount
{
Name = Blob,
Properties = new StorageAccountProperties
{
AccessKey = AccessKey
}
};
DataLakeAnalyticsClient.AddStorageAccount(ResourceGroupName, Account, toAdd);
}
else
{
var toAdd = new DataLakeStoreAccount
{
Name = DataLakeStore
};
DataLakeAnalyticsClient.AddDataLakeStoreAccount(ResourceGroupName, Account, toAdd);
if (Default)
{
DataLakeAnalyticsClient.SetDefaultDataLakeStoreAccount(ResourceGroupName, Account, toAdd);
}
}
}
public override void ExecuteCmdlet()
{
if (string.IsNullOrEmpty(Name))
{
ConfirmAction(
Force.IsPresent,
string.Format(Resources.RemovingDataLakeAnalyticsCatalogSecrets, DatabaseName),
string.Format(Resources.RemoveDataLakeAnalyticsCatalogSecrets, DatabaseName),
DatabaseName,
() =>
{
DataLakeAnalyticsClient.DeleteSecret(Account, DatabaseName, Name);
if (PassThru)
{
WriteObject(true);
}
});
}
else
{
ConfirmAction(
Force.IsPresent,
string.Format(Resources.RemovingDataLakeAnalyticsCatalogSecret, Name),
string.Format(Resources.RemoveDataLakeAnalyticsCatalogSecret, Name),
Name,
() =>
{
DataLakeAnalyticsClient.DeleteSecret(Account, DatabaseName, Name);
if (PassThru)
{
WriteObject(true);
}
});
}
}
public override void ExecuteCmdlet()
{
if (ParameterSetName.Equals(BlobParameterSetName, StringComparison.InvariantCultureIgnoreCase))
{
var toAdd = new StorageAccount
{
Name = Blob,
Properties = new StorageAccountProperties
{
AccessKey = AccessKey
}
};
DataLakeAnalyticsClient.SetStorageAccount(ResourceGroupName, Account, toAdd);
}
else if (Default)
{
var toAdd = new DataLakeStoreAccount
{
Name = DataLakeStore
};
DataLakeAnalyticsClient.SetDefaultDataLakeStoreAccount(ResourceGroupName, Account, toAdd);
}
else
{
WriteWarning(Resources.InvalidDataLakeStoreAccountModificationAttempt);
}
}
public override void ExecuteCmdlet()
{
if (ParameterSetName.Equals(DataLakeParameterSetName, StringComparison.InvariantCultureIgnoreCase))
{
ConfirmAction(
Force.IsPresent,
string.Format(Resources.RemovingDataLakeAnalyticsDataLakeStore, DataLakeStore),
string.Format(Resources.RemoveDataLakeAnalyticsCatalogSecret, DataLakeStore),
DataLakeStore,
() =>
{
DataLakeAnalyticsClient.RemoveDataLakeStoreAccount(ResourceGroupName, Account, DataLakeStore);
if (PassThru)
{
WriteObject(true);
}
});
}
else
{
ConfirmAction(
Force.IsPresent,
string.Format(Resources.RemovingDataLakeAnalyticsBlobAccount, Blob),
string.Format(Resources.RemoveDataLakeAnalyticsBlobAccount, Blob),
Blob,
() =>
{
DataLakeAnalyticsClient.RemoveStorageAccount(ResourceGroupName, Account, Blob);
if (PassThru)
{
WriteObject(true);
}
});
}
}
public override void ExecuteCmdlet()
{
string[] requiredAceTypes;
switch (ParameterSetName)
{
case BaseCatalogParameterSetName:
case BaseCatalogItemParameterSetName:
requiredAceTypes = new[] { AclType.User, AclType.Group, AclType.Other };
break;
case UserOwnerCatalogParameterSetName:
case UserOwnerCatalogItemParameterSetName:
requiredAceTypes = new[] { AclType.UserObj };
break;
case GroupOwnerCatalogParameterSetName:
case GroupOwnerCatalogItemParameterSetName:
requiredAceTypes = new[] { AclType.GroupObj };
break;
default: throw new ArgumentException($"Invalid parameter set: {this.ParameterSetName}");
}
var toReturn = DataLakeAnalyticsClient.GetCatalogItemAclEntry(Account, Path, ItemType, requiredAceTypes).Select(acl => new PSDataLakeAnalyticsAcl(acl)).ToList();
if (toReturn.Count == 1)
{
WriteObject(toReturn[0]);
}
else
{
WriteObject(toReturn, true);
}
}
public override void ExecuteCmdlet()
{
if (ParameterSetName.Equals(BlobParameterSetName, StringComparison.InvariantCultureIgnoreCase))
{
var toAdd = new StorageAccountInfo
{
Name = Blob,
Properties = new StorageAccountProperties
{
AccessKey = AccessKey
}
};
DataLakeAnalyticsClient.AddStorageAccount(ResourceGroupName, Account, toAdd);
}
else
{
var toAdd = new DataLakeStoreAccountInfo
{
Name = DataLakeStore,
Properties = new DataLakeStoreAccountInfoProperties()
};
DataLakeAnalyticsClient.AddDataLakeStoreAccount(ResourceGroupName, Account, toAdd);
if (Default)
{
DataLakeAnalyticsClient.SetDefaultDataLakeStoreAccount(ResourceGroupName, Account, toAdd);
}
}
}
public override void ExecuteCmdlet()
{
// We only support updates for Storage accounts.
var toAdd = new UpdateStorageAccountParameters
{
AccessKey = AccessKey
};
DataLakeAnalyticsClient.SetStorageAccount(ResourceGroupName, Account, Blob, toAdd);
}
public override void ExecuteCmdlet()
{
ConfirmAction(
string.Format(Resources.AddDataLakeFirewallRule, Name),
Name,
() =>
WriteObject(new DataLakeAnalyticsFirewallRule(DataLakeAnalyticsClient.AddOrUpdateFirewallRule(
ResourceGroupName, Account, Name, StartIpAddress, EndIpAddress, this)))
);
}
public override void ExecuteCmdlet()
{
if (string.IsNullOrEmpty(Name))
{
WriteObject(DataLakeAnalyticsClient.ListComputePolicy(ResourceGroupName, Account), true);
}
else
{
WriteObject(DataLakeAnalyticsClient.GetComputePolicy(ResourceGroupName, Account, Name));
}
}
public override void ExecuteCmdlet()
{
if (ParameterSetName.Equals(BaseParameterSetName))
{
WriteObject(DataLakeAnalyticsClient.ListJobRecurrence(Account, SubmittedAfter, SubmittedBefore), true);
}
else
{
WriteObject(DataLakeAnalyticsClient.GetJobReccurence(Account, RecurrenceId, SubmittedAfter, SubmittedBefore));
}
}
protected override void ProcessRecord()
{
if (ParameterSetName.Equals(DataLakeParameterSetName, StringComparison.InvariantCultureIgnoreCase))
{
DataLakeAnalyticsClient.RemoveStorageAccount(ResourceGroupName, Account, Blob);
}
else
{
DataLakeAnalyticsClient.RemoveDataLakeStoreAccount(ResourceGroupName, Account, DataLakeStore);
}
}
public override void ExecuteCmdlet()
{
if (Uri != null && Uri.Port <= 0)
{
WriteWarning(string.Format(Resources.NoPortSpecified, Uri));
}
var toUse = Uri ?? new Uri(string.Format("https://{0}:{1}", DatabaseHost, Port));
WriteObject(DataLakeAnalyticsClient.CreateSecret(Account, DatabaseName, Secret.UserName,
Secret.GetNetworkCredential().Password, toUse.AbsoluteUri));
}
protected override void ProcessRecord()
{
if (Uri != null && Uri.Port <= 0)
{
WriteWarning(string.Format(Resources.NoPortSpecified, Uri));
}
var toUse = Uri ?? new Uri(string.Format("https://{0}:{1}", Host, Port));
WriteObject(DataLakeAnalyticsClient.UpdateSecret(ResourceGroupName, Account, DatabaseName, Secret.UserName,
Secret.GetNetworkCredential().Password, toUse.AbsoluteUri));
}
public override void ExecuteCmdlet()
{
var itemList = DataLakeAnalyticsClient.GetCatalogItem(ResourceGroupName, Account, Path, ItemType);
if (itemList.Count == 1)
{
WriteObject(itemList[0]);
}
else
{
WriteObject(itemList, true);
}
}
public override void ExecuteCmdlet()
{
if (string.IsNullOrEmpty(Name))
{
WriteObject(DataLakeAnalyticsClient.ListFirewallRules(ResourceGroupName, Account)
.Select(element => new DataLakeAnalyticsFirewallRule(element))
.ToList(), true);
}
else
{
WriteObject(new DataLakeAnalyticsFirewallRule(DataLakeAnalyticsClient.GetFirewallRule(ResourceGroupName, Account, Name)));
}
}
protected override void ProcessRecord()
{
var itemList = DataLakeAnalyticsClient.GetCatalogItem(ResourceGroupName, Account, Path, ItemType);
if (itemList.Count == 1)
{
WriteObject(itemList[0]);
}
else
{
WriteObject(itemList, true);
}
}
public override void ExecuteCmdlet()
{
ConfirmAction(
string.Format(Resources.RemoveDataLakeAnalyticsCatalogCredential, Name),
Name,
() =>
{
DataLakeAnalyticsClient.DeleteCredential(Account, DatabaseName, Name, Password != null ? Password.GetNetworkCredential().Password : null);
if (PassThru)
{
WriteObject(true);
}
});
}
public override void ExecuteCmdlet()
{
ConfirmAction(
Force.IsPresent,
string.Format(Resources.StoppingDataLakeAnalyticsJob, JobId),
string.Format(Resources.StopDataLakeAnalyticsJob, JobId),
JobId.ToString(),
() => DataLakeAnalyticsClient.CancelJob(Account, JobId));
if (PassThru)
{
WriteObject(true);
}
}
protected override void ProcessRecord()
{
ConfirmAction(
Force.IsPresent,
string.Format(Resources.StoppingDataLakeAnalyticsJob, JobId),
string.Format(Resources.StopDataLakeAnalyticsJob, JobId),
JobId.ToString(),
() => DataLakeAnalyticsClient.CancelJob(ResourceGroupName, Account, JobId));
if (PassThru)
{
WriteObject(true);
}
}
public override void ExecuteCmdlet()
{
if (!string.IsNullOrEmpty(Name))
{
// Get for single account
WriteObject(DataLakeAnalyticsClient.GetAccount(ResourceGroupName, Name));
}
else
{
// List all accounts in given resource group if avaliable otherwise all accounts in the subscription
var list = DataLakeAnalyticsClient.ListAccounts(ResourceGroupName, null, null, null);
WriteObject(list, true);
}
}
public override void ExecuteCmdlet()
{
ConfirmAction(
string.Format(Resources.RemoveDataLakeAnalyticsFirewallRule, Name),
Name,
() =>
{
DataLakeAnalyticsClient.DeleteFirewallRule(ResourceGroupName, Account, Name, this);
if (PassThru)
{
WriteObject(true);
}
});
}
public override void ExecuteCmdlet()
{
if (ParameterSetName.Equals(BlobParameterSetName, StringComparison.InvariantCultureIgnoreCase))
{
WriteObject(new PSStorageAccountInfo(DataLakeAnalyticsClient.GetStorageAccount(ResourceGroupName, Account, Blob)));
}
else if ((ParameterSetName.Equals(DataLakeParameterSetName, StringComparison.InvariantCultureIgnoreCase)))
{
WriteObject(new PSDataLakeStoreAccountInfo(DataLakeAnalyticsClient.GetDataLakeStoreAccount(ResourceGroupName, Account, DataLakeStore)));
}
else
{
WriteObject(DataLakeAnalyticsClient.GetAllDataSources(ResourceGroupName, Account), true);
}
}
protected override void ProcessRecord()
{
DataLakeStoreAccount defaultAccount = null;
if (!string.IsNullOrEmpty(DefaultDataLakeStore))
{
defaultAccount = new DataLakeStoreAccount
{
Name = DefaultDataLakeStore
};
}
WriteObject(DataLakeAnalyticsClient.CreateOrUpdateAccount(ResourceGroupName, Name, null, defaultAccount,
null, null, Tags));
}
public override void ExecuteCmdlet()
{
WriteWarning(Resources.IncorrectOutputTypeWarning);
if (Uri != null && Uri.Port <= 0)
{
WriteWarning(string.Format(Resources.NoPortSpecified, Uri));
}
var toUse = Uri ?? new Uri(string.Format("https://{0}:{1}", DatabaseHost, Port));
// TODO: Remove the WriteObject during next breaking change release, since this object
// is always null.
WriteObject(DataLakeAnalyticsClient.UpdateSecret(Account, DatabaseName, Secret.UserName,
Secret.GetNetworkCredential().Password, toUse.AbsoluteUri));
}
public override void ExecuteCmdlet()
{
if (!string.IsNullOrEmpty(Name))
{
// Get for single account
WriteObject(new PSDataLakeAnalyticsAccount(DataLakeAnalyticsClient.GetAccount(ResourceGroupName, Name)));
}
else
{
// List all accounts in given resource group if avaliable otherwise all accounts in the subscription
WriteObject(DataLakeAnalyticsClient.ListAccounts(ResourceGroupName, null, null, null)
.Select(element => new PSDataLakeAnalyticsAccountBasic(element))
.ToList(), true);
}
}
public override void ExecuteCmdlet()
{
DataLakeStoreAccountInfo defaultAccount = null;
if (!string.IsNullOrEmpty(DefaultDataLakeStore))
{
defaultAccount = new DataLakeStoreAccountInfo
{
Name = DefaultDataLakeStore
};
}
WriteObject(DataLakeAnalyticsClient.CreateOrUpdateAccount(ResourceGroupName, Name, null, defaultAccount,
null, null, Tags));
}
public override void ExecuteCmdlet()
{
ConfirmAction(
Force.IsPresent,
string.Format(Resources.RemovingDataLakeAnalyticsAccount, Name),
string.Format(Resources.RemoveDataLakeAnalyticsAccount, Name),
Name,
() =>
{
DataLakeAnalyticsClient.DeleteAccount(ResourceGroupName, Name);
if (PassThru)
{
WriteObject(true);
}
});
}
public override void ExecuteCmdlet()
{
string processMessage = string.Empty;
string target = string.Empty;
switch (this.ParameterSetName)
{
case UserCatalogParameterSetName:
case GroupCatalogParameterSetName:
processMessage = string.Format(Resources.RemoveDataLakeAnalyticsCatalogAcl, Account);
target = Account;
break;
case UserCatalogItemParameterSetName:
case GroupCatalogItemParameterSetName:
processMessage = string.Format(Resources.RemoveDataLakeAnalyticsCatalogItemAcl, Path.FullCatalogItemPath);
target = Path.FullCatalogItemPath ?? Account;
break;
default: throw new ArgumentException($"Invalid parameter set: {this.ParameterSetName}");
}
string aceType = string.Empty;
switch (this.ParameterSetName)
{
case UserCatalogParameterSetName:
case UserCatalogItemParameterSetName: aceType = AclType.User; break;
case GroupCatalogParameterSetName:
case GroupCatalogItemParameterSetName: aceType = AclType.Group; break;
default: throw new ArgumentException($"Invalid parameter set: {this.ParameterSetName}");
}
ConfirmAction(
processMessage,
target,
() =>
{
DataLakeAnalyticsClient.RemoveCatalogItemAclEntry(Account, Path, ItemType, aceType, ObjectId);
if (PassThru)
{
WriteObject(true);
}
});
}
public override void ExecuteCmdlet()
{
WriteObject(
new PSDataLakeAnalyticsAccount(
DataLakeAnalyticsClient.CreateOrUpdateAccount(
ResourceGroupName,
Name,
null,
null,
null,
null,
Tags,
MaxDegreeOfParallelism,
MaxJobCount,
QueryStoreRetention,
Tier)));
}
public override void ExecuteCmdlet()
{
try
{
if (DataLakeAnalyticsClient.GetAccount(ResourceGroupName, Name) != null)
{
throw new CloudException(string.Format(Resources.DataLakeAnalyticsAccountExists, Name));
}
}
catch (CloudException ex)
{
if (ex.Body != null && !string.IsNullOrEmpty(ex.Body.Code) && ex.Body.Code == "ResourceNotFound" ||
ex.Message.Contains("ResourceNotFound"))
{
// account does not exists so go ahead and create one
}
else if (ex.Body != null && !string.IsNullOrEmpty(ex.Body.Code) &&
ex.Body.Code == "ResourceGroupNotFound" || ex.Message.Contains("ResourceGroupNotFound"))
{
// resource group not found, let create throw error don't throw from here
}
else
{
// all other exceptions should be thrown
throw;
}
}
var defaultStorage = new AddDataLakeStoreWithAccountParameters
{
Name = DefaultDataLakeStore
};
WriteObject(
new PSDataLakeAnalyticsAccount(
DataLakeAnalyticsClient.CreateOrUpdateAccount(
ResourceGroupName,
Name,
Location,
defaultStorage,
customTags: Tag,
maxAnalyticsUnits: MaxAnalyticsUnits,
maxJobCount: MaxJobCount,
queryStoreRetention: QueryStoreRetention,
tier: Tier)));
}
