/// <summary>
/// Creates a new compute node user.
/// </summary>
/// <param name="options">The options to use when creating the compute node user.</param>
public void CreateComputeNodeUser(NewComputeNodeUserParameters options)
{
if (options == null)
{
throw new ArgumentNullException("options");
}
ComputeNodeUser user = null;
string computeNodeId = null;
if (options.ComputeNode != null)
{
user = options.ComputeNode.omObject.CreateComputeNodeUser();
computeNodeId = options.ComputeNode.Id;
}
else
{
PoolOperations poolOperations = options.Context.BatchOMClient.PoolOperations;
user = poolOperations.CreateComputeNodeUser(options.PoolId, options.ComputeNodeId);
computeNodeId = options.ComputeNodeId;
}
user.Name = options.ComputeNodeUserName;
user.Password = options.Password;
user.ExpiryTime = options.ExpiryTime;
user.IsAdmin = options.IsAdmin;
WriteVerbose(string.Format(Resources.CreatingComputeNodeUser, user.Name, computeNodeId));
user.Commit(ComputeNodeUserCommitSemantics.AddUser, options.AdditionalBehaviors);
}
public void TestComputeNodeUserIaas()
{
Action test = () =>
{
using (BatchClient batchCli = TestUtilities.OpenBatchClientAsync(TestUtilities.GetCredentialsFromEnvironment()).Result)
{
CloudPool sharedPool = this.poolFixture.Pool;
List <string> cnuNamesToDelete = new List <string>();
// pick a compute node to victimize with user accounts
var nodes = sharedPool.ListComputeNodes().ToList();
ComputeNode cn = nodes[0];
try
{
ComputeNodeUser bob = batchCli.PoolOperations.CreateComputeNodeUser(sharedPool.Id, cn.Id);
bob.Name = "bob";
bob.ExpiryTime = DateTime.UtcNow + TimeSpan.FromHours(25);
bob.Password = "******";
bob.SshPublicKey = "base64==";
cnuNamesToDelete.Add(bob.Name); // remember to clean this up
bob.Commit(ComputeNodeUserCommitSemantics.AddUser);
bob.SshPublicKey = "base65==";
bob.Commit(ComputeNodeUserCommitSemantics.UpdateUser);
// TODO: need to close the loop on this somehow... move to unit/interceptor-based?
// currently the server is timing out.
}
finally
{
// clear any old accounts
try
{
foreach (string curCNUName in cnuNamesToDelete)
{
this.testOutputHelper.WriteLine("TestComputeNodeUserIAAS attempting to delete the following <nodeid,user>: <{0},{1}>", cn.Id, curCNUName);
cn.DeleteComputeNodeUser(curCNUName);
}
}
catch (Exception ex)
{
this.testOutputHelper.WriteLine("TestComputeNodeUserIAAS: exception deleting user account. ex: " + ex.ToString());
}
}
}
};
SynchronizationContextHelper.RunTest(test, TestTimeout);
}
public Task CreateNodeUserAsync(string poolId, string computeNodeId, string userName, string password, DateTime expiryTime, bool admin)
{
ComputeNodeUser user = this.Client.PoolOperations.CreateComputeNodeUser(poolId, computeNodeId);
user.Name = userName;
user.Password = password;
user.ExpiryTime = expiryTime;
user.IsAdmin = admin;
return(user.CommitAsync());
}
/// <summary>
/// Updates a compute node user account
/// </summary>
/// <param name="parameters">The parameters specifying the compute node user to update and the changes to make</param>
public void UpdateComputeNodeUser(UpdateComputeNodeUserParameters parameters)
{
if (parameters == null)
{
throw new ArgumentNullException("parameters");
}
WriteVerbose(string.Format(Resources.UpdatingComputeNodeUser, parameters.ComputeNodeUserName));
ComputeNodeUser computeNodeUser = new ComputeNodeUser(parameters.Context.BatchOMClient.PoolOperations, parameters.PoolId, parameters.ComputeNodeId);
computeNodeUser.Name = parameters.ComputeNodeUserName;
computeNodeUser.Password = parameters.Password;
computeNodeUser.ExpiryTime = parameters.ExpiryTime;
computeNodeUser.Commit(ComputeNodeUserCommitSemantics.UpdateUser, parameters.AdditionalBehaviors);
}
/// <summary>
/// Updates a compute node user account
/// </summary>
/// <param name="parameters">The parameters specifying the compute node user to update and the changes to make</param>
public void UpdateComputeNodeUser(UpdateComputeNodeUserParameters parameters)
{
if (parameters == null)
{
throw new ArgumentNullException("parameters");
}
WriteVerbose(string.Format(Resources.UpdatingComputeNodeUser, parameters.ComputeNodeUserName));
ComputeNodeUser computeNodeUser = parameters.Context.BatchOMClient.PoolOperations.CreateComputeNodeUser(parameters.PoolId, parameters.ComputeNodeId);
computeNodeUser.Name = parameters.ComputeNodeUserName;
computeNodeUser.Password = parameters.Password;
computeNodeUser.ExpiryTime = parameters.ExpiryTime;
computeNodeUser.Commit(ComputeNodeUserCommitSemantics.UpdateUser, parameters.AdditionalBehaviors);
}
public void Bug1770933_1770935_1771164_AddUserCRUDAndGetRDP()
{
Action test = () =>
{
using (BatchClient batchCli = TestUtilities.OpenBatchClientAsync(TestUtilities.GetCredentialsFromEnvironment()).Result)
{
// names to create/delete
List <string> names = new List <string>()
{
TestUtilities.GetMyName(), TestUtilities.GetMyName() + "1", TestUtilities.GetMyName() + "2", TestUtilities.GetMyName() + "3", TestUtilities.GetMyName() + "4"
};
// pick a compute node to victimize with user accounts
IEnumerable <ComputeNode> ienmComputeNodes = batchCli.PoolOperations.ListComputeNodes(this.poolFixture.PoolId);
List <ComputeNode> computeNodeList = new List <ComputeNode>(ienmComputeNodes);
ComputeNode computeNode = computeNodeList[0];
try
{
string rdpFileName = "Bug1770933.rdp";
// test user public constructor and IPoolMgr verbs
{
ComputeNodeUser newUser = batchCli.PoolOperations.CreateComputeNodeUser(this.poolFixture.PoolId, computeNode.Id);
newUser.Name = names[0];
newUser.IsAdmin = true;
newUser.ExpiryTime = DateTime.UtcNow + TimeSpan.FromHours(1.0);
newUser.Password = @"!!Admin!!";
// commit that creates/adds the user
newUser.Commit(ComputeNodeUserCommitSemantics.AddUser);
// now update the user's password
newUser.Password = @"!!!Admin!!!";
// commit that updates
newUser.Commit(ComputeNodeUserCommitSemantics.UpdateUser);
// clean up from prev run
if (File.Exists(rdpFileName))
{
File.Delete(rdpFileName);
}
// pull the rdp file
batchCli.PoolOperations.GetRDPFile(this.poolFixture.PoolId, computeNode.Id, rdpFileName);
// simple validation tests on the rdp file
TestFileExistsAndHasLength(rdpFileName);
// cleanup the rdp file
File.Delete(rdpFileName);
// "test" delete user from IPoolMgr
// TODO: when GET/LIST User is available we should close the loop and confirm the user is gone.
batchCli.PoolOperations.DeleteComputeNodeUser(this.poolFixture.PoolId, computeNode.Id, newUser.Name);
}
// test IPoolMgr CreateUser
{
ComputeNodeUser pmcUser = batchCli.PoolOperations.CreateComputeNodeUser(this.poolFixture.PoolId, computeNode.Id);
pmcUser.Name = names[1];
pmcUser.IsAdmin = true;
pmcUser.ExpiryTime = DateTime.UtcNow + TimeSpan.FromHours(1.0);
pmcUser.Password = @"!!!Admin!!!";
// add the user
pmcUser.Commit(ComputeNodeUserCommitSemantics.AddUser);
// pull rdp file
batchCli.PoolOperations.GetRDPFile(this.poolFixture.PoolId, computeNode.Id, rdpFileName);
// simple validation on rdp file
TestFileExistsAndHasLength(rdpFileName);
// cleanup
File.Delete(rdpFileName);
// delete user
batchCli.PoolOperations.DeleteComputeNodeUser(this.poolFixture.PoolId, computeNode.Id, pmcUser.Name);
}
// test IComputeNode verbs
{
ComputeNodeUser poolMgrUser = batchCli.PoolOperations.CreateComputeNodeUser(this.poolFixture.PoolId, computeNode.Id);
poolMgrUser.Name = names[2];
poolMgrUser.IsAdmin = true;
poolMgrUser.ExpiryTime = DateTime.UtcNow + TimeSpan.FromHours(1.0);
poolMgrUser.Password = @"!!!Admin!!!";
poolMgrUser.Commit(ComputeNodeUserCommitSemantics.AddUser);
// pull rdp file
computeNode.GetRDPFile(rdpFileName);
// simple validation on rdp file
TestFileExistsAndHasLength(rdpFileName);
// cleanup
File.Delete(rdpFileName);
// delete user
computeNode.DeleteComputeNodeUser(poolMgrUser.Name);
}
// test ComputeNodeUser.Delete
{
ComputeNodeUser usrDelete = batchCli.PoolOperations.CreateComputeNodeUser(this.poolFixture.PoolId, computeNode.Id);
usrDelete.Name = names[3];
usrDelete.ExpiryTime = DateTime.UtcNow + TimeSpan.FromHours(1.0);
usrDelete.Password = @"!!!Admin!!!";
usrDelete.Commit(ComputeNodeUserCommitSemantics.AddUser);
usrDelete.Delete();
}
// test rdp-by-stream IPoolMgr and IComputeNode
// the by-stream paths do not converge with the by-filename paths until IProtocol so we test them seperately
{
ComputeNodeUser byStreamUser = batchCli.PoolOperations.CreateComputeNodeUser(this.poolFixture.PoolId, computeNode.Id);
byStreamUser.Name = names[4];
byStreamUser.IsAdmin = true;
byStreamUser.ExpiryTime = DateTime.UtcNow + TimeSpan.FromHours(1.0);
byStreamUser.Password = @"!!!Admin!!!";
byStreamUser.Commit(ComputeNodeUserCommitSemantics.AddUser);
// IPoolMgr
using (Stream rdpStreamPoolMgr = File.Create(rdpFileName))
{
batchCli.PoolOperations.GetRDPFile(this.poolFixture.PoolId, computeNode.Id, rdpStreamPoolMgr);
rdpStreamPoolMgr.Flush();
rdpStreamPoolMgr.Close();
TestFileExistsAndHasLength(rdpFileName);
File.Delete(rdpFileName);
}
// IComputeNode
using (Stream rdpViaIComputeNode = File.Create(rdpFileName))
{
computeNode.GetRDPFile(rdpViaIComputeNode);
rdpViaIComputeNode.Flush();
rdpViaIComputeNode.Close();
TestFileExistsAndHasLength(rdpFileName);
File.Delete(rdpFileName);
}
// delete the user account
byStreamUser.Delete();
}
}
finally
{
// clear any old accounts
foreach (string curName in names)
{
bool hitException = false;
try
{
ComputeNodeUser deleteThis = batchCli.PoolOperations.CreateComputeNodeUser(this.poolFixture.PoolId, computeNode.Id);
deleteThis.Name = curName;
deleteThis.Delete();
}
catch (BatchException ex)
{
Assert.Equal(BatchErrorCodeStrings.NodeUserNotFound, ex.RequestInformation.BatchError.Code);
hitException = true;
}
Assert.True(hitException, "Should have hit exception on user: "******", compute node: " + computeNode.Id + ".");
}
}
}
};
SynchronizationContextHelper.RunTest(test, TestTimeout);
}
/// <summary>
/// Adds a user account to the specified compute node.
/// </summary>
/// <remarks>
/// You can add a user account to a node only when it is in the idle or running
/// state.
/// </remarks>
/// <param name='operations'>
/// The operations group for this extension method.
/// </param>
/// <param name='poolId'>
/// The ID of the pool that contains the compute node.
/// </param>
/// <param name='nodeId'>
/// The ID of the machine on which you want to create a user account.
/// </param>
/// <param name='user'>
/// The user account to be created.
/// </param>
/// <param name='computeNodeAddUserOptions'>
/// Additional parameters for the operation
/// </param>
/// <param name='cancellationToken'>
/// The cancellation token.
/// </param>
public static async Task <ComputeNodeAddUserHeaders> AddUserAsync(this IComputeNodeOperations operations, string poolId, string nodeId, ComputeNodeUser user, ComputeNodeAddUserOptions computeNodeAddUserOptions = default(ComputeNodeAddUserOptions), CancellationToken cancellationToken = default(CancellationToken))
{
using (var _result = await operations.AddUserWithHttpMessagesAsync(poolId, nodeId, user, computeNodeAddUserOptions, null, cancellationToken).ConfigureAwait(false))
{
return(_result.Headers);
}
}
/// <summary>
/// Adds a user account to the specified compute node.
/// </summary>
/// <remarks>
/// You can add a user account to a node only when it is in the idle or running
/// state.
/// </remarks>
/// <param name='operations'>
/// The operations group for this extension method.
/// </param>
/// <param name='poolId'>
/// The ID of the pool that contains the compute node.
/// </param>
/// <param name='nodeId'>
/// The ID of the machine on which you want to create a user account.
/// </param>
/// <param name='user'>
/// The user account to be created.
/// </param>
/// <param name='computeNodeAddUserOptions'>
/// Additional parameters for the operation
/// </param>
public static ComputeNodeAddUserHeaders AddUser(this IComputeNodeOperations operations, string poolId, string nodeId, ComputeNodeUser user, ComputeNodeAddUserOptions computeNodeAddUserOptions = default(ComputeNodeAddUserOptions))
{
return(operations.AddUserAsync(poolId, nodeId, user, computeNodeAddUserOptions).GetAwaiter().GetResult());
}
/// <summary>
/// Adds a user account to the specified compute node.
/// </summary>
/// <param name='operations'>
/// The operations group for this extension method.
/// </param>
/// <param name='poolId'>
/// The id of the pool that contains the compute node.
/// </param>
/// <param name='nodeId'>
/// The id of the machine on which you want to create a user account.
/// </param>
/// <param name='user'>
/// The user account to be created.
/// </param>
/// <param name='computeNodeAddUserOptions'>
/// Additional parameters for the operation
/// </param>
public static ComputeNodeAddUserHeaders AddUser(this IComputeNodeOperations operations, string poolId, string nodeId, ComputeNodeUser user, ComputeNodeAddUserOptions computeNodeAddUserOptions = default(ComputeNodeAddUserOptions))
{
return(System.Threading.Tasks.Task.Factory.StartNew(s => ((IComputeNodeOperations)s).AddUserAsync(poolId, nodeId, user, computeNodeAddUserOptions), operations, System.Threading.CancellationToken.None, System.Threading.Tasks.TaskCreationOptions.None, System.Threading.Tasks.TaskScheduler.Default).Unwrap().GetAwaiter().GetResult());
}
public virtual Response AddUser(string poolId, string nodeId, ComputeNodeUser user, ComputeNodeAddUserOptions computeNodeAddUserOptions, CancellationToken cancellationToken = default)
{
return(RestClient.AddUser(poolId, nodeId, user, computeNodeAddUserOptions, cancellationToken).GetRawResponse());
}
public virtual async Task <Response> AddUserAsync(string poolId, string nodeId, ComputeNodeUser user, ComputeNodeAddUserOptions computeNodeAddUserOptions, CancellationToken cancellationToken = default)
{
return((await RestClient.AddUserAsync(poolId, nodeId, user, computeNodeAddUserOptions, cancellationToken).ConfigureAwait(false)).GetRawResponse());
}
