public async Task <VmmServerList> ListVmmServers()
{
try
{
VmmServerList servers = await this.configStorageClient.SelectVmmServerCollectionAsync <VmmServerList>(VmmServerMapping.CreateVmmServerCollectonWithoutPassword);
SpfServer server = await this.configStorageClient.SelectSpfServerAsync <SpfServer>(SpfServerMapping.CreateSpfServer);
if (server != null)
{
var adminContext = GetAdminContext(server);
foreach (SPFAdmin.Stamp stamp in adminContext.Stamps)
{
var foundServer = (from s in servers where s.StampId == stamp.ID select s).FirstOrDefault();
if (foundServer == null)
{
servers.Add(new VmmServer()
{
StampId = stamp.ID, ServerName = stamp.Name, State = "NotRegistered"
});
}
}
}
return(servers);
}
catch (Exception e)
{
VmBackupLog.Current.WriteErrorMessage("ListVmmServers", VmBackupEventId.UnexpectedAdminException, e);
throw;
}
}
public async Task <JsonResult> SetSpfServer(string adminUrl, string userName, string password)
{
Requires.Argument <string>("adminUrl", adminUrl).NotNullOrEmpty();
Requires.Argument <string>("userName", userName).NotNullOrEmpty();
Requires.Argument <string>("password", password).NotNullOrEmpty();
try
{
SpfServer serverToPost = new SpfServer()
{
AdminUrl = adminUrl,
UserName = userName,
Password = password
};
var server = await ClientFactory.VmBackupClient.SetSpfServerAsync(serverToPost);
SpfServerModel serverModel = new SpfServerModel(server);
return(Json(serverModel));
}
catch (Exception e)
{
throw this.HandleException(e);
}
}
public static SpfServer CreateSpfServerWithoutPassword(SqlDataReader sqlDataReader)
{
SpfServer server = null;
if (sqlDataReader.Read())
{
server = GenerateSpfServer(sqlDataReader, true);
}
return(server);
}
public static SpfServer CreateSpfServer(SqlDataReader sqlDataReader)
{
SpfServer server = null;
if (sqlDataReader.Read())
{
server = GenerateSpfServer(sqlDataReader, false);
}
return(server);
}
/// <summary>
///
/// </summary>
/// <param name="resourceToPost"></param>
/// <returns></returns>
public Task <SpfServer> SetSpfServerAsync(SpfServer resourceToPost)
{
if (resourceToPost == null)
{
throw new ArgumentNullException("resourceToPost");
}
var requestUrl = this.CreateRequestUri(VmBackupClient.SpfServer);
return(this.restClient.PostResourceAsync <SpfServer, VmBackupErrorResource>(resourceToPost, requestUrl)
.HandleException <SpfServer>(this.HandleAggregateException));
}
private static SpfServer GenerateSpfServer(SqlDataReader sqlDataReader, bool removePassword = true)
{
SpfServer server = new SpfServer();
server.AdminUrl = (string)sqlDataReader["AdminUrl"];
server.UserName = (string)sqlDataReader["UserName"];
//Decrypt the password
byte[] encryptedPassword = (byte[])sqlDataReader["Password"];
server.Password = removePassword ? string.Empty : encryptor.DecryptData(encryptedPassword);
return(server);
}
private SPFAdmin.Admin GetAdminContext(SpfServer server)
{
var context = new SPFAdmin.Admin(
new Uri(
string.Format(
CultureInfo.InvariantCulture,
"{0}/{1}",
server.AdminUrl.TrimEnd(new[] { '/' }),
spfAdminUri)));
context.IgnoreMissingProperties = true;
context.Credentials = new NetworkCredential(server.UserName, server.Password);
return(context);
}
public async Task <SpfServer> SetSpfServer(SpfServer server)
{
try
{
SpfAdmin.Admin context = GetAdminContext(server);
if (context.Stamps.Count() > 0)
{
byte[] encryptionResult = encryptor.EncryptData(server.Password);
return(await this.configStorageClient.InsertOrUpdateSpfServerAsync <SpfServer>(server.AdminUrl, server.UserName, encryptionResult, SpfServerMapping.CreateSpfServerWithoutPassword));
}
else
{
throw new Exception("Could not get stamps!");
}
}
catch (Exception e)
{
VmBackupLog.Current.WriteErrorMessage("SetSpfServer", VmBackupEventId.UnexpectedAdminException, e);
throw;
}
}
public async Task <HttpResponseMessage> SetSpfSever(SpfServer server)
{
SpfServer spfServer = await this.vmmServersProvider.SetSpfServer(server);
return(Request.CreateResponse <SpfServer>(HttpStatusCode.Created, spfServer));
}
public SpfServerModel(SpfServer server)
{
this.AdminUrl = server.AdminUrl;
this.UserName = server.UserName;
}
