private WebSiteResponse GetWebDocument(string url, string username, string password) { WebSiteResponse result = new WebSiteResponse(); HttpWebResponse resp = null; StringBuilder sb = new StringBuilder(); Stream respStream = null; try { // Enable TLS1.2 support if its https if (url.StartsWith("https://")) { TaskManager.Write("Identified as SSL Website"); ServicePointManager.SecurityProtocol = SecurityProtocolType.Tls | SecurityProtocolType.Tls12 | SecurityProtocolType.Ssl3; } WebRequest req = WebRequest.Create(url); // set site credentials if required if (!String.IsNullOrEmpty(username)) { req.Credentials = new NetworkCredential(username, password); } resp = (HttpWebResponse)req.GetResponse(); respStream = resp.GetResponseStream(); string charSet = !String.IsNullOrEmpty(resp.CharacterSet) ? resp.CharacterSet : "utf-8"; Encoding encode = System.Text.Encoding.GetEncoding(charSet); StreamReader sr = new StreamReader(respStream, encode); Char[] read = new Char[256]; int count = sr.Read(read, 0, 256); while (count > 0) { String str = new String(read, 0, count); sb.Append(str); count = sr.Read(read, 0, 256); } result.Status = (int)resp.StatusCode; result.Text = sb.ToString(); } catch (ThreadAbortException) { } catch (WebException ex) { result.Status = (int)((HttpWebResponse)ex.Response).StatusCode; result.Text = ex.ToString(); TaskManager.WriteError(ex.ToString()); } catch (Exception ex) { result.Status = -1; result.Text = ex.ToString(); TaskManager.WriteError(ex.ToString()); } finally { if (respStream != null) { respStream.Close(); } if (resp != null) { resp.Close(); } } return(result); }
public override void DoWork() { // Input parameters: // - URL // - USERNAME // - PASSWORD // - RESPONSE_STATUS // - RESPONSE_CONTAIN // - RESPONSE_DOESNT_CONTAIN // - MAIL_FROM // - MAIL_TO // - MAIL_SUBJECT // - MAIL_BODY BackgroundTask topTask = TaskManager.TopTask; // get input parameters string url = (string)topTask.GetParamValue("URL"); string username = (string)topTask.GetParamValue("USERNAME"); string password = (string)topTask.GetParamValue("PASSWORD"); string strResponseStatus = (string)topTask.GetParamValue("RESPONSE_STATUS"); string responseContains = (string)topTask.GetParamValue("RESPONSE_CONTAIN"); string responseNotContains = (string)topTask.GetParamValue("RESPONSE_DOESNT_CONTAIN"); bool useResponseStatus = Convert.ToBoolean(topTask.GetParamValue("USE_RESPONSE_STATUS")); bool useResponseContains = Convert.ToBoolean(topTask.GetParamValue("USE_RESPONSE_CONTAIN")); bool useResponseDoesntContain = Convert.ToBoolean(topTask.GetParamValue("USE_RESPONSE_DOESNT_CONTAIN")); // check input parameters if (String.IsNullOrEmpty(url)) { TaskManager.WriteWarning("Specify 'Web Site URL' task parameter."); return; } if ((String.IsNullOrEmpty(strResponseStatus) || !useResponseStatus) && (String.IsNullOrEmpty(responseContains) || !useResponseContains) && (String.IsNullOrEmpty(responseNotContains) || !useResponseDoesntContain)) { TaskManager.WriteWarning("Specify one of 'Response Status', 'Response Contain' or 'Response Doesn't Contain' parameters."); return; } int responseStatus = Utils.ParseInt(strResponseStatus, -1); if (!String.IsNullOrEmpty(strResponseStatus) && responseStatus == -1) { TaskManager.WriteWarning("Specify correct response HTTP status, e.g. 404, 500, 503, etc."); return; } // load web site WebSiteResponse resp = GetWebDocument(url, username, password); // check if there was a generic error if (resp.Status == -1) { SendMailMessage(url, resp.Text, ""); } bool sendMessage = false; // check status if (responseStatus != -1) { sendMessage |= ((resp.Status == responseStatus) && useResponseStatus); } // check "contains" if (!String.IsNullOrEmpty(responseContains)) { sendMessage |= ((resp.Text.ToLower().IndexOf(responseContains.ToLower()) != -1) && useResponseContains); } // check "not contains" if (!String.IsNullOrEmpty(responseNotContains)) { sendMessage |= ((resp.Text.ToLower().IndexOf(responseNotContains.ToLower()) == -1) && useResponseDoesntContain); } if (sendMessage) { SendMailMessage(url, "", resp.Text); } }
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 override void DoWork() { // Input parameters: // - FILE_PATH // - FTP_SERVER // - FTP_USERNAME // - FTP_PASSWORD // - FTP_FOLDER BackgroundTask topTask = TaskManager.TopTask; // get input parameters string filePath = (string)topTask.GetParamValue("FILE_PATH"); string ftpServer = (string)topTask.GetParamValue("FTP_SERVER"); string ftpUsername = (string)topTask.GetParamValue("FTP_USERNAME"); string ftpPassword = (string)topTask.GetParamValue("FTP_PASSWORD"); string ftpFolder = (string)topTask.GetParamValue("FTP_FOLDER"); // check input parameters if (String.IsNullOrEmpty(filePath)) { TaskManager.WriteWarning("Specify 'File' task parameter"); return; } if (String.IsNullOrEmpty(ftpServer)) { TaskManager.WriteWarning("Specify 'FTP Server' task parameter"); return; } // substitute parameters DateTime d = DateTime.Now; string date = d.ToString("yyyyMMdd"); string time = d.ToString("HHmm"); filePath = Utils.ReplaceStringVariable(filePath, "date", date); filePath = Utils.ReplaceStringVariable(filePath, "time", time); // build FTP command file StringBuilder sb = new StringBuilder(); StringWriter writer = new StringWriter(sb); // FTP server writer.WriteLine("open " + ftpServer); // check if anonymous mode if (String.IsNullOrEmpty(ftpUsername)) { ftpUsername = "******"; ftpPassword = "******"; } // FTP username/password writer.WriteLine(ftpUsername); writer.WriteLine(ftpPassword); // check if we need to change remote folder if (!String.IsNullOrEmpty(ftpFolder)) { writer.WriteLine("cd " + ftpFolder.Replace("\\", "/")); } // file to send writer.WriteLine("binary"); writer.WriteLine("put " + FilesController.GetFullPackagePath(topTask.PackageId, filePath)); // bye writer.WriteLine("bye"); string cmdBatch = sb.ToString(); // create temp file in user space string cmdPath = Utils.GetRandomString(10) + ".txt"; string fullCmdPath = FilesController.GetFullPackagePath(topTask.PackageId, cmdPath); // upload batch FilesController.UpdateFileBinaryContent(topTask.PackageId, cmdPath, Encoding.UTF8.GetBytes(cmdBatch)); // execute system command // load OS service int serviceId = PackageController.GetPackageServiceId(topTask.PackageId, ResourceGroups.Os); // load service ServiceInfo service = ServerController.GetServiceInfo(serviceId); if (service == null) { return; } WindowsServer winServer = new WindowsServer(); ServiceProviderProxy.ServerInit(winServer, service.ServerId); TaskManager.Write(winServer.ExecuteSystemCommand("ftp.exe", "-s:" + fullCmdPath)); // delete batch file FilesController.DeleteFiles(topTask.PackageId, new string[] { cmdPath }); }
public static int AddSharePointGroup(SystemGroup item) { // check account int accountCheck = SecurityContext.CheckAccount(DemandAccount.NotDemo | DemandAccount.IsActive); if (accountCheck < 0) { return(accountCheck); } // check package int packageCheck = SecurityContext.CheckPackage(item.PackageId, DemandPackage.IsActive); if (packageCheck < 0) { return(packageCheck); } // check quota QuotaValueInfo quota = PackageController.GetPackageQuota(item.PackageId, Quotas.SHAREPOINT_GROUPS); if (quota.QuotaExhausted) { return(BusinessErrorCodes.ERROR_SHAREPOINT_GROUPS_RESOURCE_QUOTA_LIMIT); } // check if mail resource is available int serviceId = PackageController.GetPackageServiceId(item.PackageId, ResourceGroups.SharePoint); if (serviceId == 0) { return(BusinessErrorCodes.ERROR_SHAREPOINT_RESOURCE_UNAVAILABLE); } // check package items if (PackageController.GetPackageItemByName(item.PackageId, ResourceGroups.SharePoint, item.Name, typeof(SystemGroup)) != null) { return(BusinessErrorCodes.ERROR_SHAREPOINT_GROUPS_PACKAGE_ITEM_EXISTS); } // place log record TaskManager.StartTask("SHAREPOINT", "ADD_GROUP", item.Name); try { // check service items SharePointServer sps = GetSharePoint(serviceId); if (sps.GroupExists(item.Name)) { return(BusinessErrorCodes.ERROR_SHAREPOINT_GROUPS_SERVICE_ITEM_EXISTS); } item.Description = "SolidCP System Group"; // add service item sps.CreateGroup(item); // save item item.ServiceId = serviceId; int itemId = PackageController.AddPackageItem(item); TaskManager.ItemId = itemId; return(itemId); } catch (Exception ex) { throw TaskManager.WriteError(ex); } finally { TaskManager.CompleteTask(); } }
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 AddSite(SharePointSite item) { // check account int accountCheck = SecurityContext.CheckAccount(DemandAccount.NotDemo | DemandAccount.IsActive); if (accountCheck < 0) { return(accountCheck); } // check package int packageCheck = SecurityContext.CheckPackage(item.PackageId, DemandPackage.IsActive); if (packageCheck < 0) { return(packageCheck); } // check quota QuotaValueInfo quota = PackageController.GetPackageQuota(item.PackageId, Quotas.SHAREPOINT_SITES); if (quota.QuotaExhausted) { return(BusinessErrorCodes.ERROR_SHAREPOINT_RESOURCE_QUOTA_LIMIT); } // check if stats resource is available int serviceId = PackageController.GetPackageServiceId(item.PackageId, ResourceGroups.SharePoint); if (serviceId == 0) { return(BusinessErrorCodes.ERROR_SHAREPOINT_RESOURCE_UNAVAILABLE); } // check package items if (PackageController.GetPackageItemByName(item.PackageId, item.Name, typeof(SharePointSite)) != null) { return(BusinessErrorCodes.ERROR_SHAREPOINT_PACKAGE_ITEM_EXISTS); } // place log record TaskManager.StartTask("SHAREPOINT", "ADD_SITE", item.Name); TaskManager.WriteParameter("Database group", item.DatabaseGroupName); TaskManager.WriteParameter("Database name", item.DatabaseName); TaskManager.WriteParameter("Database user", item.DatabaseUser); int databaseItemId = 0; int databaseUserItemId = 0; try { // load web site WebSite siteItem = (WebSite)PackageController.GetPackageItemByName(item.PackageId, item.Name, typeof(WebSite)); if (siteItem == null) { return(BusinessErrorCodes.ERROR_WEB_SITE_SERVICE_UNAVAILABLE); } // get service web site WebServer web = new WebServer(); ServiceProviderProxy.Init(web, siteItem.ServiceId); WebSite site = web.GetSite(siteItem.SiteId); ///////////////////////////////////////// // // PREPARE SHAREPOINT SITE INSTALLATION // ServiceInfo wssService = ServerController.GetServiceInfo(serviceId); bool wss30 = (wssService.ProviderId == 23); // WSS 3.0 // remember original web site bindings ServerBinding[] bindings = site.Bindings; // set application pool and root folder item.ApplicationPool = site.ApplicationPool; item.RootFolder = site.ContentPath; // change web site .NET framework if required bool siteUpdated = false; if (!wss30 && (site.AspNetInstalled != "1" || site.DedicatedApplicationPool)) { site.AspNetInstalled = "1"; site.DedicatedApplicationPool = false; web.UpdateSite(site); siteUpdated = true; } if (wss30 && site.AspNetInstalled != "2") { site.AspNetInstalled = "2"; web.UpdateSite(site); siteUpdated = true; } if (siteUpdated) { site = web.GetSite(siteItem.SiteId); item.ApplicationPool = site.ApplicationPool; } if (site.FrontPageInstalled) { // remove FrontPage web.UninstallFrontPage(siteItem.SiteId, siteItem.FrontPageAccount); } // create SQL database SqlDatabase database = new SqlDatabase(); database.PackageId = item.PackageId; database.Name = item.DatabaseName; databaseItemId = DatabaseServerController.AddSqlDatabase(database, item.DatabaseGroupName); if (databaseItemId < 0) { return(databaseItemId); } // create SQL user SqlUser dbUser = new SqlUser(); dbUser.PackageId = item.PackageId; dbUser.Name = item.DatabaseUser; dbUser.Password = item.DatabasePassword; databaseUserItemId = DatabaseServerController.AddSqlUser(dbUser, item.DatabaseGroupName); if (databaseUserItemId < 0) { return(databaseUserItemId); } // delete SQL database from service // and change database user role int sqlServiceId = PackageController.GetPackageServiceId(item.PackageId, item.DatabaseGroupName); if (sqlServiceId < 0) { return(BusinessErrorCodes.ERROR_MSSQL_RESOURCE_UNAVAILABLE); } // load server settings StringDictionary sqlSettings = ServerController.GetServiceSettings(sqlServiceId); item.DatabaseServer = sqlSettings["ExternalAddress"]; DatabaseServer dbServer = new DatabaseServer(); ServiceProviderProxy.Init(dbServer, sqlServiceId); // delete database from service dbServer.DeleteDatabase(database.Name); // give SQL user "db_creator" role dbServer.ExecuteSqlNonQuery("master", String.Format( "sp_addsrvrolemember '{0}', 'dbcreator'\nGO", dbUser.Name)); // install SharePoint site SharePointServer sps = GetSharePoint(serviceId); sps.ExtendVirtualServer(item); // remove SQL user from "db_creator" role dbServer.ExecuteSqlNonQuery("master", String.Format( "sp_dropsrvrolemember '{0}', 'dbcreator'\nGO", dbUser.Name)); // restore original web site bindings web.UpdateSiteBindings(site.SiteId, bindings, false); // save statistics item item.ServiceId = serviceId; int itemId = PackageController.AddPackageItem(item); TaskManager.ItemId = itemId; return(itemId); } catch (Exception ex) { // delete database if required if (databaseItemId > 0) { DatabaseServerController.DeleteSqlDatabase(databaseItemId); } // delete user if required if (databaseUserItemId > 0) { DatabaseServerController.DeleteSqlUser(databaseUserItemId); } throw TaskManager.WriteError(ex); } finally { TaskManager.CompleteTask(); } }
public static int UpdateSharePointUser(SystemUser item) { // check account int accountCheck = SecurityContext.CheckAccount(DemandAccount.NotDemo | DemandAccount.IsActive); if (accountCheck < 0) { return(accountCheck); } // load original meta item SystemUser origItem = (SystemUser)PackageController.GetPackageItem(item.Id); if (origItem == null) { return(BusinessErrorCodes.ERROR_SHAREPOINT_USERS_PACKAGE_ITEM_NOT_FOUND); } // check package int packageCheck = SecurityContext.CheckPackage(origItem.PackageId, DemandPackage.IsActive); if (packageCheck < 0) { return(packageCheck); } // place log record TaskManager.StartTask("SHAREPOINT", "UPDATE_USER", origItem.Name, item.Id); try { // get service SharePointServer sps = GetSharePoint(origItem.ServiceId); item.Name = origItem.Name; item.FullName = origItem.Name; item.Description = "SolidCP System Account"; item.AccountDisabled = false; item.PasswordCantChange = true; item.PasswordNeverExpires = true; // update service item sps.UpdateUser(item); // update meta item if (item.Password != "") { item.Password = CryptoUtils.Encrypt(item.Password); PackageController.UpdatePackageItem(item); } return(0); } catch (Exception ex) { throw TaskManager.WriteError(ex); } finally { TaskManager.CompleteTask(); } }
public static int InstallWebPartsPackage(int itemId, string uploadedFile, string packageFile) { // check account int accountCheck = SecurityContext.CheckAccount(DemandAccount.NotDemo | DemandAccount.IsActive); if (accountCheck < 0) { return(accountCheck); } // load original meta item SharePointSite item = (SharePointSite)PackageController.GetPackageItem(itemId); if (item == null) { return(BusinessErrorCodes.ERROR_SHAREPOINT_PACKAGE_ITEM_NOT_FOUND); } // check package int packageCheck = SecurityContext.CheckPackage(item.PackageId, DemandPackage.IsActive); if (packageCheck < 0) { return(packageCheck); } // place log record TaskManager.StartTask("SHAREPOINT", "INSTALL_WEBPARTS", item.Name, itemId); TaskManager.WriteParameter("Package file", packageFile); try { SharePointServer sps = GetSharePoint(item.ServiceId); string backupFile = null; if (!String.IsNullOrEmpty(packageFile)) { // copy package files to the remote SharePoint Server string path = null; byte[] buffer = null; int offset = 0; do { // read package file buffer = FilesController.GetFileBinaryChunk(item.PackageId, packageFile, offset, FILE_BUFFER_LENGTH); // write remote backup file string tempPath = sps.AppendTempFileBinaryChunk(Path.GetFileName(packageFile), path, buffer); if (path == null) { path = tempPath; backupFile = path; } offset += FILE_BUFFER_LENGTH; }while (buffer.Length == FILE_BUFFER_LENGTH); } else if (!String.IsNullOrEmpty(uploadedFile)) { // upladed files backupFile = uploadedFile; } // restore if (!String.IsNullOrEmpty(backupFile)) { sps.InstallWebPartsPackage(item.Name, backupFile); } return(0); } catch (Exception ex) { throw TaskManager.WriteError(ex); } finally { TaskManager.CompleteTask(); } }
public static string BackupVirtualServer(int itemId, string fileName, bool zipBackup, bool download, string folderName) { // check account int accountCheck = SecurityContext.CheckAccount(DemandAccount.NotDemo); if (accountCheck < 0) { return(null); } // load original meta item SharePointSite item = (SharePointSite)PackageController.GetPackageItem(itemId); if (item == null) { return(null); } // place log record TaskManager.StartTask("SHAREPOINT", "BACKUP_SITE", item.Name, itemId); try { SharePointServer sps = GetSharePoint(item.ServiceId); string backFile = sps.BackupVirtualServer(item.Name, fileName, zipBackup); if (!download) { // copy backup files to space folder string relFolderName = FilesController.CorrectRelativePath(folderName); if (!relFolderName.EndsWith("\\")) { relFolderName = relFolderName + "\\"; } // create backup folder if not exists if (!FilesController.DirectoryExists(item.PackageId, relFolderName)) { FilesController.CreateFolder(item.PackageId, relFolderName); } string packageFile = relFolderName + Path.GetFileName(backFile); // delete destination file if exists if (FilesController.FileExists(item.PackageId, packageFile)) { FilesController.DeleteFiles(item.PackageId, new string[] { packageFile }); } byte[] buffer = null; int offset = 0; do { // read remote content buffer = sps.GetTempFileBinaryChunk(backFile, offset, FILE_BUFFER_LENGTH); // write remote content FilesController.AppendFileBinaryChunk(item.PackageId, packageFile, buffer); offset += FILE_BUFFER_LENGTH; }while (buffer.Length == FILE_BUFFER_LENGTH); } return(backFile); } catch (Exception ex) { throw TaskManager.WriteError(ex); } finally { TaskManager.CompleteTask(); } }
public static int DeleteSite(int itemId) { // check account int accountCheck = SecurityContext.CheckAccount(DemandAccount.NotDemo); if (accountCheck < 0) { return(accountCheck); } // load original meta item SharePointSite origItem = (SharePointSite)PackageController.GetPackageItem(itemId); if (origItem == null) { return(BusinessErrorCodes.ERROR_SHAREPOINT_PACKAGE_ITEM_NOT_FOUND); } // place log record TaskManager.StartTask("SHAREPOINT", "DELETE_SITE", origItem.Name, itemId); try { // get service SharePointServer sps = GetSharePoint(origItem.ServiceId); // delete service item sps.UnextendVirtualServer(origItem.Name, true); try { // delete database ServiceProviderItem dbItem = PackageController.GetPackageItemByName(origItem.PackageId, origItem.DatabaseGroupName, origItem.DatabaseName, typeof(SqlDatabase)); if (dbItem != null) { DatabaseServerController.DeleteSqlDatabase(dbItem.Id); } // delete database user dbItem = PackageController.GetPackageItemByName(origItem.PackageId, origItem.DatabaseGroupName, origItem.DatabaseUser, typeof(SqlUser)); if (dbItem != null) { DatabaseServerController.DeleteSqlUser(dbItem.Id); } } catch (Exception ex2) { TaskManager.WriteError(ex2); } // delete meta item PackageController.DeletePackageItem(origItem.Id); try { // start web site WebSite site = WebServerController.GetWebSite(origItem.PackageId, origItem.Name); if (site != null) { WebServerController.ChangeSiteState(site.Id, ServerState.Started); } } catch (Exception ex) { TaskManager.WriteError(ex); } return(0); } catch (Exception ex) { throw TaskManager.WriteError(ex); } finally { TaskManager.CompleteTask(); } }