C# ResultObject.AddError方法代码示例

		public static ResultObject GrantWebDeployPublishingAccess(int siteItemId, string accountName, string accountPassword)
		{
			ResultObject result = new ResultObject { IsSuccess = true };

			try
			{
				TaskManager.StartTask(LOG_SOURCE_WEB, "GrantWeDeployPublishingAccess");
				TaskManager.WriteParameter("SiteItemId", siteItemId);

				// load site item
				var item = (WebSite)PackageController.GetPackageItem(siteItemId);

				//
				if (item == null)
				{
					TaskManager.WriteError("Web site not found");
					//
					result.AddError("WEBSITE_NOT_FOUND", null);
					result.IsSuccess = false;
					return result;
				}

				//
				int accountCheck = SecurityContext.CheckAccount(DemandAccount.NotDemo | DemandAccount.IsActive);
				if (accountCheck < 0)
				{
					TaskManager.WriteWarning("Current user is either demo or inactive");
					//
					result.AddError("DEMO_USER", null);
					result.IsSuccess = false;
					return result;
				}

				// check package
				int packageCheck = SecurityContext.CheckPackage(item.PackageId, DemandPackage.IsActive);
				if (packageCheck < 0)
				{
					TaskManager.WriteWarning("Current user is either not allowed to access the package or the package inactive");
					//
					result.AddError("NOT_ALLOWED", null);
					result.IsSuccess = false;
					return result;
				}

				//
				WebServer server = GetWebServer(item.ServiceId);

				// Most part of the functionality used to enable Web Deploy publishing correspond to those created for Web Management purposes,
				// so we can re-use the existing functionality to deliver seamless development experience.
				if (server.CheckWebManagementAccountExists(accountName))
				{
					TaskManager.WriteWarning("Account name specified already exists");
					//
					result.AddError("ACCOUNTNAME_PROHIBITED", null);
					result.IsSuccess = false;
					return result;
				}

				// Most part of the functionality used to enable Web Deploy publishing correspond to those created for Web Management purposes,
				// so we can re-use the existing functionality to deliver seamless development experience.
				ResultObject passwResult = server.CheckWebManagementPasswordComplexity(accountPassword);
				if (!passwResult.IsSuccess)
				{
					TaskManager.WriteWarning("Account password does not meet complexity requirements");
					//
					result.ErrorCodes.AddRange(passwResult.ErrorCodes);
					result.IsSuccess = false;
					//
					return result;
				}

				// Execute a call to remote server to enable Web Deploy publishing access for the specified user account
				server.GrantWebDeployPublishingAccess(item.SiteId, accountName, accountPassword);
				// Enable Web Deploy flag for the web site
				item.WebDeploySitePublishingEnabled = true;
				// Remember Web Deploy publishing account
				item.WebDeployPublishingAccount = accountName;
				// Remember Web Deploy publishing password
				item.WebDeployPublishingPassword = CryptoUtils.Encrypt(accountPassword);
				// Put changes in effect
				PackageController.UpdatePackageItem(item);
			}
			catch (Exception ex)
			{
				TaskManager.WriteError(ex);
				//
				result.IsSuccess = false;
			}
			finally
			{
				TaskManager.CompleteTask();
			}
			//
			return result;
		}

		public static ResultObject ChangeWebDeployPublishingPassword(int siteItemId, string newAccountPassword)
		{
			ResultObject result = new ResultObject { IsSuccess = true };
			try
			{
				TaskManager.StartTask(LOG_SOURCE_WEB, "ChangeWebDeployPublishingPassword");
				TaskManager.WriteParameter("SiteItemId", siteItemId);

				//
				var item = (WebSite)PackageController.GetPackageItem(siteItemId);

				//
				if (item == null)
				{
					TaskManager.WriteWarning("Web site not found");

					//
					result.AddError("WEBSITE_NOT_FOUND", null);
					result.IsSuccess = false;

					return result;
				}

				//
				int accountCheck = SecurityContext.CheckAccount(DemandAccount.NotDemo | DemandAccount.IsActive);
				if (accountCheck < 0)
				{
					TaskManager.WriteWarning("Current user is either demo or inactive");

					result.AddError("DEMO_USER", null);
					result.IsSuccess = false;

					return result;
				}

				// check package
				int packageCheck = SecurityContext.CheckPackage(item.PackageId, DemandPackage.IsActive);
				if (packageCheck < 0)
				{
					TaskManager.WriteWarning("Current user is either not allowed to access the package or the package inactive");

					//
					result.AddError("NOT_ALLOWED", null);
					result.IsSuccess = false;

					return result;
				}

				// Revoke access first
				RevokeWebDeployPublishingAccess(siteItemId);
				//
				result = GrantWebDeployPublishingAccess(siteItemId, item.WebDeployPublishingAccount, newAccountPassword);
			}
			catch (Exception ex)
			{
				TaskManager.WriteError(ex);
			}
			finally
			{
				TaskManager.CompleteTask();
			}
			//
			return result;
		}

		public new ResultObject CheckWebManagementPasswordComplexity(string accountPassword)
		{
			// Preserve setting to restore it back
			bool adEnabled = ServerSettings.ADEnabled;
			// !!! Bypass AD for WMSVC as it requires full-qualified username to authenticate user
			// against the web server
			ServerSettings.ADEnabled = false;
			
			//
			ResultObject result = new ResultObject { IsSuccess = true };

			//
			if (IdentityCredentialsMode == "IISMNGR")
			{
				InvalidPasswordReason reason = ManagementAuthentication.IsPasswordStrongEnough(accountPassword);
				//
				if (reason != InvalidPasswordReason.NoError)
				{
					result.IsSuccess = false;
					result.AddError(reason.ToString(), new Exception("Password complexity check failed"));
				}
			}
			// Restore setting back
			ServerSettings.ADEnabled = adEnabled;

			//
			return result;
		}

		public static ResultObject SaveWebDeployPublishingProfile(int siteItemId, int[] serviceItemIds)
		{
			ResultObject result = new ResultObject { IsSuccess = true };

			try
			{
				TaskManager.StartTask(LOG_SOURCE_WEB, "SaveWebDeployPublishingProfile");
				TaskManager.WriteParameter("SiteItemId", siteItemId);

				// load site item
				var item = (WebSite)PackageController.GetPackageItem(siteItemId);

				//
				if (item == null)
				{
					TaskManager.WriteError("Web site not found");
					//
					result.AddError("WEBSITE_NOT_FOUND", null);
					result.IsSuccess = false;
					return result;
				}

				//
				int accountCheck = SecurityContext.CheckAccount(DemandAccount.NotDemo | DemandAccount.IsActive);
				if (accountCheck < 0)
				{
					TaskManager.WriteWarning("Current user is either demo or inactive");
					//
					result.AddError("DEMO_USER", null);
					result.IsSuccess = false;
					return result;
				}

				// check package
				int packageCheck = SecurityContext.CheckPackage(item.PackageId, DemandPackage.IsActive);
				if (packageCheck < 0)
				{
					TaskManager.WriteWarning("Current user is either not allowed to access the package or the package inactive");
					//
					result.AddError("NOT_ALLOWED", null);
					result.IsSuccess = false;
					return result;
				}

				// Ensure all service items specified are within the same hosting space
				// This is a logcally correct and secure statement than the other one
				// TO-DO: Uncomment this line before demo!
				//var profileIntegritySucceeded = false;

				var profileIntegritySucceeded = true;
				//
				foreach (int itemId in serviceItemIds)
				{
					try
					{
						//
						PackageController.GetPackageItem(itemId);
						//
						profileIntegritySucceeded = true;
					}
					catch (Exception ex)
					{
						TaskManager.WriteError(ex);
						//
						profileIntegritySucceeded = false;
						// Exit from the loop
						break;
					}
				}

				//
				if (profileIntegritySucceeded == true)
				{
					// Build service items list
					item.WebDeploySitePublishingProfile = String.Join(",", Array.ConvertAll<int, string>(serviceItemIds, (int x) => { return x.ToString(); }));
					// Put changes in effect
					PackageController.UpdatePackageItem(item);
				}
			}
			catch (Exception ex)
			{
				TaskManager.WriteError(ex);
				//
				result.IsSuccess = false;
			}
			finally
			{
				TaskManager.CompleteTask();
			}
			//
			return result;
		}

 public static ResultObject UnsetReplicaServer(int serviceId, string remoteServer)
 {
     ResultObject result = new ResultObject();
     try
     {
         VirtualizationServer2012 vs = GetVirtualizationProxy(serviceId);
         vs.UnsetReplicaServer(remoteServer);
         result.IsSuccess = true;
     }
     catch (Exception ex)
     {
         result.AddError(VirtualizationErrorCodes.UNSET_REPLICA_SERVER_ERROR, ex);
     }
     return result;
 }

        public static ResultObject ResumeReplication(int itemId)
        {
            ResultObject result = new ResultObject();
            try
            {
                VirtualMachine vm = GetVirtualMachineByItemId(itemId);

                // Check Quotas
                ReplicationHelper.CheckReplicationQuota(vm.PackageId, ref result);
                if (result.ErrorCodes.Count > 0) return result;

                VirtualizationServer2012 vs = GetVirtualizationProxy(vm.ServiceId);
                vs.ResumeReplication(vm.VirtualMachineId);

                result.IsSuccess = true;
            }
            catch (Exception ex)
            {
                result.AddError(VirtualizationErrorCodes.RESUME_REPLICATION_ERROR, ex);
            }
            return result; 
        }

		public static ResultObject DeleteCertificateRequest(int siteId, int csrID)
		{
			ResultObject result = new ResultObject { IsSuccess = true };

			try
			{
				WebSite item = GetWebSite(siteId);
				PackageInfo service = PackageController.GetPackage(item.PackageId);

				DataProvider.DeleteCertificate(SecurityContext.User.UserId, service.PackageId, csrID);
			}
			catch (Exception ex)
			{

				result.IsSuccess = false;
				result.AddError("610", ex);
			}
			return result;
		}

        public static void CreateVMFromVMAsunc(int packageId, VMInfo vmTemplate, string vmName)
        {
            ResultObject res = new ResultObject();

            Guid taksId = Guid.NewGuid();

            res = TaskManager.StartResultTask<ResultObject>("VPSForPC", "CREATE", taksId);
            TaskManager.ItemName = vmName;
            TaskManager.PackageId = packageId;

            string templateName = vmTemplate.Name;

            vmTemplate.Id = 0;
            vmTemplate.Name = vmName;
            vmTemplate.CurrentTaskId = taksId.ToString("N"); // generate creation task id
            vmTemplate.ProvisioningStatus = VirtualMachineProvisioningStatus.InProgress;

            try
            {
                vmTemplate.Id = PackageController.AddPackageItem(vmTemplate);
            }
            catch (Exception ex)
            {
                res.AddError(VirtualizationErrorCodes.CREATE_META_ITEM_ERROR, ex);
                TaskManager.CompleteResultTask(res);
                throw;
            }

            TaskManager.ItemId = vmTemplate.Id;

            try
            {
                var vs = GetVirtualizationProxy(vmTemplate.ServiceId);
                vmTemplate = vs.CreateVMFromVM(templateName, vmTemplate, taksId);
                PackageController.UpdatePackageItem(vmTemplate);

//                    CreateAsyncVMfromVM.Run(templateName, vmTemplate);
            }
            catch (Exception ex)
            {
                // delete meta item
                PackageController.DeletePackageItem(vmTemplate.Id);

                // return from method
                res.AddError(VirtualizationErrorCodes.CREATE_TASK_START_ERROR, ex);
                TaskManager.CompleteResultTask(res);
                throw;
            }

            if (!String.IsNullOrEmpty(vmTemplate.exMessage))
            {
                TaskManager.CompleteResultTask(res
                            , VirtualizationErrorCodes.CREATE_ERROR
                            , new Exception(vmTemplate.exMessage)
                            , vmTemplate.logMessage);
            }
            else
            {
                TaskManager.CompleteResultTask(res, null, null, vmTemplate.logMessage);
            }
        }

		public static ResultObject InstallPfx(byte[] pfx, int siteItemId, string password)
		{
			ResultObject result = new ResultObject { IsSuccess = true };
			try
			{
				TaskManager.StartTask(LOG_SOURCE_WEB, "installPFX");
				TaskManager.WriteParameter("SiteItemId", siteItemId);

				WebSite item = GetWebSite(siteItemId) as WebSite;
				PackageInfo service = PackageController.GetPackage(item.PackageId);

				TaskManager.WriteParameter("WebSite.Name", item.Name);
				WebServer server = GetWebServer(item.ServiceId);
				TaskManager.WriteParameter("item.ServiceId", item.ServiceId);

                // remove all web site pointers
                List<DomainInfo> pointers = GetWebSitePointers(siteItemId);
                foreach (DomainInfo pointer in pointers)
                    DeleteWebSitePointer(siteItemId, pointer.DomainId, true, true, true);

				SSLCertificate certificate = server.installPFX(pfx, password, item);
				if (certificate.SerialNumber == null)
				{
					result.AddError("Error_Installing_certificate", null);
					result.IsSuccess = false;
				}
				DataProvider.AddPFX(SecurityContext.User.UserId, item.PackageId, item.Id, service.UserId, certificate.Hostname,
				   certificate.FriendlyName, certificate.DistinguishedName, certificate.CSRLength, certificate.SerialNumber,
				   certificate.ValidFrom, certificate.ExpiryDate);


			}
			catch (Exception ex)
			{
				result.IsSuccess = false;
				result.AddError("Error_Installing_certificate", ex);
				TaskManager.WriteError(ex);
			}
			finally
			{
				TaskManager.CompleteTask();
			}
			return result;
		}

		public static ResultObject CheckCertificate(int siteId)
		{
			ResultObject result = new ResultObject { IsSuccess = false };
			bool serverResult = false;

			try
			{
				WebSite item = GetWebSite(siteId) as WebSite;
				WebServer server = GetWebServer(item.ServiceId);
				serverResult = server.CheckCertificate(item);
				if (serverResult && !DataProvider.CheckSSLExistsForWebsite(siteId))
				{
					result.IsSuccess = true;
				}
			}
			catch (Exception ex)
			{

				result.IsSuccess = false;
				result.AddError("610", ex);
			}
			return result;
		}

		public static ResultObject InstallCertificate(SSLCertificate certificate, int siteItemId)
		{
			ResultObject result = new ResultObject { IsSuccess = true };
			try
			{
				TaskManager.StartTask(LOG_SOURCE_WEB, "installCertificate");
				TaskManager.WriteParameter("SiteItemId", siteItemId);
				TaskManager.WriteParameter("Hostname", certificate.Hostname);


				WebSite item = GetWebSite(siteItemId) as WebSite;
				TaskManager.WriteParameter("WebSite.Name", item.Name);
				WebServer server = GetWebServer(item.ServiceId);
				TaskManager.WriteParameter("item.ServiceId", item.ServiceId);

                IPAddressInfo ip = ServerController.GetIPAddress(item.SiteIPAddressId);

                if (ip != null)
                    //item.SiteIPAddress = !String.IsNullOrEmpty(ip.InternalIP) ? ip.InternalIP : ip.ExternalIP;
                    item.SiteIPAddress = ip.ExternalIP;

				certificate = server.installCertificate(certificate, item);
				if (certificate.SerialNumber == null)
				{
					result.AddError("Error_Installing_certificate", null);
					result.IsSuccess = false;
				}


				DataProvider.CompleteSSLRequest(SecurityContext.User.UserId, item.PackageId,
												certificate.id, certificate.Certificate,
												certificate.DistinguishedName, certificate.SerialNumber,
												certificate.Hash, certificate.ValidFrom, certificate.ExpiryDate);
				if (certificate.IsRenewal)
				{
					DataProvider.DeleteCertificate(SecurityContext.User.UserId, item.PackageId, certificate.PreviousId);
				}

			}
			catch (Exception ex)
			{
				result.AddError("0", ex);
				TaskManager.WriteError(ex);
			}
			finally
			{
				TaskManager.CompleteTask();
			}
			return result;
		}

        public new ResultObject DeleteCertificate(SSLCertificate certificate, WebSite website)
        {
            // This method removes all https bindings and all certificates associated with them.
            // Old implementation (IIS70) removed a single binding (there could not be more than one) and the first certificate that matched via serial number
            var result = new ResultObject { IsSuccess = true };

            if (certificate == null)
            {
                return result;
            }

            try
            {
                var certificatesAndStoreNames = new List<Tuple<string, byte[]>>();

                // User servermanager to get aLL SSL-bindings on this website and try to remove the certificates used
                using (var srvman = GetServerManager())
                {

                    var site = srvman.Sites[website.Name];
                    var bindings = site.Bindings.Where(b => b.Protocol == "https");

                    foreach (Binding binding in bindings.ToList())
                    {
                        if (binding.SslFlags.HasFlag(SslFlags.CentralCertStore))
                        {
                            if (!string.IsNullOrWhiteSpace(CCSUncPath) && Directory.Exists(CCSUncPath))
                            {
                                // This is where it will be if CCS is used
                                var path = GetCCSPath(certificate.Hostname);
                                if (File.Exists(path))
                                {
                                    File.Delete(path);
                                }

                                // If binding with hostname, also try to delete with the hostname in the binding
                                // This is because if SNI is used, several bindings are created for every valid name in the cerificate, but only one name exists in the SSLCertificate
                                if (!string.IsNullOrEmpty(binding.Host))
                                {
                                    path = GetCCSPath(binding.Host);
                                    if (File.Exists(path))
                                    {
                                        File.Delete(path);
                                    }
                                }
                            }
                        }
                        else
                        {
                            var certificateAndStoreName = new Tuple<string, byte[]>(binding.CertificateStoreName, binding.CertificateHash);

                            if (!string.IsNullOrEmpty(binding.CertificateStoreName) && !certificatesAndStoreNames.Contains(certificateAndStoreName))
                            {
                                certificatesAndStoreNames.Add(certificateAndStoreName);
                            }
                        }

                        // Remove binding from site
                        site.Bindings.Remove(binding);
                    }

                    srvman.CommitChanges();

                    foreach (var certificateAndStoreName in certificatesAndStoreNames)
                    {
                        // Delete all certs with the same serialnumber in Store
                        var store = new X509Store(certificateAndStoreName.Item1, StoreLocation.LocalMachine);
                        store.Open(OpenFlags.MaxAllowed);

                        var certs = store.Certificates.Find(X509FindType.FindByThumbprint, BitConverter.ToString(certificateAndStoreName.Item2).Replace("-", ""), false);
                        foreach (var cert in certs)
                        {
                            store.Remove(cert);
                        }

                        store.Close();
                    }
                }
            }
            catch (Exception ex)
            {
                Log.WriteError(String.Format("Unable to delete certificate for website {0}", website.Name), ex);
                result.IsSuccess = false;
                result.AddError("", ex);
            }

            return result;
        }

		public ResultObject DeleteCertificate(SSLCertificate certificate, WebSite website)
		{
			ResultObject result = new ResultObject();

			try
			{
				X509Store store = new X509Store(StoreName.My, StoreLocation.LocalMachine);

				store.Open(OpenFlags.MaxAllowed);

				X509Certificate2 cert =
					store.Certificates.Find(X509FindType.FindBySerialNumber, certificate.SerialNumber, false)[0];
				store.Remove(cert);

				store.Close();
				RemoveBinding(certificate, website);

				result.IsSuccess = true;
			}
			catch (Exception ex)
			{
				result.IsSuccess = false;
				result.AddError("", ex);
			}
			return result;
		}

		public static ResultObject GrantWebManagementAccess(int siteItemId, string accountName, string accountPassword)
		{
			ResultObject result = new ResultObject { IsSuccess = true };

			try
			{
				TaskManager.StartTask(LOG_SOURCE_WEB, "GrantWebManagementAccess");
				TaskManager.WriteParameter("SiteItemId", siteItemId);
				
				//
				WebSite item = GetWebSite(siteItemId);
				
				//
				if (item == null)
				{
					TaskManager.WriteError("Web site not found");
					//
					result.AddError("WEBSITE_NOT_FOUND", null);
					result.IsSuccess = false;
					return result;
				}

				//
				int accountCheck = SecurityContext.CheckAccount(DemandAccount.NotDemo | DemandAccount.IsActive);
				if (accountCheck < 0)
				{
					TaskManager.WriteWarning("Current user is either demo or inactive");
					//
					result.AddError("DEMO_USER", null);
					result.IsSuccess = false;
					return result;
				}

				// check package
				int packageCheck = SecurityContext.CheckPackage(item.PackageId, DemandPackage.IsActive);
				if (packageCheck < 0)
				{
					TaskManager.WriteWarning("Current user is either not allowed to access the package or the package inactive");
					//
					result.AddError("NOT_ALLOWED", null);
					result.IsSuccess = false;
					return result;
				}
				
				//
				WebServer server = GetWebServer(item.ServiceId);

				//
				if (server.CheckWebManagementAccountExists(accountName))
				{
					TaskManager.WriteWarning("Account name specified already exists");
					//
					result.AddError("ACCOUNTNAME_PROHIBITED", null);
					result.IsSuccess = false;
					return result;
				}

				//
				ResultObject passwResult = server.CheckWebManagementPasswordComplexity(accountPassword);
				if (!passwResult.IsSuccess)
				{
					TaskManager.WriteWarning("Account password does not meet complexity requirements");
					//
					result.ErrorCodes.AddRange(passwResult.ErrorCodes);
					result.IsSuccess = false;
					//
					return result;
				}
				
				//
				server.GrantWebManagementAccess(item.SiteId, accountName, accountPassword);
			}
			catch (Exception ex)
			{
				TaskManager.WriteError(ex);
			}
			finally
			{
				TaskManager.CompleteTask();
			}
			//
			return result;
		}

 public static ResultObject SetReplicaServer(int serviceId, string remoteServer, string thumbprint, string storagePath)
 {
     ResultObject result = new ResultObject();
     try
     {
         if (string.IsNullOrEmpty(storagePath))
             throw new Exception("Please enter replication path"); 
         
         VirtualizationServer2012 vs = GetVirtualizationProxy(serviceId);
         vs.SetReplicaServer(remoteServer, thumbprint, storagePath);
         result.IsSuccess = true;
     }
     catch (Exception ex)
     {
         result.AddError(VirtualizationErrorCodes.SET_REPLICA_SERVER_ERROR, ex);
     }
     return result;
 }