public List <string> GetImportableItems(int packageId, int itemTypeId, Type itemType, ResourceGroupInfo group) { List <string> items = new List <string>(); // get service id int serviceId = PackageController.GetPackageServiceId(packageId, group.GroupName); if (serviceId == 0) { return(items); } DatabaseServer db = GetDatabaseServer(serviceId); if (itemType == typeof(SqlDatabase)) { items.AddRange(db.GetDatabases()); } else if (itemType == typeof(SqlUser)) { items.AddRange(db.GetUsers()); } return(items); }
public static int BackupItem(string tempFolder, XmlWriter writer, ServiceProviderItem item) { // load item type ServiceProviderItemType itemType = PackageController.GetServiceItemType(item.TypeId); if (!itemType.Backupable) { return(-1); } // load group ResourceGroupInfo group = ServerController.GetResourceGroup(itemType.GroupId); // create controller IBackupController controller = null; try { controller = Activator.CreateInstance(Type.GetType(group.GroupController)) as IBackupController; if (controller != null) { return(BackupItem(tempFolder, writer, item, group, controller)); } } catch (Exception ex) { TaskManager.WriteError(ex); } return(-2); }
public static List <ServiceProviderItemType> GetImportableItemTypes(int packageId) { // load all service item types List <ServiceProviderItemType> itemTypes = PackageController.GetServiceItemTypes(); // load package context PackageContext cntx = PackageController.GetPackageContext(packageId); // build importable items list List <ServiceProviderItemType> importableTypes = new List <ServiceProviderItemType>(); foreach (ServiceProviderItemType itemType in itemTypes) { if (!itemType.Importable) { continue; } // load group ResourceGroupInfo group = ServerController.GetResourceGroup(itemType.GroupId); if (cntx.Groups.ContainsKey(group.GroupName)) { importableTypes.Add(itemType); } } return(importableTypes); }
public void ImportItem(int packageId, int itemTypeId, Type itemType, ResourceGroupInfo group, string itemName) { // get service id int serviceId = PackageController.GetPackageServiceId(packageId, group.GroupName); if (serviceId == 0) { return; } if (itemType == typeof(SqlDatabase)) { // import database SqlDatabase db = new SqlDatabase(); db.ServiceId = serviceId; db.PackageId = packageId; db.Name = itemName; db.GroupName = group.GroupName; PackageController.AddPackageItem(db); } else if (itemType == typeof(SqlUser)) { // import user SqlUser user = new SqlUser(); user.ServiceId = serviceId; user.PackageId = packageId; user.Name = itemName; user.GroupName = group.GroupName; user.Password = ""; PackageController.AddPackageItem(user); } }
public void ImportItem(int packageId, int itemTypeId, Type itemType, ResourceGroupInfo group, string itemName) { // get service id int serviceId = PackageController.GetPackageServiceId(packageId, group.GroupName); if (serviceId == 0) { return; } // FTP provider FTPServer ftp = new FTPServer(); ServiceProviderProxy.Init(ftp, serviceId); if (itemType == typeof(FtpAccount)) { // load FTP account FtpAccount account = ftp.GetAccount(itemName); account.Folder = FilesController.GetFullPackagePath(packageId, "\\"); // root space folder // update FTP account ftp.UpdateAccount(account); // save account account.ServiceId = serviceId; account.PackageId = packageId; PackageController.AddPackageItem(account); } }
public void ImportItem(int packageId, int itemTypeId, Type itemType, ResourceGroupInfo group, string itemName) { // get service id int serviceId = PackageController.GetPackageServiceId(packageId, group.GroupName); if (serviceId == 0) { return; } StatisticsServer stats = new StatisticsServer(); ServiceProviderProxy.Init(stats, serviceId); if (itemType == typeof(StatsSite)) { // import statistics site StatsSite site = new StatsSite(); site.ServiceId = serviceId; site.PackageId = packageId; site.Name = itemName; site.GroupName = group.GroupName; // load site id site.SiteId = stats.GetSiteId(itemName); PackageController.AddPackageItem(site); } }
private static int BackupItem(string tempFolder, XmlWriter writer, ServiceProviderItem item, ResourceGroupInfo group, IBackupController controller) { writer.WriteStartElement("Item"); writer.WriteAttributeString("itemId", item.Id.ToString()); writer.WriteAttributeString("itemTypeId", item.TypeId.ToString()); writer.WriteAttributeString("itemName", item.Name); writer.WriteAttributeString("packageId", item.PackageId.ToString()); writer.WriteAttributeString("serviceId", item.ServiceId.ToString()); try { return(controller.BackupItem(tempFolder, writer, item, group)); } catch (Exception ex) { TaskManager.WriteError(ex); } finally { writer.WriteEndElement(); // Item } return(0); }
public void ImportItem(int packageId, int itemTypeId, Type itemType, ResourceGroupInfo group, string itemName) { // get service id int serviceId = PackageController.GetPackageServiceId(packageId, group.GroupName); if (serviceId == 0) { return; } if (itemType == typeof(SystemUser)) { // import user SystemUser user = new SystemUser(); user.ServiceId = serviceId; user.PackageId = packageId; user.Name = itemName; user.Password = ""; user.GroupName = group.GroupName; PackageController.AddPackageItem(user); } else if (itemType == typeof(SystemGroup)) { // import group SystemGroup spGroup = new SystemGroup(); spGroup.ServiceId = serviceId; spGroup.PackageId = packageId; spGroup.Name = itemName; spGroup.GroupName = group.GroupName; PackageController.AddPackageItem(spGroup); } }
public int RestoreItem(string tempFolder, XmlNode itemNode, int itemId, Type itemType, string itemName, int packageId, int serviceId, ResourceGroupInfo group) { if (itemType != typeof(DnsZone)) { return(0); } // DNS provider DNSServer dns = GetDNSServer(serviceId); // check service item if (!dns.ZoneExists(itemName)) { // create primary and secondary zones AddZone(packageId, serviceId, itemName, false, false); // restore records XmlSerializer serializer = new XmlSerializer(typeof(DnsRecord)); List <DnsRecord> records = new List <DnsRecord>(); foreach (XmlNode childNode in itemNode.ChildNodes) { if (childNode.Name == "DnsRecord") { records.Add((DnsRecord)serializer.Deserialize(new XmlNodeReader(childNode))); } } dns.AddZoneRecords(itemName, records.ToArray()); } // check if meta-item exists int zoneId = 0; DnsZone item = (DnsZone)PackageController.GetPackageItemByName(packageId, itemName, typeof(DnsZone)); if (item == null) { // restore meta-item item = new DnsZone(); item.Name = itemName; item.PackageId = packageId; item.ServiceId = serviceId; zoneId = PackageController.AddPackageItem(item); } else { zoneId = item.Id; } // restore domains RestoreDomainByZone(itemName, packageId, zoneId); return(0); }
public void ImportItem(int packageId, int itemTypeId, Type itemType, ResourceGroupInfo group, string itemName) { // get service id int serviceId = PackageController.GetPackageServiceId(packageId, group.GroupName); if (serviceId == 0) { return; } if (itemType == typeof(SystemDSN)) { // save DSN info SystemDSN dsn = new SystemDSN(); dsn.Name = itemName; dsn.ServiceId = serviceId; dsn.PackageId = packageId; PackageController.AddPackageItem(dsn); } }
public List <string> GetImportableItems(int packageId, int itemTypeId, Type itemType, ResourceGroupInfo group) { List <string> items = new List <string>(); // get service id int serviceId = PackageController.GetPackageServiceId(packageId, group.GroupName); if (serviceId == 0) { return(items); } OS.OperatingSystem os = GetOS(serviceId); if (itemType == typeof(SystemDSN)) { items.AddRange(os.GetDSNNames()); } return(items); }
public int RestoreItem(string tempFolder, System.Xml.XmlNode itemNode, int itemId, Type itemType, string itemName, int packageId, int serviceId, ResourceGroupInfo group) { if (itemType == typeof(StatsSite)) { StatisticsServer stats = GetStatisticsServer(serviceId); // extract meta item XmlSerializer serializer = new XmlSerializer(typeof(StatsSite)); StatsSite site = (StatsSite)serializer.Deserialize( new XmlNodeReader(itemNode.SelectSingleNode("StatsSite"))); // create site if required if (stats.GetSite(site.SiteId) == null) { stats.AddSite(site); } // add meta-item if required if (PackageController.GetPackageItemByName(packageId, itemName, typeof(StatsSite)) == null) { site.PackageId = packageId; site.ServiceId = serviceId; PackageController.AddPackageItem(site); } } return(0); }
public int BackupItem(string tempFolder, System.Xml.XmlWriter writer, ServiceProviderItem item, ResourceGroupInfo group) { if (item is StatsSite) { // backup stats site StatisticsServer stats = GetStatisticsServer(item.ServiceId); // read site info StatsSite itemSite = item as StatsSite; StatsSite site = stats.GetSite(itemSite.SiteId); XmlSerializer serializer = new XmlSerializer(typeof(StatsSite)); serializer.Serialize(writer, site); } return(0); }
public int RestoreItem(string tempFolder, System.Xml.XmlNode itemNode, int itemId, Type itemType, string itemName, int packageId, int serviceId, ResourceGroupInfo group) { if (itemType == typeof(SystemUser)) { SharePointServer sps = GetSharePoint(serviceId); // extract meta item XmlSerializer serializer = new XmlSerializer(typeof(SystemUser)); SystemUser user = (SystemUser)serializer.Deserialize( new XmlNodeReader(itemNode.SelectSingleNode("SystemUser"))); // create user if required if (!sps.UserExists(itemName)) { user.Password = CryptoUtils.Decrypt(user.Password); sps.CreateUser(user); // restore password user.Password = CryptoUtils.Encrypt(user.Password); } // add meta-item if required if (PackageController.GetPackageItemByName(packageId, itemName, typeof(SystemUser)) == null) { user.PackageId = packageId; user.ServiceId = serviceId; PackageController.AddPackageItem(user); } } else if (itemType == typeof(SystemGroup)) { SharePointServer sps = GetSharePoint(serviceId); // extract meta item XmlSerializer serializer = new XmlSerializer(typeof(SystemGroup)); SystemGroup sysGroup = (SystemGroup)serializer.Deserialize( new XmlNodeReader(itemNode.SelectSingleNode("SystemGroup"))); // create user if required if (!sps.GroupExists(itemName)) { sps.CreateGroup(sysGroup); } // add meta-item if required if (PackageController.GetPackageItemByName(packageId, itemName, typeof(SystemGroup)) == null) { sysGroup.PackageId = packageId; sysGroup.ServiceId = serviceId; PackageController.AddPackageItem(sysGroup); } } return(0); }
public List <string> GetImportableItems(int packageId, int itemTypeId, Type itemType, ResourceGroupInfo group) { List <string> items = new List <string>(); // get service id int serviceId = PackageController.GetPackageServiceId(packageId, group.GroupName); if (serviceId == 0) { return(items); } // Mail provider StatisticsServer stats = new StatisticsServer(); ServiceProviderProxy.Init(stats, serviceId); if (itemType == typeof(StatsSite)) { items.AddRange(stats.GetSites()); } return(items); }
public int RestoreItem(string tempFolder, System.Xml.XmlNode itemNode, int itemId, Type itemType, string itemName, int packageId, int serviceId, ResourceGroupInfo group) { if (itemType == typeof(FtpAccount)) { FTPServer ftp = GetFTPServer(serviceId); // extract meta item XmlSerializer serializer = new XmlSerializer(typeof(FtpAccount)); FtpAccount account = (FtpAccount)serializer.Deserialize( new XmlNodeReader(itemNode.SelectSingleNode("FtpAccount"))); // create DSN if required if (!ftp.AccountExists(itemName)) { account.Password = CryptoUtils.Decrypt(account.Password); ftp.CreateAccount(account); // restore password account.Password = CryptoUtils.Encrypt(account.Password); } // add meta-item if required if (PackageController.GetPackageItemByName(packageId, itemName, typeof(FtpAccount)) == null) { account.PackageId = packageId; account.ServiceId = serviceId; PackageController.AddPackageItem(account); } } return(0); }
public int BackupItem(string tempFolder, System.Xml.XmlWriter writer, ServiceProviderItem item, ResourceGroupInfo group) { if (item is FtpAccount) { // backup FTP account FTPServer ftp = GetFTPServer(item.ServiceId); // read FTP account info FtpAccount account = ftp.GetAccount(item.Name); account.Password = ((FtpAccount)item).Password; XmlSerializer serializer = new XmlSerializer(typeof(FtpAccount)); serializer.Serialize(writer, account); } return(0); }
public static int RestoreInternal(string taskId, int userId, int packageId, int serviceId, int serverId, int storePackageId, string storePackageBackupPath, string storeServerBackupPath) { try { // copy backup from remote or local server string backupFileName = (storePackageId > 0) ? Path.GetFileName(storePackageBackupPath) : Path.GetFileName(storeServerBackupPath); TaskManager.StartTask(taskId, "BACKUP", "RESTORE", backupFileName, SecurityContext.User.UserId); // create temp folder string tempFolder = GetTempBackupFolder(); string backupFileNamePath = Path.Combine(tempFolder, backupFileName); if (storePackageId > 0) { try { int osServiceId = PackageController.GetPackageServiceId(storePackageId, ResourceGroups.Os); if (osServiceId > 0) { OS.OperatingSystem os = new OS.OperatingSystem(); ServiceProviderProxy.Init(os, osServiceId); string remoteBackupPath = FilesController.GetFullPackagePath(storePackageId, storePackageBackupPath); FileStream stream = new FileStream(backupFileNamePath, FileMode.Create, FileAccess.Write); byte[] buffer = new byte[FILE_BUFFER_LENGTH]; int offset = 0; do { // read remote content buffer = os.GetFileBinaryChunk(remoteBackupPath, offset, FILE_BUFFER_LENGTH); // write remote content stream.Write(buffer, 0, buffer.Length); offset += FILE_BUFFER_LENGTH; }while (buffer.Length == FILE_BUFFER_LENGTH); stream.Close(); } } catch (Exception ex) { TaskManager.WriteError(ex, "Can't copy source backup set"); return(0); } } else { backupFileNamePath = storeServerBackupPath; } try { // unpack archive FileUtils.UnzipFiles(backupFileNamePath, tempFolder); } catch (Exception ex) { TaskManager.WriteError(ex, "Can't unzip backup set"); return(0); } // load backup catalog XmlDocument doc = new XmlDocument(); try { doc.Load(Path.Combine(tempFolder, BACKUP_CATALOG_FILE_NAME)); } catch (Exception ex) { TaskManager.WriteError(ex, "Can't find/open backup catalog file"); return(0); } // validate XML document //if (!ValidateXmlDocument(doc)) //{ // TaskManager.WriteError("Corrupted or altered backup catalog file has been read"); // return 0; //} // get the list of items to restore string condition = ""; if (userId > 0) { // get user spaces List <PackageInfo> packages = new List <PackageInfo>(); packages.AddRange(PackageController.GetMyPackages(userId)); packages.AddRange(PackageController.GetPackages(userId)); List <string> parts = new List <string>(); foreach (PackageInfo package in packages) { parts.Add("@packageId = " + package.PackageId.ToString()); } condition = "[" + String.Join(" or ", parts.ToArray()) + "]"; } else if (packageId > 0) { condition = "[@packageId = " + packageId + "]"; } else if (serviceId > 0) { condition = "[@serviceId = " + serviceId + "]"; } else if (serverId > 0) { // get server services List <ServiceInfo> services = ServerController.GetServicesByServerId(serverId); List <string> parts = new List <string>(); foreach (ServiceInfo service in services) { parts.Add("@serviceId = " + service.ServiceId.ToString()); } condition = "[" + String.Join(" or ", parts.ToArray()) + "]"; } XmlNodeList itemNodes = doc.SelectNodes("Backup/Items/Item" + condition); TaskManager.IndicatorMaximum = itemNodes.Count; TaskManager.IndicatorCurrent = 0; // group items by item types Dictionary <int, List <XmlNode> > groupedItems = new Dictionary <int, List <XmlNode> >(); // sort by groups foreach (XmlNode itemNode in itemNodes) { int itemTypeId = Utils.ParseInt(itemNode.Attributes["itemTypeId"].Value, 0); // add to group if (!groupedItems.ContainsKey(itemTypeId)) { groupedItems[itemTypeId] = new List <XmlNode>(); } groupedItems[itemTypeId].Add(itemNode); } // restore grouped items foreach (int itemTypeId in groupedItems.Keys) { // load item type ServiceProviderItemType itemTypeInfo = PackageController.GetServiceItemType(itemTypeId); if (!itemTypeInfo.Backupable) { continue; } Type itemType = Type.GetType(itemTypeInfo.TypeName); // load group ResourceGroupInfo group = ServerController.GetResourceGroup(itemTypeInfo.GroupId); // instantiate controller IBackupController controller = null; try { controller = Activator.CreateInstance(Type.GetType(group.GroupController)) as IBackupController; if (controller != null) { // backup items foreach (XmlNode itemNode in groupedItems[itemTypeId]) { int itemId = Utils.ParseInt(itemNode.Attributes["itemId"].Value, 0); string itemName = itemNode.Attributes["itemName"].Value; int itemPackageId = Utils.ParseInt(itemNode.Attributes["packageId"].Value, 0); int itemServiceId = Utils.ParseInt(itemNode.Attributes["serviceId"].Value, 0); TaskManager.Write(String.Format("Restore {0} '{1}'", itemTypeInfo.DisplayName, itemName)); try { int restoreResult = controller.RestoreItem(tempFolder, itemNode, itemId, itemType, itemName, itemPackageId, itemServiceId, group); } catch (Exception ex) { TaskManager.WriteError(ex, "Can't restore item"); } TaskManager.IndicatorCurrent++; } } } catch (Exception ex) { TaskManager.WriteError(ex); } } // delete backup folder and all its contents try { Directory.Delete(tempFolder, true); } catch (Exception ex) { TaskManager.WriteError(ex, "Can't delete temporary backup folder"); return(0); } } catch (Exception ex) { TaskManager.WriteError(ex); } finally { TaskManager.CompleteTask(); } return(0); }
public List <string> GetImportableItems(int packageId, int itemTypeId, Type itemType, ResourceGroupInfo group) { List <string> items = new List <string>(); // get service id int serviceId = PackageController.GetPackageServiceId(packageId, group.GroupName); if (serviceId == 0) { return(items); } // FTP provider FTPServer ftp = new FTPServer(); ServiceProviderProxy.Init(ftp, serviceId); FtpAccount[] accounts = ftp.GetAccounts(); foreach (FtpAccount account in accounts) { items.Add(account.Name); } return(items); }
public static List <string> GetImportableItems(int packageId, int itemTypeId) { List <string> items = new List <string>(); // check account int accountCheck = SecurityContext.CheckAccount(DemandAccount.IsAdmin | DemandAccount.NotDemo); if (accountCheck < 0) { return(items); } // load item type if (itemTypeId > 0) { ServiceProviderItemType itemType = PackageController.GetServiceItemType(itemTypeId); // load group ResourceGroupInfo group = ServerController.GetResourceGroup(itemType.GroupId); // Is it DNS Zones? Then create a IDN Mapping object var isDnsZones = group.GroupName == "DNS"; var idn = new IdnMapping(); // get service id int serviceId = PackageController.GetPackageServiceId(packageId, group.GroupName); if (serviceId == 0) { return(items); } // Read existing packages and serviceitems DataTable dtServiceItems = PackageController.GetServiceItemsDataSet(serviceId).Tables[0]; DataTable dtPackageItems = PackageController.GetPackageItemsDataSet(packageId).Tables[0]; // Add already existing packages and serviceitems to lowercase ignorelist List <string> ignorelist = new List <string>(); foreach (DataRow dr in dtServiceItems.Rows) { string serviceItemName = (string)dr["ItemName"]; int serviceItemTypeId = (int)dr["ItemTypeId"]; if (serviceItemTypeId == itemTypeId) { if (!ignorelist.Contains(serviceItemName)) { ignorelist.Add(serviceItemName.ToLower()); } } } foreach (DataRow dr in dtPackageItems.Rows) { string packageItemName = (string)dr["ItemName"]; int packageItemTypeId = (int)dr["ItemTypeId"]; if (packageItemTypeId == itemTypeId) { if (!ignorelist.Contains(packageItemName)) { ignorelist.Add(packageItemName.ToLower()); } } } // instantiate controller IImportController ctrl = null; try { List <string> importableItems = null; ctrl = Activator.CreateInstance(Type.GetType(group.GroupController)) as IImportController; if (ctrl != null) { importableItems = ctrl.GetImportableItems(packageId, itemTypeId, Type.GetType(itemType.TypeName), group); } foreach (string importableItem in importableItems) { if (!ignorelist.Contains(importableItem.ToLower())) { var itemToImport = importableItem; // For DNS zones the compare has been made using ascii, convert to unicode if necessary to make the list of items easier to read if (isDnsZones && itemToImport.StartsWith("xn--")) { itemToImport = idn.GetUnicode(importableItem); } items.Add(itemToImport); } } } catch { /* do nothing */ } } else { return(GetImportableCustomItems(packageId, itemTypeId)); } return(items); }
public int BackupItem(string tempFolder, XmlWriter writer, ServiceProviderItem item, ResourceGroupInfo group) { if (!(item is DnsZone)) { return(0); } // DNS provider DNSServer dns = GetDNSServer(item.ServiceId); // zone records serialized XmlSerializer serializer = new XmlSerializer(typeof(DnsRecord)); try { // get zone records DnsRecord[] records = dns.GetZoneRecords(item.Name); // serialize zone records foreach (DnsRecord record in records) { serializer.Serialize(writer, record); } } catch (Exception ex) { TaskManager.WriteError(ex, "Could not read zone records"); } return(0); }
public int BackupItem(string tempFolder, System.Xml.XmlWriter writer, ServiceProviderItem item, ResourceGroupInfo group) { if (item is SystemUser) { // backup system user SharePointServer sps = GetSharePoint(item.ServiceId); // read user info SystemUser user = sps.GetUser(item.Name); user.Password = ((SystemUser)item).Password; XmlSerializer serializer = new XmlSerializer(typeof(SystemUser)); serializer.Serialize(writer, user); } else if (item is SystemGroup) { // backup system group SharePointServer sps = GetSharePoint(item.ServiceId); // read site info SystemGroup sysGroup = sps.GetGroup(item.Name); XmlSerializer serializer = new XmlSerializer(typeof(SystemGroup)); serializer.Serialize(writer, group); } return(0); }
public int BackupItem(string tempFolder, System.Xml.XmlWriter writer, ServiceProviderItem item, ResourceGroupInfo group) { if (item is HomeFolder) { // backup home folder files string backupName = String.Format("SpaceFiles_{0}_{1}.zip", item.Id, DateTime.Now.Ticks); // get the list of remote files List <SystemFile> files = FilesController.GetFiles(item.PackageId, "\\", true); string[] zipFiles = new string[files.Count]; for (int i = 0; i < zipFiles.Length; i++) { zipFiles[i] = files[i].Name; } // zip remote files FilesController.ZipFiles(item.PackageId, zipFiles, backupName); // download zipped file string localBackupPath = Path.Combine(tempFolder, backupName); byte[] buffer = null; FileStream stream = new FileStream(localBackupPath, FileMode.Create, FileAccess.Write); int offset = 0; long length = 0; do { // read remote content buffer = FilesController.GetFileBinaryChunk(item.PackageId, backupName, offset, FILE_BUFFER_LENGTH); // write remote content stream.Write(buffer, 0, buffer.Length); length += buffer.Length; offset += FILE_BUFFER_LENGTH; }while (buffer.Length == FILE_BUFFER_LENGTH); stream.Close(); // delete zipped file if (FilesController.FileExists(item.PackageId, backupName)) { FilesController.DeleteFiles(item.PackageId, new string[] { backupName }); } // add file pointer BackupController.WriteFileElement(writer, "SpaceFiles", backupName, length); // store meta item XmlSerializer serializer = new XmlSerializer(typeof(HomeFolder)); serializer.Serialize(writer, item); } else if (item is SystemDSN) { // backup ODBC DSN OS.OperatingSystem os = GetOS(item.ServiceId); // read DSN info SystemDSN itemDsn = item as SystemDSN; SystemDSN dsn = os.GetDSN(item.Name); dsn.DatabasePassword = itemDsn.DatabasePassword; XmlSerializer serializer = new XmlSerializer(typeof(SystemDSN)); serializer.Serialize(writer, dsn); } return(0); }
public int BackupItem(string tempFolder, XmlWriter writer, ServiceProviderItem item, ResourceGroupInfo group) { if (item is SqlDatabase) { // backup database DatabaseServer sql = GetDatabaseServer(item.ServiceId); string backupName = String.Format("DatabaseBackup_{0}.zip", item.Id); string remoteBackupFile = sql.BackupDatabase(item.Name, backupName, true); // download remote backup string localBackupPath = Path.Combine(tempFolder, backupName); byte[] buffer = null; FileStream stream = new FileStream(localBackupPath, FileMode.Create, FileAccess.Write); int offset = 0; long length = 0; do { // read remote content buffer = sql.GetTempFileBinaryChunk(remoteBackupFile, offset, FILE_BUFFER_LENGTH); // write remote content stream.Write(buffer, 0, buffer.Length); length += buffer.Length; offset += FILE_BUFFER_LENGTH; }while (buffer.Length == FILE_BUFFER_LENGTH); stream.Close(); // add file pointer BackupController.WriteFileElement(writer, "DatabaseBackup", backupName, length); // store meta item SqlDatabase database = sql.GetDatabase(item.Name); XmlSerializer serializer = new XmlSerializer(typeof(SqlDatabase)); serializer.Serialize(writer, database); } else if (item is SqlUser) { // backup user DatabaseServer sql = GetDatabaseServer(item.ServiceId); SqlUser userItem = item as SqlUser; // store user info SqlUser user = sql.GetUser(item.Name, GetSqlDatabasesArray(item.PackageId, item.GroupName)); user.Password = userItem.Password; XmlSerializer serializer = new XmlSerializer(typeof(SqlUser)); serializer.Serialize(writer, user); } return(0); }
public static int BackupInternal(string taskId, int userId, int packageId, int serviceId, int serverId, string backupFileName, int storePackageId, string storePackageFolder, string storeServerFolder, bool deleteTempBackup) { try { TaskManager.StartTask(taskId, "BACKUP", "BACKUP", backupFileName, SecurityContext.User.UserId); // Set Ending .scpak if (!backupFileName.EndsWith(".scpak")) { backupFileName += ".scpak"; } // get the list of items to backup TaskManager.Write("Calculate items to backup"); List <ServiceProviderItem> items = GetBackupItems(userId, packageId, serviceId, serverId); if (items.Count == 0) { return(0); } // group items by item types Dictionary <int, List <ServiceProviderItem> > groupedItems = new Dictionary <int, List <ServiceProviderItem> >(); // sort by groups foreach (ServiceProviderItem item in items) { // add to group if (!groupedItems.ContainsKey(item.TypeId)) { groupedItems[item.TypeId] = new List <ServiceProviderItem>(); } groupedItems[item.TypeId].Add(item); } // temp backup folder string tempFolder = GetTempBackupFolder(); // create backup catalog file StringWriter sw = new StringWriter(); XmlTextWriter writer = new XmlTextWriter(sw); // write backup file header writer.WriteProcessingInstruction("xml", "version=\"1.0\" encoding=\"utf-8\""); writer.WriteStartElement("Backup"); writer.WriteStartElement("Info"); writer.WriteElementString("Name", backupFileName); writer.WriteElementString("Created", DateTime.Now.ToString("r")); writer.WriteElementString("User", GetLoggedUsername()); writer.WriteEndElement(); // Info // determine the number of items to backup int totalItems = 0; foreach (int itemTypeId in groupedItems.Keys) { // load item type ServiceProviderItemType itemType = PackageController.GetServiceItemType(itemTypeId); if (!itemType.Backupable) { continue; } totalItems += groupedItems[itemTypeId].Count; } TaskManager.IndicatorMaximum = totalItems + 2; TaskManager.IndicatorCurrent = 0; // backup grouped items writer.WriteStartElement("Items"); foreach (int itemTypeId in groupedItems.Keys) { // load item type ServiceProviderItemType itemType = PackageController.GetServiceItemType(itemTypeId); if (!itemType.Backupable) { continue; } // load group ResourceGroupInfo group = ServerController.GetResourceGroup(itemType.GroupId); // instantiate controller IBackupController controller = null; try { if (group.GroupController != null) { controller = Activator.CreateInstance(Type.GetType(group.GroupController)) as IBackupController; } if (controller != null) { // backup items foreach (ServiceProviderItem item in groupedItems[itemTypeId]) { TaskManager.Write(String.Format("Backup {0} of {1} - {2} '{3}'", TaskManager.IndicatorCurrent + 1, totalItems, itemType.DisplayName, item.Name)); try { int backupResult = BackupItem(tempFolder, writer, item, group, controller); } catch (Exception ex) { TaskManager.WriteError(ex, "Can't backup item"); } // increment progress TaskManager.IndicatorCurrent += 1; } } } catch (Exception ex) { TaskManager.WriteError(ex); } } writer.WriteEndElement(); // Items // close catalog writer writer.WriteEndElement(); // Backup writer.Close(); // convert to Xml document XmlDocument doc = new XmlDocument(); doc.LoadXml(sw.ToString()); // sign XML document //SignXmlDocument(doc); // save signed doc to file try { doc.Save(Path.Combine(tempFolder, BACKUP_CATALOG_FILE_NAME)); } catch (Exception ex) { TaskManager.WriteError(ex, "Can't save backup catalog file: " + Path.Combine(tempFolder, BACKUP_CATALOG_FILE_NAME)); return(0); } TaskManager.Write("Packaging backup..."); // compress backup files string[] zipFiles = Directory.GetFiles(tempFolder); string[] zipFileNames = new string[zipFiles.Length]; for (int i = 0; i < zipFiles.Length; i++) { zipFileNames[i] = Path.GetFileName(zipFiles[i]); } string backupFileNamePath = Path.Combine(tempFolder, backupFileName); try { FileUtils.ZipFiles(backupFileNamePath, tempFolder, zipFileNames); // delete packed files foreach (string zipFile in zipFiles) { File.Delete(zipFile); } } catch (Exception ex) { TaskManager.WriteError(ex, "Can't zip backed up files"); return(0); } TaskManager.IndicatorCurrent += 1; TaskManager.Write("Copying backup..."); // move/copy backup file if (!String.IsNullOrEmpty(storeServerFolder)) { // copy to local folder or UNC try { string destFile = Path.Combine(storeServerFolder, backupFileName); File.Copy(backupFileNamePath, destFile, true); } catch (Exception ex) { TaskManager.WriteError(ex, "Can't copy backup to destination location"); return(0); } } else if (storePackageId > 0) { try { // copy to space folder int osServiceId = PackageController.GetPackageServiceId(storePackageId, ResourceGroups.Os); if (osServiceId > 0) { OS.OperatingSystem os = new OS.OperatingSystem(); ServiceProviderProxy.Init(os, osServiceId); string remoteBackupPath = FilesController.GetFullPackagePath(storePackageId, Path.Combine(storePackageFolder, backupFileName)); FileStream stream = new FileStream(backupFileNamePath, FileMode.Open, FileAccess.Read); byte[] buffer = new byte[FILE_BUFFER_LENGTH]; int readBytes = 0; do { // read package file readBytes = stream.Read(buffer, 0, FILE_BUFFER_LENGTH); if (readBytes < FILE_BUFFER_LENGTH) { // resize buffer Array.Resize <byte>(ref buffer, readBytes); } // write remote backup file os.AppendFileBinaryContent(remoteBackupPath, buffer); }while (readBytes == FILE_BUFFER_LENGTH); stream.Close(); } } catch (Exception ex) { TaskManager.WriteError(ex, "Can't copy backup to destination hosting space"); return(0); } } TaskManager.IndicatorCurrent += 1; // delete backup file if required if (deleteTempBackup) { try { // delete backup folder and all its contents Directory.Delete(tempFolder, true); } catch (Exception ex) { TaskManager.WriteError(ex, "Can't delete temporary backup folder"); return(0); } } BackgroundTask topTask = TaskManager.TopTask; topTask.IndicatorCurrent = topTask.IndicatorMaximum; TaskController.UpdateTask(topTask); } catch (Exception ex) { TaskManager.WriteError(ex); } finally { TaskManager.CompleteTask(); } return(0); }
public static int ImportItemsInternal(string taskId, int packageId, string[] items) { PackageInfo package = PackageController.GetPackage(packageId); TaskManager.StartTask(taskId, "IMPORT", "IMPORT", package.PackageName, packageId); TaskManager.IndicatorMaximum = items.Length; TaskManager.IndicatorCurrent = 0; Dictionary <int, List <string> > groupedItems = new Dictionary <int, List <string> >(); List <string> customItems = new List <string>(); // sort by groups foreach (string item in items) { string[] itemParts = item.Split('|'); if (!item.StartsWith("+")) { int itemTypeId = Utils.ParseInt(itemParts[0], 0); string itemName = itemParts[1]; // add to group if (!groupedItems.ContainsKey(itemTypeId)) { groupedItems[itemTypeId] = new List <string>(); } groupedItems[itemTypeId].Add(itemName); } else { switch (itemParts[0]) { case ("+100"): if (itemParts.Length > 2) { customItems.Add(item); } break; } } } // import each group foreach (int itemTypeId in groupedItems.Keys) { // load item type ServiceProviderItemType itemType = PackageController.GetServiceItemType(itemTypeId); // load group ResourceGroupInfo group = ServerController.GetResourceGroup(itemType.GroupId); // instantiate controller IImportController ctrl = null; try { ctrl = Activator.CreateInstance(Type.GetType(group.GroupController)) as IImportController; if (ctrl != null) { foreach (string itemName in groupedItems[itemTypeId]) { TaskManager.Write(String.Format("Import {0} '{1}'", itemType.DisplayName, itemName)); try { // perform import ctrl.ImportItem(packageId, itemTypeId, Type.GetType(itemType.TypeName), group, itemName); } catch (Exception ex) { TaskManager.WriteError(ex, "Can't import item"); } TaskManager.IndicatorCurrent++; } } } catch { /* do nothing */ } } foreach (string s in customItems) { try { string[] sParts = s.Split('|'); switch (sParts[0]) { case "+100": TaskManager.Write(String.Format("Import {0}", sParts[4])); int result = WebServerController.ImporHostHeader(int.Parse(sParts[2], 0), int.Parse(sParts[3], 0), int.Parse(sParts[5], 0)); if (result < 0) { TaskManager.WriteError(String.Format("Failed to Import {0} ,error: {1}: ", sParts[4], result.ToString())); } break; } } catch { /* do nothing */ } TaskManager.IndicatorCurrent++; } TaskManager.IndicatorCurrent = items.Length; TaskManager.CompleteTask(); return(0); }
public List <string> GetImportableItems(int packageId, int itemTypeId, Type itemType, ResourceGroupInfo group) { List <string> items = new List <string>(); // get service id int serviceId = PackageController.GetPackageServiceId(packageId, group.GroupName); if (serviceId == 0) { return(items); } // Mail provider DNSServer dns = new DNSServer(); ServiceProviderProxy.Init(dns, serviceId); // IDN: The list of importable names is populated with unicode names, to make it easier for the user var idn = new IdnMapping(); if (itemType == typeof(DnsZone)) { items.AddRange(dns.GetZones().Select(z => { try { return(idn.GetUnicode(z)); } catch { return(null); } })); } return(items); }
public int RestoreItem(string tempFolder, XmlNode itemNode, int itemId, Type itemType, string itemName, int packageId, int serviceId, ResourceGroupInfo group) { if (itemType == typeof(SqlDatabase)) { DatabaseServer sql = GetDatabaseServer(serviceId); // extract meta item XmlSerializer serializer = new XmlSerializer(typeof(SqlDatabase)); SqlDatabase db = (SqlDatabase)serializer.Deserialize( new XmlNodeReader(itemNode.SelectSingleNode("SqlDatabase"))); // create database if required if (!sql.DatabaseExists(itemName)) { sql.CreateDatabase(db); } // copy database backup to remote server XmlNode fileNode = itemNode.SelectSingleNode("File[@name='DatabaseBackup']"); string backupFileName = fileNode.Attributes["path"].Value; long backupFileLength = Int64.Parse(fileNode.Attributes["size"].Value); string localBackupFilePath = Path.Combine(tempFolder, backupFileName); if (new FileInfo(localBackupFilePath).Length != backupFileLength) { return(-3); } FileStream stream = new FileStream(localBackupFilePath, FileMode.Open, FileAccess.Read); byte[] buffer = new byte[FILE_BUFFER_LENGTH]; int readBytes = 0; long length = 0; string remoteBackupPath = null; do { // read package file readBytes = stream.Read(buffer, 0, FILE_BUFFER_LENGTH); length += readBytes; if (readBytes < FILE_BUFFER_LENGTH) { // resize buffer Array.Resize <byte>(ref buffer, readBytes); } // write remote backup file string tempPath = sql.AppendTempFileBinaryChunk(backupFileName, remoteBackupPath, buffer); if (remoteBackupPath == null) { remoteBackupPath = tempPath; } }while (readBytes == FILE_BUFFER_LENGTH); stream.Close(); // restore database sql.RestoreDatabase(itemName, new string[] { remoteBackupPath }); // add meta-item if required if (PackageController.GetPackageItemByName(packageId, group.GroupName, itemName, typeof(SqlDatabase)) == null) { db.PackageId = packageId; db.ServiceId = serviceId; db.GroupName = group.GroupName; PackageController.AddPackageItem(db); } } else if (itemType == typeof(SqlUser)) { DatabaseServer sql = GetDatabaseServer(serviceId); // extract meta item XmlSerializer serializer = new XmlSerializer(typeof(SqlUser)); SqlUser user = (SqlUser)serializer.Deserialize( new XmlNodeReader(itemNode.SelectSingleNode("SqlUser"))); // create user if required if (!sql.UserExists(itemName)) { sql.CreateUser(user, CryptoUtils.Decrypt(user.Password)); } // add meta-item if required if (PackageController.GetPackageItemByName(packageId, group.GroupName, itemName, typeof(SqlUser)) == null) { user.PackageId = packageId; user.ServiceId = serviceId; user.GroupName = group.GroupName; PackageController.AddPackageItem(user); } } return(0); }
public int RestoreItem(string tempFolder, System.Xml.XmlNode itemNode, int itemId, Type itemType, string itemName, int packageId, int serviceId, ResourceGroupInfo group) { if (itemType == typeof(HomeFolder)) { OS.OperatingSystem os = GetOS(serviceId); // extract meta item XmlSerializer serializer = new XmlSerializer(typeof(HomeFolder)); HomeFolder homeFolder = (HomeFolder)serializer.Deserialize( new XmlNodeReader(itemNode.SelectSingleNode("HomeFolder"))); // create home folder if required if (!os.DirectoryExists(homeFolder.Name)) { os.CreatePackageFolder(homeFolder.Name); } // copy database backup to remote server XmlNode fileNode = itemNode.SelectSingleNode("File[@name='SpaceFiles']"); string backupFileName = fileNode.Attributes["path"].Value; long backupFileLength = Int64.Parse(fileNode.Attributes["size"].Value); string localBackupFilePath = Path.Combine(tempFolder, backupFileName); if (new FileInfo(localBackupFilePath).Length != backupFileLength) { return(-3); } FileStream stream = new FileStream(localBackupFilePath, FileMode.Open, FileAccess.Read); byte[] buffer = new byte[FILE_BUFFER_LENGTH]; int readBytes = 0; long length = 0; string remoteBackupPath = Path.Combine(homeFolder.Name, backupFileName); do { // read package file readBytes = stream.Read(buffer, 0, FILE_BUFFER_LENGTH); length += readBytes; if (readBytes < FILE_BUFFER_LENGTH) { // resize buffer Array.Resize <byte>(ref buffer, readBytes); } // write remote backup file os.AppendFileBinaryContent(remoteBackupPath, buffer); }while (readBytes == FILE_BUFFER_LENGTH); stream.Close(); // unzip files os.UnzipFiles(remoteBackupPath, homeFolder.Name); // delete archive if (os.FileExists(remoteBackupPath)) { os.DeleteFile(remoteBackupPath); } // add meta-item if required if (PackageController.GetPackageItemByName(packageId, itemName, typeof(HomeFolder)) == null) { homeFolder.PackageId = packageId; homeFolder.ServiceId = serviceId; PackageController.AddPackageItem(homeFolder); } } else if (itemType == typeof(SystemDSN)) { OS.OperatingSystem os = GetOS(serviceId); // extract meta item XmlSerializer serializer = new XmlSerializer(typeof(SystemDSN)); SystemDSN dsn = (SystemDSN)serializer.Deserialize( new XmlNodeReader(itemNode.SelectSingleNode("SystemDSN"))); // create DSN if required if (os.GetDSN(itemName) == null) { dsn.DatabasePassword = CryptoUtils.Decrypt(dsn.DatabasePassword); os.CreateDSN(dsn); // restore password dsn.DatabasePassword = CryptoUtils.Encrypt(dsn.DatabasePassword); } // add meta-item if required if (PackageController.GetPackageItemByName(packageId, itemName, typeof(SystemDSN)) == null) { dsn.PackageId = packageId; dsn.ServiceId = serviceId; PackageController.AddPackageItem(dsn); } } return(0); }
public void ImportItem(int packageId, int itemTypeId, Type itemType, ResourceGroupInfo group, string itemName) { // get service id int serviceId = PackageController.GetPackageServiceId(packageId, group.GroupName); if (serviceId == 0) { return; } if (itemType == typeof(DnsZone)) { // Get ascii form in punycode var zoneName = GetAsciiZoneName(itemName); // add DNS zone DnsZone zone = new DnsZone(); zone.Name = zoneName; zone.ServiceId = serviceId; zone.PackageId = packageId; int zoneId = PackageController.AddPackageItem(zone); // Add secondary zone(s) try { // get secondary DNS services var primSettings = ServerController.GetServiceSettings(serviceId); var secondaryServiceIds = new List <int>(); var strSecondaryServices = primSettings["SecondaryDNSServices"]; if (!String.IsNullOrEmpty(strSecondaryServices)) { var secondaryServices = strSecondaryServices.Split(','); secondaryServiceIds.AddRange(secondaryServices.Select(strSecondaryId => Utils.ParseInt(strSecondaryId, 0)).Where(secondaryId => secondaryId != 0)); } // add secondary zones var secondaryZoneFound = false; foreach (var secondaryId in secondaryServiceIds) { var secDns = GetDNSServer(secondaryId); if (secDns.ZoneExists(zoneName)) { secondaryZoneFound = true; var secondaryZone = new SecondaryDnsZone { Name = zoneName, ServiceId = secondaryId, PackageId = packageId }; PackageController.AddPackageItem(secondaryZone); } } if (!secondaryZoneFound) { TaskManager.WriteWarning("No secondary zone(s) found when importing zone " + itemName); } } catch (Exception ex) { TaskManager.WriteError(ex, "Error importing secondary zone(s)"); } // add/update domains/pointers RestoreDomainByZone(itemName, packageId, zoneId); } }