/// <summary>
/// get the server group detail list
/// </summary>
/// <param name="conn"></param>
/// <param name="groupCD"></param>
/// <returns></returns>
public IList <BackupServer> GetGroupBackupServerList(OdbcConnection conn, string groupId)
{
IList <BackupServer> gbsList = new List <BackupServer>();
string sql = "SELECT bs.id,bs.backupServerName,bs.backupServerIP,bs.account,bs.password,bs.startFile,bs.ssbpath FROM backupServer bs"
+ " INNER JOIN backupServerGroupDetail bsgd ON bs.id = bsgd.backupServerID"
+ " WHERE bs.deleteFlg = 0 AND bsgd.deleteFlg=0 AND bsgd.backupServerGroupID = " + groupId;
try
{
DataTable dt = db.Squery(sql, conn);
foreach (DataRow row in dt.Rows)
{
BackupServer bs = new BackupServer();
bs.id = row["id"].ToString();
bs.backupServerName = row["backupServerName"].ToString();
bs.backupServerIP = row["backupServerIP"].ToString();
bs.account = row["account"].ToString();
bs.password = row["password"].ToString();
bs.startFile = row["startFile"].ToString();
bs.ssbpath = row["ssbpath"].ToString();
gbsList.Add(bs);
}
}
catch (Exception e)
{
throw e;
}
return(gbsList);
}
public int UpdateBackupServer(BackupServer BackupServer, SqlConnection conn)
{
int result = -1;
string sql = "UPDATE backupServer SET backupServerName = @servername,"
+ " backupServerIP = @ip,"
+ " memo = @memo, "
+ " account =@account,"
+ " password =@password,"
+ " startFile =@startFile,"
+ " updater =@updater,"
+ " updateDate =@updateDate"
+ " WHERE id = @id";
SqlParameter[] para = new SqlParameter[] {
new SqlParameter("@servername", BackupServer.backupServerName),
new SqlParameter("@ip", BackupServer.backupServerIP),
new SqlParameter("@memo", BackupServer.memo),
new SqlParameter("@account", BackupServer.account),
new SqlParameter("@password", BackupServer.password),
new SqlParameter("@startFile", BackupServer.startFile),
new SqlParameter("@updater", BackupServer.updater),
new SqlParameter("@updateDate", BackupServer.updateDate),
new SqlParameter("@id", BackupServer.id)
};
try
{
result = db.Udaquery(sql, conn, para);
}
catch (Exception e)
{
throw e;
}
return(result);
}
/// <summary>
/// get part backup server list
/// </summary>
/// <param name="conn"></param>
/// <param name="groupId"></param>
/// <returns></returns>
public IList <BackupServer> GetPartBackupServerList(OdbcConnection conn, string groupId)
{
IList <BackupServer> bspList = new List <BackupServer>();
try
{
string sql = "select id,backupServerName,backupServerIP,memo,account,password,startFile from backupServer where deleteFlg=0"
+ " and id not in ("
+ "select backupServerID from backupServerGroupDetail where backupServerGroupID = " + groupId + " and deleteFlg=0"
+ ")";
DataTable dt = db.Squery(sql, conn);
foreach (DataRow row in dt.Rows)
{
BackupServer bs = new BackupServer();
bs.id = row["id"].ToString();
bs.backupServerName = row["backupServerName"].ToString();
bs.backupServerIP = row["backupServerIP"].ToString();
bs.memo = row["memo"].ToString();
bs.account = row["account"].ToString();
bs.password = row["password"].ToString();
bs.startFile = row["startFile"].ToString();
bspList.Add(bs);
}
}
catch (Exception e)
{
throw e;
}
return(bspList);
}
public async Task <JsonResult> UpdateBackupServer(Guid serverId, string serverName, string userName, string password)
{
Requires.Argument <Guid>("serverId", serverId).NotNull();
Requires.Argument <string>("serverName", serverName).NotNullOrEmpty();
Requires.Argument <string>("userName", userName).NotNullOrEmpty();
Requires.Argument <string>("password", password).NotNullOrEmpty();
try
{
BackupServer serverToPost = new BackupServer()
{
ServerId = serverId,
ServerName = serverName,
UserName = userName,
Password = password
};
var server = await ClientFactory.VmBackupClient.UpdateBackupServerAsync(serverToPost);
BackupServerModel serverModel = new BackupServerModel(server);
return(Json(serverModel));
}
catch (Exception e)
{
throw this.HandleException(e);
}
}
public async Task <JsonResult> CreateBackupServer(string serverName, string userName, string password, string groupId)
{
Requires.Argument <string>("serverName", serverName).NotNullOrEmpty();
Requires.Argument <string>("userName", userName).NotNullOrEmpty();
Requires.Argument <string>("password", password).NotNullOrEmpty();
Requires.Argument <string>("groupId", groupId).ValidResourceId();
try
{
BackupServer serverToPost = new BackupServer()
{
ServerName = serverName,
UserName = userName,
Password = password,
GroupId = Guid.Parse(groupId)
};
var server = await ClientFactory.VmBackupClient.CreateBackupServerAsync(serverToPost);
BackupServerModel serverModel = new BackupServerModel(server);
return(Json(serverModel));
}
catch (Exception e)
{
throw this.HandleException(e);
}
}
public async Task <BackupServer> UpdateBackupServer(BackupServer server, string id)
{
try
{
Guid serverId = Guid.Parse(id);
if (serverId != server.ServerId)
{
throw new Exception("Bad ID!");
}
await this.dpmServerClient.CheckServerVersionAndConnectivity(server.ServerName, server.UserName, server.Password);
byte[] encryptionResult = encryptor.EncryptData(server.Password);
return(await this.configStorageClient.UpdateBackupServerAsync <BackupServer>(
server.ServerId,
server.UserName,
encryptionResult,
BackupServerMapping.CreateBackupServerWithoutPassword));
}
catch (Exception e)
{
VmBackupLog.Current.WriteErrorMessage("UpdateBackupServer", VmBackupEventId.UnexpectedAdminException, e);
throw;
}
}
/// <summary>
/// init the backup server modifification page
/// </summary>
private void FrmTransfer_Load(object sender, EventArgs e)
{
//get monitor server by record id
if (!String.IsNullOrWhiteSpace(id))
{
IBackupServerService bs = BLLFactory.ServiceAccess.CreateBackupServer();
backupServer = bs.GetBackupServerById(Convert.ToInt32(id));
this.txtTrId.Text = backupServer.id.ToString();
this.txtTrName.Text = backupServer.backupServerName;
this.txtTrIp.Text = backupServer.backupServerIP;
this.txtTrMemo.Text = backupServer.memo;
this.txtTraccount.Text = backupServer.account;
this.txtTrPass.Text = backupServer.password;
this.txtTrStfile.Text = backupServer.startFile;
//Set the related MonitorServer.
this.innerBackupServerGroup = groupSerivce.GetBackupServerGroupByBackupServerID(Convert.ToInt32(id));
foreach (object item in this.cobMonitorServer.Items)
{
ComboBoxItem cobItem = (ComboBoxItem)item;
if (cobItem.Value != null && cobItem.Value.Equals(this.innerBackupServerGroup.monitorServerID))
{
this.cobMonitorServer.SelectedItem = item;
break;
}
}
this.txtBackupServerGroupName.Text = this.innerBackupServerGroup.backupServerGroupName;
}
else
{
this.IP_StartFolder = CommonUtil.GetTransfer_IP_StartFolder();
}
}
public ActionResult Add(BackupServerGroup model, BackupServer bkModel)
{
int result = -1;
//session获取值
if (Session["LoginId"] == null)
{
result = -99;
}
else
{
try
{
string dt = CommonUtil.DateTimeNowToString();
string loginId = Session["LoginId"].ToString();
model.backupServerGroupName = bkModel.backupServerName;
model.creater = loginId;
model.createDate = dt;
model.updater = loginId;
model.updateDate = dt;
model.deleteFlg = 0;
result = groupSerivce.InsertBackupServerGroup(model);
bkModel.creater = loginId;
bkModel.createDate = dt;
bkModel.updater = loginId;
bkModel.updateDate = dt;
bkModel.deleteFlg = 0;
result = bkService.InsertBackupServer(bkModel);
//add relation detail
IList <BackupServerGroup> groupList = groupSerivce.GetBackupServerGroupByName(model.backupServerGroupName);
IList <BackupServer> bkList = bkService.GetBackupServerListByName(bkModel.backupServerName);
if (groupList.Count > 0 && bkList.Count > 0)
{
BackupServerGroupDetail modelDetail = new BackupServerGroupDetail();
modelDetail.backupServerGroupId = Convert.ToInt32(groupList[0].id);
modelDetail.backupServerId = Convert.ToInt32(bkList[0].id);
modelDetail.deleteFlg = 0;
modelDetail.creater = loginId;
modelDetail.createDate = dt;
modelDetail.updater = loginId;
modelDetail.updateDate = dt;
result = groubDetailService.InsertBackupServerGroupDetail(modelDetail);
}
}
catch (Exception ex)
{
result = -10;
logger.Error(ex.Message);
}
}
Response.Write(result);
Response.End();
return(null);
}
/// <summary>
///
/// </summary>
/// <param name="BackupServer"></param>
/// <param name="conn"></param>
/// <returns></returns>
public int InsertBackupServer(BackupServer BackupServer, OdbcConnection conn)
{
try
{
return(db.insert(BackupServer, "backupServer", conn));
}
catch (Exception e)
{
throw e;
}
}
public BackupServerModel(BackupServer server)
{
this.ServerName = server.ServerName;
this.ServerId = server.ServerId;
this.State = server.State;
this.UserName = server.UserName;
this.ProtectionGroupCount = server.ProtectionGroupCount;
this.VirtualMachineCount = server.VirtualMachineCount;
this.GroupId = server.GroupId;
this.GroupName = server.GroupName;
}
public static BackupServer CreateBackupServer(SqlDataReader sqlDataReader)
{
BackupServer server = new BackupServer();
if (sqlDataReader.Read())
{
server = GenerateBackupServer(sqlDataReader, false);
}
return(server);
}
public static BackupServer CreateBackupServerWithoutPassword(SqlDataReader sqlDataReader)
{
BackupServer server = new BackupServer();
if (sqlDataReader.Read())
{
server = GenerateBackupServer(sqlDataReader, true);
}
return(server);
}
/// <summary>
///
/// </summary>
/// <param name="resourceToPost"></param>
/// <returns></returns>
public Task <BackupServer> CreateBackupServerAsync(BackupServer resourceToPost)
{
if (resourceToPost == null)
{
throw new ArgumentNullException("resourceToPost");
}
var requestUrl = this.CreateRequestUri(VmBackupClient.BackupServers);
return(this.restClient.PostResourceAsync <BackupServer, VmBackupErrorResource>(resourceToPost, requestUrl)
.HandleException <BackupServer>(this.HandleAggregateException));
}
/// <summary>
///
/// </summary>
/// <param name="resourceToPost"></param>
/// <returns></returns>
public Task <BackupServer> UpdateBackupServerAsync(BackupServer resourceToPost)
{
if (resourceToPost == null)
{
throw new ArgumentNullException("resourceToPost");
}
var requestUrl = this.CreateRequestUri(string.Format(CultureInfo.InvariantCulture, VmBackupClient.BackupServer, resourceToPost.ServerId));
return(this.restClient.PutResourceAsync <BackupServer, VmBackupErrorResource>(resourceToPost, requestUrl)
.HandleException <BackupServer>(this.HandleAggregateException));
}
public int InsertBackupServer(BackupServer BackupServer)
{
OdbcConnection conn;
int count = 0;
using (conn = OdbcHelper.CreateConntion())
{
conn.Open();
count = BackupServerDal.InsertBackupServer(BackupServer, conn);
conn.Close();
}
return(count);
}
public ActionResult NetworkTest(BackupServer model)
{
int Result = 0;
string ipMessage = model.backupServerIP;
string stfileMessage = model.startFile;
//string monitorDrive = "AA";
string accountMessage = model.account;
string passMessage = model.password;
//string serverFolderPath = @"\\" + ipMessage + @"\" + stfileMessage.TrimStart('\\').Replace('/', '\\');
//string localPath = monitorDrive + ":";
try
{
//int status = Common.NetworkConnection.Connect(serverFolderPath, localPath, accountMessage, passMessage);
//if (status == (int)Common.ERROR_ID.ERROR_SUCCESS)
//{
// Result = 1;
//}
//else
//{
// Result = -1;
//}
string ip = @"\\" + ipMessage;
NetWorkFileShare1 netWorkFileShare = new NetWorkFileShare1();
if (netWorkFileShare.ConnectState(ip, accountMessage.Trim(), passMessage.Trim()))
{
Result = 1;
}
else
{
Result = -1;
}
}
catch (Exception ex)
{
if (ex.Message.IndexOf("1312") > -1)
{
Result = 1;
}
else
{
Result = -10;
}
logger.Error(ex.Message);
}
Response.Write(Result);
Response.End();
return(null);
}
/// <summary>
/// 転送先・編集ページ
/// </summary>
/// <param name="id"></param>
/// <returns></returns>
public ActionResult Edit(int id)
{
try
{
ViewData["bkserver"] = bkService.GetBackupServerById(id);
ViewData["msList"] = mService.GetMonitorServerList();
ViewData["model"] = groupSerivce.GetBackupServerGroupByBackupServerID(id);
}
catch (Exception ex)
{
ViewData["bkserver"] = new BackupServer();
ViewData["msList"] = new MonitorServer();
ViewData["model"] = new BackupServerGroup();
logger.Error(ex.Message);
}
return(View());
}
private static BackupServer GenerateBackupServer(SqlDataReader sqlDataReader, bool removePassword = true)
{
BackupServer server = new BackupServer();
server.ServerId = (Guid)sqlDataReader["ServerId"];
server.ServerName = (string)sqlDataReader["ServerName"];
server.UserName = (string)sqlDataReader["UserName"];
//Decrypt the password
byte[] encryptedPassword = (byte[])sqlDataReader["Password"];
server.Password = removePassword ? string.Empty : encryptor.DecryptData(encryptedPassword);
server.State = (string)sqlDataReader["BackupServerStateName"];
server.GroupId = (Guid)sqlDataReader["GroupId"];
server.GroupName = (string)sqlDataReader["GroupName"];
server.ProtectionGroupCount = (int)sqlDataReader["ProtectionGroupCount"];
server.VirtualMachineCount = (int)sqlDataReader["VirtualMachineCount"];
return(server);
}
/// <summary>
/// データ更新
/// </summary>
/// <param name="bkModel"></param>
/// <returns></returns>
public ActionResult Update(BackupServerGroup model, BackupServer bkModel)
{
int result = -1;
//session获取值
if (Session["LoginId"] == null)
{
result = -99;
}
else
{
try
{
model.id = Request.Form["group_id"];
model.updater = bkModel.updater = Session["LoginId"].ToString();
model.updateDate = bkModel.updateDate = CommonUtil.DateTimeNowToString();
if (model.memo == null)
{
model.memo = string.Empty;
}
if (bkModel.memo == null)
{
bkModel.memo = string.Empty;
}
if (bkModel.ssbpath == null)
{
bkModel.ssbpath = string.Empty;
}
result = groupSerivce.UpdateBackupServerGroup(model);
result = bkService.UpdateBackupServer(bkModel);
}
catch (Exception ex)
{
result = -10;
logger.Error(ex.Message);
}
}
Response.Write(result);
Response.End();
return(null);
}
public WitnessService(Manager manager)
{
this.db_manager = manager.DBManager;
this.backup_manager = manager.BackupManager;
this.net_service = manager.NetService;
this.backup_server = manager.BackupServer;
this.controller = this.db_manager.WitnessController;
this.db_manager.WitnessService = this;
this.thread_generate = new Thread(new ThreadStart(ScheduleProductionLoop));
new Thread(new ThreadStart(() =>
{
while (need_sync_check)
{
Thread.Sleep(100);
}
this.backup_server.InitServer();
})).Start();
}
/// <summary>
///
/// </summary>
/// <param name="BackupServer"></param>
/// <param name="conn"></param>
/// <returns></returns>
public int UpdateBackupServer(BackupServer BackupServer, OdbcConnection conn)
{
int result = -1;
string sql = "UPDATE backupServer SET backupServerName = ?,"
+ " backupServerIP = ?,"
+ " memo = ?, "
+ " account =?,"
+ " password =?,"
+ " startFile =?,"
+ " ssbpath =?,"
+ " updater =?,"
+ " updateDate =?,"
+ " synchronismFlg = 0"
+ " WHERE id = ?";
OdbcParameter[] para = new OdbcParameter[] {
new OdbcParameter("@backupServerName", BackupServer.backupServerName),
new OdbcParameter("@backupServerIP", BackupServer.backupServerIP),
new OdbcParameter("@memo", BackupServer.memo),
new OdbcParameter("@account", BackupServer.account),
new OdbcParameter("@password", BackupServer.password),
new OdbcParameter("@startFile", BackupServer.startFile),
new OdbcParameter("@ssbpath", BackupServer.ssbpath),
new OdbcParameter("@updater", BackupServer.updater),
new OdbcParameter("@updateDate", BackupServer.updateDate),
new OdbcParameter("@id", BackupServer.id)
};
try
{
result = db.Udaquery(sql, conn, para);
}
catch (Exception e)
{
throw e;
}
return(result);
}
public async Task <BackupServer> UpdateBackupServer(BackupServer server, string serverId)
{
return(await this.backupServersProvider.UpdateBackupServer(server, serverId));
}
public async Task <HttpResponseMessage> CreateBackupSever(BackupServer backupServer)
{
BackupServer server = await this.backupServersProvider.CreateBackupServer(backupServer);
return(Request.CreateResponse <BackupServer>(HttpStatusCode.Created, server));
}
/// <summary>
/// insert log and backupserverfile
/// </summary>
/// <param name="file"></param>
/// <param name="backup"></param>
/// <param name="startTime"></param>
/// <param name="endTime"></param>
/// <param name="timespan"></param>
/// <param name="transferFlg"></param>
private void InsertTransferInfo(MonitorServerFile file, BackupServer backup, DateTime startTime, DateTime endTime, TimeSpan timespan, int transferFlg)
{
//insert log
try
{
Log Log = new Log();
Log.monitorServerID = file.monitorServerID;
Log.monitorFileName = file.monitorFileName;
Log.monitorFilePath = file.monitorFilePath;
Log.monitorFileType = file.monitorFileType;
Log.monitorFileSize = file.monitorFileSize;
Log.monitorTime = file.monitorStartTime;
Log.transferFlg = transferFlg;
Log.backupServerGroupID = Int32.Parse(_backupgroupid);
Log.backupServerID = Int32.Parse(backup.id);
Log.backupServerFileName = file.monitorFileName;
Log.backupServerFilePath = backup.startFile;
Log.backupServerFileType = file.monitorFileType;
Log.backupServerFileSize = file.monitorFileSize;
Log.backupStartTime = startTime.ToString();
Log.backupEndTime = endTime.ToString();
Log.backupTime = timespan.TotalMilliseconds.ToString() + "ms";
Log.backupFlg = transferFlg;
Log.copyStartTime = startTime.ToString();
Log.copyEndTime = endTime.ToString();
Log.copyTime = timespan.TotalMilliseconds.ToString() + "ms";
Log.copyFlg = transferFlg;
Log.deleteFlg = DEFAULTINT_VALUE;
Log.deleter = DEFAULTCHAR_VALUE;
Log.deleteDate = DEFAULTDATETIME_VALUE;
Log.creater = "exe";
Log.createDate = CommonUtil.DateTimeNowToString();
Log.updater = "exe";
Log.updateDate = CommonUtil.DateTimeNowToString();
Log.restorer = DEFAULTCHAR_VALUE;
Log.restoreDate = DEFAULTDATETIME_VALUE;
LogService.InsertLog(Log);
//insert backupserverfile
BackupServerFile BackupServerFile = new BackupServerFile();
BackupServerFile.backupServerGroupID = Int32.Parse(_backupgroupid);
BackupServerFile.backupServerID = Int32.Parse(backup.id);
BackupServerFile.backupServerFileName = file.monitorFileName;
BackupServerFile.backupServerFilePath = backup.startFile;
BackupServerFile.backupServerFileType = file.monitorFileType;
BackupServerFile.backupServerFileSize = file.monitorFileSize;
BackupServerFile.backupStartTime = startTime.ToString();
BackupServerFile.backupEndTime = endTime.ToString();
BackupServerFile.backupTime = timespan.TotalMilliseconds.ToString() + "ms";
BackupServerFile.backupFlg = transferFlg;
BackupServerFile.copyStartTime = startTime.ToString();
BackupServerFile.copyEndTime = endTime.ToString();
BackupServerFile.copyTime = timespan.TotalMilliseconds.ToString() + "ms";
BackupServerFile.copyFlg = transferFlg;
BackupServerFile.deleteFlg = DEFAULTINT_VALUE;
BackupServerFile.deleter = DEFAULTCHAR_VALUE;
BackupServerFile.deleteDate = DEFAULTDATETIME_VALUE;
BackupServerFile.creater = "exe";
BackupServerFile.createDate = CommonUtil.DateTimeNowToString();
BackupServerFile.updater = "exe";
BackupServerFile.updateDate = CommonUtil.DateTimeNowToString();
BackupServerFile.restorer = DEFAULTCHAR_VALUE;
BackupServerFile.restoreDate = DEFAULTDATETIME_VALUE;
BackupServerFileService.InsertBackupServerFile(BackupServerFile);
}
catch (Exception e)
{
logger.Error(e.Message);
}
}
public async Task <BackupServer> CreateBackupServer(BackupServer server)
{
try
{
ServerGroup group = await this.configStorageClient.SelectServerGroupByIdAsync <ServerGroup>(server.GroupId, ServerGroupMapping.CreateServerGroup);
if (group == null)
{
string exceptionMessage = string.Format(CultureInfo.CurrentCulture, ErrorMessages.CreateBackupServerFailedGroupNotFound, server.ServerName);
VmBackupLog.Current.WriteErrorMessage("CreateBackupServer", VmBackupEventId.ServerGroupNotFound, null, server.GroupId);
throw Utility.CreateHttpResponseException(exceptionMessage, HttpStatusCode.BadRequest);
}
BackupServerVersion version = await this.dpmServerClient.CheckServerVersionAndConnectivity(server.ServerName, server.UserName, server.Password);
if (version.Major < 4 || (version.Major == 4 && version.Minor < 2))
{
string exceptionMessage = string.Format(CultureInfo.CurrentCulture, ErrorMessages.CreateBackupServerFailedBadVersionNumber, server.ServerName, version.VersionString);
VmBackupLog.Current.WriteErrorMessage("CreateBackupServer", VmBackupEventId.DpmVersionTooLow, null, server.ServerName, version.VersionString);
throw Utility.CreateHttpResponseException(exceptionMessage, HttpStatusCode.BadRequest);
}
if (group.AzureBackupEnabled)
{
await this.dpmServerClient.CheckAzureSubscription(server.ServerName, server.UserName, server.Password);
}
byte[] encryptionResult = encryptor.EncryptData(server.Password);
BackupServer createdServer = await this.configStorageClient.InsertBackupServerAsync <BackupServer>(Guid.NewGuid(), server.ServerName, server.UserName, encryptionResult, server.GroupId, BackupServerMapping.CreateBackupServerWithoutPassword);
return(createdServer);
}
catch (PSRemotingTransportException e)
{
string exceptionMessage = string.Format(CultureInfo.CurrentCulture, ErrorMessages.CannotConnectToServer, server.ServerName);
VmBackupLog.Current.WriteErrorMessage("CreateBackupServer", VmBackupEventId.CannnotConnectToServer, e, server.ServerName);
throw Utility.CreateHttpResponseException(exceptionMessage, HttpStatusCode.BadRequest);
}
catch (RuntimeException e)
{
string exceptionMessage;
const int AzureSubscriptionNotFound = 10001;
const int AzureSubscriptionNotActive = 10002;
int messageNumber;
bool parseSucceeded = int.TryParse(e.ErrorRecord.FullyQualifiedErrorId, out messageNumber);
if (parseSucceeded && AzureSubscriptionNotFound == messageNumber)
{
exceptionMessage = string.Format(CultureInfo.CurrentCulture, ErrorMessages.CreateBackupServerFailedAzureSubscriptionNotFound, server.ServerName);
VmBackupLog.Current.WriteErrorMessage("CreateBackupServer", VmBackupEventId.AzureSubscriptionNotFound, null, server.GroupId, server.ServerName);
throw Utility.CreateHttpResponseException(exceptionMessage, HttpStatusCode.BadRequest);
}
else if (parseSucceeded && AzureSubscriptionNotActive == messageNumber)
{
exceptionMessage = string.Format(CultureInfo.CurrentCulture, ErrorMessages.CreateBackupServerFailedAzureSubscriptionNotReady, server.ServerName);
VmBackupLog.Current.WriteErrorMessage("CreateBackupServer", VmBackupEventId.AzureSubscriptionNotReady, null, server.GroupId, server.ServerName);
throw Utility.CreateHttpResponseException(exceptionMessage, HttpStatusCode.BadRequest);
}
else
{
VmBackupLog.Current.WriteErrorMessage("CreateBackupServer", VmBackupEventId.UnexpectedAdminException, e);
throw;
}
}
catch (SqlException e)
{
string exceptionMessage;
const int GroupNotFound = 56001;
const int ServerNameAlreadyUsed = 56002;
int messageNumber;
bool parseSucceeded = int.TryParse(e.Message, out messageNumber);
if (parseSucceeded && GroupNotFound == messageNumber)
{
exceptionMessage = string.Format(CultureInfo.CurrentCulture, ErrorMessages.CreateBackupServerFailedGroupNotFound, server.ServerName);
VmBackupLog.Current.WriteErrorMessage("CreateBackupServer", VmBackupEventId.ServerGroupNotFound, null, server.GroupId);
throw Utility.CreateHttpResponseException(exceptionMessage, HttpStatusCode.BadRequest);
}
else if (parseSucceeded && ServerNameAlreadyUsed == messageNumber)
{
exceptionMessage = string.Format(CultureInfo.CurrentCulture, ErrorMessages.CreateBackupServerFailedNameInUse, server.ServerName);
VmBackupLog.Current.WriteErrorMessage("CreateBackupServer", VmBackupEventId.ServerNameAlreadyInUse, null, server.ServerName);
throw Utility.CreateHttpResponseException(exceptionMessage, HttpStatusCode.Conflict);
}
else
{
VmBackupLog.Current.WriteErrorMessage("CreateBackupServer", VmBackupEventId.UnexpectedAdminException, e);
throw;
}
}
catch (Exception e)
{
VmBackupLog.Current.WriteErrorMessage("CreateBackupServer", VmBackupEventId.UnexpectedAdminException, e);
throw;
}
}
