/// <summary> /// Restore backed up previously service provider item. /// </summary> /// <param name="tempFolder">Temporary directory path.</param> /// <param name="itemNode">Serialized service provider item.</param> /// <param name="itemId">Service provider item id.</param> /// <param name="itemType">Service provider item type.</param> /// <param name="itemName">Service provider item name.</param> /// <param name="packageId">Service provider item package.</param> /// <param name="serviceId">Service provider item service id.</param> /// <param name="group">Service provider item resource group.</param> /// <returns>Resulting code.</returns> public int RestoreItem(string tempFolder, XmlNode itemNode, int itemId, Type itemType, string itemName, int packageId, int serviceId, ResourceGroupInfo group) { if (itemType == typeof(SharePointEnterpriseSiteCollection)) { HostedSharePointServerEnt hostedSharePointServer = GetHostedSharePointServer(serviceId); // Deserialize item. XmlSerializer serializer = new XmlSerializer(typeof(SharePointEnterpriseSiteCollection)); SharePointEnterpriseSiteCollection siteCollection = (SharePointEnterpriseSiteCollection)serializer.Deserialize(new XmlNodeReader(itemNode.SelectSingleNode("SharePointEnterpriseSiteCollection"))); siteCollection.PackageId = packageId; siteCollection.ServiceId = serviceId; // Create site collection if needed. if (hostedSharePointServer.Enterprise_GetSiteCollection(siteCollection.Url) == null) { hostedSharePointServer.Enterprise_CreateSiteCollection(siteCollection); } // Add metabase record if needed. SharePointEnterpriseSiteCollection metaSiteCollection = (SharePointEnterpriseSiteCollection)PackageController.GetPackageItemByName(packageId, itemName, typeof(SharePointEnterpriseSiteCollection)); if (metaSiteCollection == null) { PackageController.AddPackageItem(siteCollection); } } 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(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 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); } }
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 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 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 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 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 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); }
private static int RegisterZoneItems(int spaceId, int serviceId, string zoneName, bool primaryZone) { // zone item DnsZone zone = primaryZone ? new DnsZone() : new SecondaryDnsZone(); zone.Name = GetAsciiZoneName(zoneName); zone.PackageId = spaceId; zone.ServiceId = serviceId; int zoneItemId = PackageController.AddPackageItem(zone); return(zoneItemId); }
private static int AddOrganizationToPackageItems(Organization org, int serviceId, int packageId, string organizationName, string organizationId, string domainName) { org.ServiceId = serviceId; org.PackageId = packageId; org.Name = organizationName; org.OrganizationId = organizationId; org.DefaultDomain = domainName; int itemId = PackageController.AddPackageItem(org); return(itemId); }
/// <summary> /// Imports selected item into metabase. /// </summary> /// <param name="packageId">Package to which items must be imported.</param> /// <param name="itemTypeId">Item type id.</param> /// <param name="itemType">Item type.</param> /// <param name="group">Item resource group.</param> /// <param name="itemName">Item name to import.</param> 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; } HostedSharePointServerEnt hostedSharePointServer = GetHostedSharePointServer(serviceId); if (itemType == typeof(SharePointEnterpriseSiteCollection)) { SharePointEnterpriseSiteCollection siteCollection = hostedSharePointServer.Enterprise_GetSiteCollection(itemName); PackageController.AddPackageItem(siteCollection); } }
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 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)) { // add DNS zone DnsZone zone = new DnsZone(); zone.Name = itemName; zone.ServiceId = serviceId; zone.PackageId = packageId; int zoneId = PackageController.AddPackageItem(zone); // add/update domains/pointers RestoreDomainByZone(itemName, packageId, zoneId); } }
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); } }
/// <summary> /// Adds SharePoint site collection. /// </summary> /// <param name="item">Site collection description.</param> /// <returns>Created site collection id within metabase.</returns> public static int AddSiteCollection(SharePointEnterpriseSiteCollection 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. OrganizationStatistics orgStats = OrganizationController.GetOrganizationStatistics(item.OrganizationId); //QuotaValueInfo quota = PackageController.GetPackageQuota(item.PackageId, Quotas.HOSTED_SHAREPOINT_SITES); if (orgStats.AllocatedSharePointEnterpriseSiteCollections > -1 && orgStats.CreatedSharePointEnterpriseSiteCollections >= orgStats.AllocatedSharePointEnterpriseSiteCollections) { return(BusinessErrorCodes.ERROR_SHAREPOINT_RESOURCE_QUOTA_LIMIT); } // Check if stats resource is available int serviceId = PackageController.GetPackageServiceId(item.PackageId, ResourceGroups.SharepointEnterpriseServer); if (serviceId == 0) { return(BusinessErrorCodes.ERROR_SHAREPOINT_RESOURCE_UNAVAILABLE); } StringDictionary hostedSharePointSettings = ServerController.GetServiceSettings(serviceId); QuotaValueInfo quota = PackageController.GetPackageQuota(item.PackageId, Quotas.HOSTED_SHAREPOINT_ENTERPRISE_USESHAREDSSL); Uri rootWebApplicationUri = new Uri(hostedSharePointSettings["RootWebApplicationUri"]); Organization org = OrganizationController.GetOrganization(item.OrganizationId); string siteName = item.Name; if (quota.QuotaAllocatedValue == 1) { string sslRoot = hostedSharePointSettings["SharedSSLRoot"]; string defaultDomain = org.DefaultDomain; string hostNameBase = string.Empty; string[] tmp = defaultDomain.Split('.'); if (tmp.Length == 2) { hostNameBase = tmp[0]; } else { if (tmp.Length > 2) { hostNameBase = tmp[0] + tmp[1]; } } int counter = 0; item.Name = String.Format("{0}://{1}", rootWebApplicationUri.Scheme, hostNameBase + "-" + counter.ToString() + "." + sslRoot); siteName = String.Format("{0}", hostNameBase + "-" + counter.ToString() + "." + sslRoot); while (DataProvider.CheckServiceItemExists(serviceId, item.Name, "WebsitePanel.Providers.SharePoint.SharePointEnterpriseSiteCollection, WebsitePanel.Providers.Base")) { counter++; item.Name = String.Format("{0}://{1}", rootWebApplicationUri.Scheme, hostNameBase + "-" + counter.ToString() + "." + sslRoot); siteName = String.Format("{0}", hostNameBase + "-" + counter.ToString() + "." + sslRoot); } } else { item.Name = String.Format("{0}://{1}", rootWebApplicationUri.Scheme, item.Name); } if (rootWebApplicationUri.Port > 0 && rootWebApplicationUri.Port != 80 && rootWebApplicationUri.Port != 443) { item.PhysicalAddress = String.Format("{0}:{1}", item.Name, rootWebApplicationUri.Port); } else { item.PhysicalAddress = item.Name; } if (Utils.ParseBool(hostedSharePointSettings["LocalHostFile"], false)) { item.RootWebApplicationInteralIpAddress = hostedSharePointSettings["RootWebApplicationInteralIpAddress"]; item.RootWebApplicationFQDN = item.Name.Replace(rootWebApplicationUri.Scheme + "://", ""); } item.MaxSiteStorage = RecalculateMaxSize(org.MaxSharePointEnterpriseStorage, (int)item.MaxSiteStorage); item.WarningStorage = item.MaxSiteStorage == -1 ? -1 : Math.Min((int)item.WarningStorage, item.MaxSiteStorage); // Check package item with given name already exists. if (PackageController.GetPackageItemByName(item.PackageId, item.Name, typeof(SharePointEnterpriseSiteCollection)) != null) { return(BusinessErrorCodes.ERROR_SHAREPOINT_PACKAGE_ITEM_EXISTS); } // Log operation. TaskManager.StartTask("HOSTED_SHAREPOINT_ENTERPRISE", "ADD_SITE_COLLECTION", item.Name); try { // Create site collection on server. HostedSharePointServerEnt hostedSharePointServer = GetHostedSharePointServer(serviceId); hostedSharePointServer.Enterprise_CreateSiteCollection(item); // Make record in metabase. item.ServiceId = serviceId; int itemId = PackageController.AddPackageItem(item); hostedSharePointServer.Enterprise_SetPeoplePickerOu(item.Name, org.DistinguishedName); int dnsServiceId = PackageController.GetPackageServiceId(item.PackageId, ResourceGroups.Dns); if (dnsServiceId > 0) { string[] tmpStr = siteName.Split('.'); string hostName = tmpStr[0]; string domainName = siteName.Substring(hostName.Length + 1, siteName.Length - (hostName.Length + 1)); List <GlobalDnsRecord> dnsRecords = ServerController.GetDnsRecordsByService(serviceId); List <DnsRecord> resourceRecords = DnsServerController.BuildDnsResourceRecords(dnsRecords, hostName, domainName, ""); DNSServer dns = new DNSServer(); ServiceProviderProxy.Init(dns, dnsServiceId); // add new resource records dns.AddZoneRecords(domainName, resourceRecords.ToArray()); } TaskManager.ItemId = itemId; return(itemId); } catch (Exception ex) { throw TaskManager.WriteError(ex); } finally { TaskManager.CompleteTask(); } }
private static int AddOrganizationDomain(int itemId, string domainName) { Log.WriteStart(string.Format("Importing domain {0}...", domainName)); // load organization Organization org = (Organization)PackageController.GetPackageItem(itemId); if (org == null) { return(-1); } // check package int packageCheck = SecurityContext.CheckPackage(org.PackageId, DemandPackage.IsActive); if (packageCheck < 0) { return(packageCheck); } DomainInfo domain = null; // check if the domain already exists int checkResult = ServerController.CheckDomain(domainName); if (checkResult == BusinessErrorCodes.ERROR_DOMAIN_ALREADY_EXISTS) { // domain exists // check if it belongs to the same space domain = ServerController.GetDomain(domainName); if (domain == null) { return(checkResult); } if (domain.PackageId != org.PackageId) { return(checkResult); } if (DataProvider.ExchangeOrganizationDomainExists(domain.DomainId)) { return(BusinessErrorCodes.ERROR_ORGANIZATION_DOMAIN_IS_IN_USE); } } else if (checkResult == BusinessErrorCodes.ERROR_RESTRICTED_DOMAIN) { return(checkResult); } // create domain if required if (domain == null) { domain = new DomainInfo(); domain.PackageId = org.PackageId; domain.DomainName = domainName; domain.IsPreviewDomain = false; domain.IsSubDomain = false; // add domain domain.DomainId = ServerController.AddDomain(domain); } // register domain DataProvider.AddExchangeOrganizationDomain(itemId, domain.DomainId, false); // register service item OrganizationDomain exchDomain = new OrganizationDomain(); exchDomain.Name = domainName; exchDomain.PackageId = org.PackageId; exchDomain.ServiceId = org.ServiceId; PackageController.AddPackageItem(exchDomain); Log.WriteEnd("Domain imported"); return(0); }
public static IntResult CreateOrganization(int packageId, string organizationId, string domain, string adminName, string adminEmail, string adminPassword) { IntResult result = new IntResult(); result.IsSuccess = true; try { // initialize task manager TaskManager.StartTask(TaskManagerSource, "CREATE_ORGANIZATION"); TaskManager.WriteParameter("packageId", packageId); TaskManager.WriteParameter("organizationId", organizationId); TaskManager.WriteParameter("domain", domain); TaskManager.WriteParameter("adminName", adminName); TaskManager.WriteParameter("adminEmail", adminEmail); TaskManager.WriteParameter("adminPassword", adminPassword); // get Exchange service ID int serviceId = PackageController.GetPackageServiceId(packageId, ResourceGroups.ExchangeHostedEdition); if (serviceId < 1) { return(Error <IntResult>(ExchangeServiceNotEnabledError)); } #region Check Space and Account // Check account int accountCheck = SecurityContext.CheckAccount(DemandAccount.NotDemo | DemandAccount.IsActive); if (accountCheck < 0) { return(Warning <IntResult>((-accountCheck).ToString())); } // Check space int packageCheck = SecurityContext.CheckPackage(packageId, DemandPackage.IsActive); if (packageCheck < 0) { return(Warning <IntResult>((-packageCheck).ToString())); } #endregion // get Exchange service ExchangeServerHostedEdition exchange = GetExchangeService(serviceId); // load service settings to know ProgramID, OfferID StringDictionary serviceSettings = ServerController.GetServiceSettings(serviceId); string programId = serviceSettings["programID"]; string offerId = serviceSettings["offerID"]; // check settings if (String.IsNullOrEmpty(programId)) { result.ErrorCodes.Add(ProgramIdIsNotSetError); } if (String.IsNullOrEmpty(offerId)) { result.ErrorCodes.Add(OfferIdIsNotSetError); } if (result.ErrorCodes.Count > 0) { result.IsSuccess = false; return(result); } #region Create organization int itemId = -1; ExchangeOrganization org = null; try { // create organization exchange.CreateOrganization(organizationId, programId, offerId, domain, adminName, adminEmail, adminPassword); // save item into meta-base org = new ExchangeOrganization(); org.Name = organizationId; org.PackageId = packageId; org.ServiceId = serviceId; itemId = PackageController.AddPackageItem(org); } catch (Exception ex) { // log error TaskManager.WriteError(ex); return(Error <IntResult>(CreateOrganizationError)); } #endregion #region Update organization quotas // update max org quotas UpdateOrganizationQuotas(org); // override quotas ResultObject quotasResult = ExchangeHostedEditionController.UpdateOrganizationQuotas(itemId, org.MaxMailboxCountQuota, org.MaxContactCountQuota, org.MaxDistributionListCountQuota); if (!quotasResult.IsSuccess) { return(Error <IntResult>(quotasResult, CreateOrganizationError)); } #endregion #region Add temporary domain // load settings PackageSettings settings = GetExchangePackageSettings(org); string tempDomainTemplate = settings[TempDomainSetting]; if (!String.IsNullOrEmpty(tempDomainTemplate)) { // add temp domain string tempDomain = String.Format("{0}.{1}", domain, tempDomainTemplate); AddOrganizationDomain(itemId, tempDomain); } #endregion result.Value = itemId; return(result); } catch (Exception ex) { // log error TaskManager.WriteError(ex); // exit with error code return(Error <IntResult>(GeneralError, ex.Message)); } finally { TaskManager.CompleteTask(); } }
public static int CreateOrganization(int packageId, string organizationId, string organizationName) { int itemId; int errorCode; // place log record Log.WriteStart(string.Format("Importing organization {0}...", organizationName)); if (!CheckQuotas(packageId, out errorCode)) { return(errorCode); } string addressListsContainer = null; if (Global.IsExchange) { try { addressListsContainer = ADUtils.GetAddressListsContainer(); } catch (Exception ex) { Log.WriteError("Cannot load Exchange 2007 Address Lists Container", ex); return(EXCHANGE_CONTAINER_ERROR); } } Organization org = PopulateOrganization(packageId, organizationId, addressListsContainer); // Check if organization exitsts. if (OrganizationIdentifierExists(organizationId)) { return(BusinessErrorCodes.ERROR_ORG_ID_EXISTS); } int serviceId = PackageController.GetPackageServiceId(packageId, ResourceGroups.HostedOrganizations); //create temprory domain name; string domainName = CreateTemporyDomainName(serviceId, organizationId); Log.WriteInfo(string.Format("Importing temp domain {0}", domainName)); if (string.IsNullOrEmpty(domainName)) { return(BusinessErrorCodes.ERROR_ORGANIZATION_TEMP_DOMAIN_IS_NOT_SPECIFIED); } bool domainCreated; int domainId = CreateDomain(domainName, packageId, out domainCreated); //create domain if (domainId < 0) { return(domainId); } //add organization to package items itemId = AddOrganizationToPackageItems(org, serviceId, packageId, organizationName, organizationId, domainName); // register org ID DataProvider.AddExchangeOrganization(itemId, organizationId); // register domain DataProvider.AddExchangeOrganizationDomain(itemId, domainId, true); // register organization domain service item OrganizationDomain orgDomain = new OrganizationDomain(); orgDomain.Name = domainName; orgDomain.PackageId = packageId; orgDomain.ServiceId = serviceId; PackageController.AddPackageItem(orgDomain); Log.WriteEnd("Organization imported"); return(itemId); }
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); // 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 AddFtpAccount(FtpAccount 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.FTP_ACCOUNTS); if (quota.QuotaExhausted) { return(BusinessErrorCodes.ERROR_FTP_RESOURCE_QUOTA_LIMIT); } // check if FTP account already exists int serviceId = PackageController.GetPackageServiceId(item.PackageId, ResourceGroups.Ftp); if (serviceId == 0) { return(BusinessErrorCodes.ERROR_FTP_RESOURCE_UNAVAILABLE); } // place log record TaskManager.StartTask("FTP_ACCOUNT", "ADD", item.Name); TaskManager.WriteParameter("Folder", item.Folder); TaskManager.WriteParameter("CanRead", item.CanRead); TaskManager.WriteParameter("CanWrite", item.CanWrite); try { // check package items if (PackageController.GetPackageItemByName(item.PackageId, item.Name, typeof(FtpAccount)) != null) { return(BusinessErrorCodes.ERROR_FTP_PACKAGE_ITEM_EXISTS); } // check service items FTPServer ftp = new FTPServer(); ServiceProviderProxy.Init(ftp, serviceId); if (ftp.AccountExists(item.Name)) { return(BusinessErrorCodes.ERROR_FTP_SERVICE_ITEM_EXISTS); } // store original path string origFolder = item.Folder; // convert folder StringDictionary ftpSettings = ServerController.GetServiceSettings(serviceId); if (Utils.ParseBool(ftpSettings["BuildUncFilesPath"], false)) { // UNC // get OS service int osServiceId = PackageController.GetPackageServiceId(item.PackageId, ResourceGroups.Os); item.Folder = FilesController.GetFullUncPackagePath(item.PackageId, osServiceId, item.Folder); } else { // Absolute item.Folder = FilesController.GetFullPackagePath(item.PackageId, item.Folder); } item.Enabled = true; // add service item ftp.CreateAccount(item); // save item item.Password = CryptoUtils.Encrypt(item.Password); item.ServiceId = serviceId; item.Folder = (origFolder == "") ? "\\" : origFolder; int itemId = PackageController.AddPackageItem(item); TaskManager.ItemId = itemId; return(itemId); } catch (Exception ex) { TaskManager.WriteError(ex); throw; } finally { TaskManager.CompleteTask(); } }
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 = "WebsitePanel 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 AddSqlDatabase(SqlDatabase item, string groupName) { // 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, groupName + ".Databases"); if (quota.QuotaExhausted) { return(BusinessErrorCodes.ERROR_MSSQL_DATABASES_RESOURCE_QUOTA_LIMIT); } // check if mail resource is available int serviceId = PackageController.GetPackageServiceId(item.PackageId, groupName); if (serviceId == 0) { return(BusinessErrorCodes.ERROR_MSSQL_RESOURCE_UNAVAILABLE); } // check package items if (PackageController.GetPackageItemByName(item.PackageId, groupName, item.Name, typeof(SqlDatabase)) != null) { return(BusinessErrorCodes.ERROR_MSSQL_DATABASES_PACKAGE_ITEM_EXISTS); } // place log record TaskManager.StartTask("SQL_DATABASE", "ADD", item.Name); TaskManager.WriteParameter("Provider", groupName); int itemId = default(int); // try { // check service items DatabaseServer sql = GetDatabaseServer(serviceId); if (sql.DatabaseExists(item.Name)) { return(BusinessErrorCodes.ERROR_MSSQL_DATABASES_SERVICE_ITEM_EXISTS); } // calculate database location StringDictionary settings = ServerController.GetServiceSettings(serviceId); UserInfo user = PackageController.GetPackageOwner(item.PackageId); if (settings["UseDefaultDatabaseLocation"] != null && !Utils.ParseBool(settings["UseDefaultDatabaseLocation"], false)) { item.Location = Utils.ReplaceStringVariable(settings["DatabaseLocation"], "user_name", user.Username); } // set database size item.DataSize = GetMaxDatabaseSize(item.PackageId, groupName); // set log size item.LogSize = GetMaxLogSize(item.PackageId, groupName); // add service item sql.CreateDatabase(item); // save item item.ServiceId = serviceId; itemId = PackageController.AddPackageItem(item); TaskManager.ItemId = itemId; } catch (Exception ex) { TaskManager.WriteError(ex); // if (ex.Message.Contains("INVALID_DATABASE_NAME")) { return(BusinessErrorCodes.ERROR_MYSQL_INVALID_DATABASE_NAME); } // Return a generic error instead of default(int) itemId = BusinessErrorCodes.FAILED_EXECUTE_SERVICE_OPERATION; } finally { TaskManager.CompleteTask(); } return(itemId); }
/// <summary> /// Adds SharePoint site collection. /// </summary> /// <param name="item">Site collection description.</param> /// <returns>Created site collection id within metabase.</returns> public static int AddSiteCollection(SharePointSiteCollection item) { string domainName = item.Name; // 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. OrganizationStatistics orgStats = OrganizationController.GetOrganizationStatistics(item.OrganizationId); //QuotaValueInfo quota = PackageController.GetPackageQuota(item.PackageId, Quotas.HOSTED_SHAREPOINT_SITES); if (orgStats.AllocatedSharePointSiteCollections > -1 && orgStats.CreatedSharePointSiteCollections >= orgStats.AllocatedSharePointSiteCollections) { return(BusinessErrorCodes.ERROR_SHAREPOINT_RESOURCE_QUOTA_LIMIT); } // Check if stats resource is available int serviceId = PackageController.GetPackageServiceId(item.PackageId, ResourceGroups.HostedSharePoint); if (serviceId == 0) { return(BusinessErrorCodes.ERROR_SHAREPOINT_RESOURCE_UNAVAILABLE); } StringDictionary hostedSharePointSettings = ServerController.GetServiceSettings(serviceId); Uri rootWebApplicationUri = new Uri(hostedSharePointSettings["RootWebApplicationUri"]); item.Name = String.Format("{0}://{1}", rootWebApplicationUri.Scheme, item.Name); if (rootWebApplicationUri.Port > 0 && rootWebApplicationUri.Port != 80 && rootWebApplicationUri.Port != 443) { item.PhysicalAddress = String.Format("{0}:{1}", item.Name, rootWebApplicationUri.Port); } else { item.PhysicalAddress = item.Name; } Organization org = OrganizationController.GetOrganization(item.OrganizationId); item.MaxSiteStorage = RecalculateMaxSize(org.MaxSharePointStorage, (int)item.MaxSiteStorage); item.WarningStorage = item.MaxSiteStorage == -1 ? -1 : Math.Min((int)item.WarningStorage, item.MaxSiteStorage); // Check package item with given name already exists. if (PackageController.GetPackageItemByName(item.PackageId, item.Name, typeof(SharePointSiteCollection)) != null) { return(BusinessErrorCodes.ERROR_SHAREPOINT_PACKAGE_ITEM_EXISTS); } // Log operation. TaskManager.StartTask("HOSTEDSHAREPOINT", "ADD_SITE_COLLECTION", item.Name); try { // Create site collection on server. HostedSharePointServer hostedSharePointServer = GetHostedSharePointServer(serviceId); hostedSharePointServer.CreateSiteCollection(item); // Make record in metabase. item.ServiceId = serviceId; int itemId = PackageController.AddPackageItem(item); int dnsServiceId = PackageController.GetPackageServiceId(item.PackageId, ResourceGroups.Dns); if (dnsServiceId > 0) { DomainInfo domain = ServerController.GetDomain(domainName); if (domain != null) { string website = domain.WebSiteName; if (!String.IsNullOrEmpty(domain.WebSiteName)) { DnsRecord[] records = ServerController.GetDnsZoneRecords(domain.DomainId); foreach (DnsRecord record in records) { if (record.RecordType.Equals(DnsRecordType.A) && String.IsNullOrEmpty(record.RecordName)) { ServerController.DeleteDnsZoneRecord(domain.DomainId, String.Empty, DnsRecordType.A, record.RecordData); break; } } } ServerController.AddDnsZoneRecord(domain.DomainId, String.Empty, DnsRecordType.A, hostedSharePointSettings["RootWebApplicationIpAddress"], 0); } } TaskManager.ItemId = itemId; return(itemId); } catch (Exception ex) { throw TaskManager.WriteError(ex); } finally { TaskManager.CompleteTask(); } }
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 static int AddSqlUser(SqlUser item, string groupName) { // 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, groupName + ".Users"); if (quota.QuotaExhausted) { return(BusinessErrorCodes.ERROR_MSSQL_USERS_RESOURCE_QUOTA_LIMIT); } // check if mail resource is available int serviceId = PackageController.GetPackageServiceId(item.PackageId, groupName); if (serviceId == 0) { return(BusinessErrorCodes.ERROR_MSSQL_RESOURCE_UNAVAILABLE); } // check package items if (PackageController.GetPackageItemByName(item.PackageId, groupName, item.Name, typeof(SqlUser)) != null) { return(BusinessErrorCodes.ERROR_MSSQL_USERS_PACKAGE_ITEM_EXISTS); } // place log record TaskManager.StartTask("SQL_USER", "ADD", item.Name); TaskManager.WriteParameter("Provider", groupName); int itemId = default(int); try { // check service items DatabaseServer sql = GetDatabaseServer(serviceId); if (sql.UserExists(item.Name)) { return(BusinessErrorCodes.ERROR_MSSQL_USERS_SERVICE_ITEM_EXISTS); } // add service item sql.CreateUser(item, item.Password); // save item item.Password = CryptoUtils.Encrypt(item.Password); item.ServiceId = serviceId; itemId = PackageController.AddPackageItem(item); TaskManager.ItemId = itemId; } catch (Exception ex) { TaskManager.WriteError(ex); // if (ex.Message.Contains("INVALID_USERNAME")) { return(BusinessErrorCodes.ERROR_MYSQL_INVALID_USER_NAME); } // Return a generic error instead of default(int) itemId = BusinessErrorCodes.FAILED_EXECUTE_SERVICE_OPERATION; } finally { TaskManager.CompleteTask(); } return(itemId); }
public static int AddOdbcSource(SystemDSN 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.OS_ODBC); if (quota.QuotaExhausted) { return(BusinessErrorCodes.ERROR_OS_DSN_RESOURCE_QUOTA_LIMIT); } // check if mail resource is available int serviceId = PackageController.GetPackageServiceId(item.PackageId, ResourceGroups.Os); if (serviceId == 0) { return(BusinessErrorCodes.ERROR_OS_RESOURCE_UNAVAILABLE); } // check package items if (PackageController.GetPackageItemByName(item.PackageId, item.Name, typeof(SystemDSN)) != null) { return(BusinessErrorCodes.ERROR_OS_DSN_PACKAGE_ITEM_EXISTS); } // place log record TaskManager.StartTask("ODBC_DSN", "ADD", item.Name); try { // check service items OS.OperatingSystem os = GetOS(serviceId); if (os.GetDSN(item.Name) != null) { return(BusinessErrorCodes.ERROR_OS_DSN_SERVICE_ITEM_EXISTS); } string[] dbNameParts = item.DatabaseName.Split('|'); string groupName = null; if (dbNameParts.Length > 1) { item.DatabaseName = dbNameParts[0]; groupName = dbNameParts[1]; } // get database server address item.DatabaseServer = GetDatabaseServerName(groupName, item.PackageId); if (item.Driver == "MsAccess" || item.Driver == "Excel" || item.Driver == "Text") { item.DatabaseName = FilesController.GetFullPackagePath(item.PackageId, item.DatabaseName); } // add service item os.CreateDSN(item); // save item item.DatabasePassword = CryptoUtils.Encrypt(item.DatabasePassword); 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 AddSite(StatsSite 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.STATS_SITES); if (quota.QuotaExhausted) { return(BusinessErrorCodes.ERROR_STATS_RESOURCE_QUOTA_LIMIT); } // check if stats resource is available int serviceId = PackageController.GetPackageServiceId(item.PackageId, ResourceGroups.Statistics); if (serviceId == 0) { return(BusinessErrorCodes.ERROR_STATS_RESOURCE_UNAVAILABLE); } // check package items if (PackageController.GetPackageItemByName(item.PackageId, item.Name, typeof(StatsSite)) != null) { return(BusinessErrorCodes.ERROR_STATS_PACKAGE_ITEM_EXISTS); } // place log record TaskManager.StartTask("STATS_SITE", "ADD", item.Name); 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); List <DomainInfo> pointers = WebServerController.GetWebSitePointers(siteItem.Id); List <string> aliases = new List <string>(); foreach (DomainInfo pointer in pointers) { aliases.Add(pointer.DomainName); } StatisticsServer stats = new StatisticsServer(); ServiceProviderProxy.Init(stats, serviceId); string siteNumber = (site.IIs7) ? site[WebSite.IIS7_SITE_ID] : siteItem.SiteId.Replace("/", ""); string logsCommonFolder = site.LogsPath; string logsFolder = Path.Combine(logsCommonFolder, siteNumber); // get service settings StringDictionary settings = ServerController.GetServiceSettings(serviceId); if (Utils.ParseBool(settings["BuildUncLogsPath"], false)) { logsFolder = FilesController.ConvertToUncPath(siteItem.ServiceId, logsFolder); } item.LogDirectory = logsFolder; item.DomainAliases = aliases.ToArray(); // install statistics item.SiteId = stats.AddSite(item); // save statistics 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 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 static int AddSharePointUser(SystemUser 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_USERS); if (quota.QuotaExhausted) { return(BusinessErrorCodes.ERROR_SHAREPOINT_USERS_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(SystemUser)) != null) { return(BusinessErrorCodes.ERROR_SHAREPOINT_USERS_PACKAGE_ITEM_EXISTS); } // place log record TaskManager.StartTask("SHAREPOINT", "ADD_USER", item.Name); try { // check service items SharePointServer sps = GetSharePoint(serviceId); if (sps.UserExists(item.Name)) { return(BusinessErrorCodes.ERROR_SHAREPOINT_USERS_SERVICE_ITEM_EXISTS); } // create service item item.FullName = item.Name; item.Description = "SolidCP System Account"; item.AccountDisabled = false; item.PasswordCantChange = true; item.PasswordNeverExpires = true; // add service item sps.CreateUser(item); // save item item.Password = CryptoUtils.Encrypt(item.Password); item.ServiceId = serviceId; int itemId = PackageController.AddPackageItem(item); TaskManager.ItemId = itemId; return(itemId); } catch (Exception ex) { throw TaskManager.WriteError(ex); } finally { TaskManager.CompleteTask(); } }