private void ProcessSoapRequest(SoapEnvelope envelope)
{
XmlNode authNode = envelope.Header.SelectSingleNode("Authentication");
if (authNode == null)
{
throw new Exception("Couldn't find authentication token specified");
}
XmlNode userNode = authNode.SelectSingleNode("Username");
XmlNode passwordNode = authNode.SelectSingleNode("Password");
if (userNode == null || passwordNode == null)
{
throw new Exception("Authentication token is invalid or broken");
}
UserInfo user = UserController.GetUserByUsernamePassword(
userNode.InnerText,
passwordNode.InnerText,
System.Web.HttpContext.Current.Request.UserHostAddress
);
if (user == null)
{
throw new Exception("Authentication token is invalid or borken");
}
SecurityContext.SetThreadPrincipal(user);
}
public void ChangePackagesServiceItemsState()
{
// impersonate thread
if (userId != -1)
{
SecurityContext.SetThreadPrincipal(userId);
}
TaskManager.StartTask("SPACE", "CHANGE_ITEMS_STATUS");
// collect required service items
List <ServiceProviderItem> items = new List <ServiceProviderItem>();
foreach (PackageInfo package in packages)
{
items.AddRange(PackageController.GetServiceItemsForStatistics(
0, package.PackageId, false, false, true, false)); // suspendable items
}
// order items by service
Dictionary <int, List <ServiceProviderItem> > orderedItems =
PackageController.OrderServiceItemsByServices(items);
// process items
bool enabled = (ItemsStatus == PackageStatus.Active);
foreach (int serviceId in orderedItems.Keys)
{
ProcessServiceItems(true, enabled, serviceId, orderedItems[serviceId]);
}
// add log record
TaskManager.CompleteTask();
}
private static void RunBackgroundTask(BackgroundTask backgroundTask)
{
UserInfo user = PackageController.GetPackageOwner(backgroundTask.PackageId);
SecurityContext.SetThreadPrincipal(user.UserId);
var schedule = SchedulerController.GetScheduleComplete(backgroundTask.ScheduleId);
backgroundTask.Guid = TaskManager.Guid;
backgroundTask.Status = BackgroundTaskStatus.Run;
TaskController.UpdateTask(backgroundTask);
try
{
var objTask = (SchedulerTask)Activator.CreateInstance(Type.GetType(schedule.Task.TaskType));
objTask.DoWork();
}
catch (Exception ex)
{
TaskManager.WriteError(ex, "Error executing scheduled task");
}
finally
{
try
{
TaskManager.CompleteTask();
}
catch (Exception)
{
}
}
}
private void Create()
{
// impersonate thread
if (ThreadUserId != -1)
{
SecurityContext.SetThreadPrincipal(ThreadUserId);
}
// perform backup
VirtualizationServerControllerForPrivateCloud.CreateVirtualMachineAsunc(vmTemplate);
}
public void Import()
{
// impersonate thread
if (threadUserId != -1)
{
SecurityContext.SetThreadPrincipal(threadUserId);
}
// perform import
ImportController.ImportItemsInternal(taskId, packageId, items);
}
private void Create()
{
// impersonate thread
if (ThreadUserId != -1)
{
SecurityContext.SetThreadPrincipal(ThreadUserId);
}
// perform backup
VirtualizationServerControllerForPrivateCloud.CreateVMFromVMAsunc(packageId, vmTemplate, vmName);
}
public void UpdateUser()
{
// impersonate thread
if (threadUserId != -1)
{
SecurityContext.SetThreadPrincipal(threadUserId);
}
// update
UserController.UpdateUser(taskId, user);
}
public void Restore()
{
// impersonate thread
if (threadUserId != -1)
{
SecurityContext.SetThreadPrincipal(threadUserId);
}
// perform restore
BackupController.RestoreInternal(taskId, userId, packageId, serviceId, serverId,
storePackageId, storePackageBackupPath, storeServerBackupPath);
}
public void Backup()
{
// impersonate thread
if (threadUserId != -1)
{
SecurityContext.SetThreadPrincipal(threadUserId);
}
// perform backup
BackupController.BackupInternal(taskId, userId, packageId, serviceId, serverId, backupFileName, storePackageId,
storePackageFolder, storeServerFolder, deleteTempBackup);
}
// Implementation of ThreadStart delegate.
// Used by Scheduler to kick off events on a seperate thread
private void RunSchedule()
{
// impersonate thread
UserInfo user = PackageController.GetPackageOwner(scheduleInfo.PackageId);
SecurityContext.SetThreadPrincipal(user.UserId);
List <BackgroundTaskParameter> parameters = new List <BackgroundTaskParameter>();
foreach (ScheduleTaskParameterInfo prm in scheduleInfo.Parameters)
{
parameters.Add(new BackgroundTaskParameter(prm.ParameterId, prm.ParameterValue));
}
TaskManager.StartTask("SCHEDULER", "RUN_SCHEDULE", scheduleInfo.ScheduleName, scheduleInfo.ScheduleId,
scheduleInfo.ScheduleId, scheduleInfo.PackageId, scheduleInfo.MaxExecutionTime,
parameters);
// run task
try
{
// create scheduled task object
SchedulerTask objTask = (SchedulerTask)Activator.CreateInstance(Type.GetType(task.TaskType));
if (objTask != null)
{
objTask.DoWork();
}
else
{
throw new Exception(String.Format("Could not create scheduled task of '{0}' type",
task.TaskType));
}
// Thread.Sleep(40000);
}
catch (Exception ex)
{
// log error
TaskManager.WriteError(ex, "Error executing scheduled task");
}
finally
{
// complete task
try
{
TaskManager.CompleteTask();
}
catch (Exception)
{
}
}
}
/// <summary>
/// Returns the password or password equivalent for the username provided.
/// </summary>
/// <param name="token">The username token</param>
/// <returns>The password (or password equivalent) for the username</returns>
protected override string AuthenticateToken(UsernameToken token)
{
// try to load user account
UserInfoInternal user = UserController.GetUserInternally(token.Username);
if (user == null)
{
return(null);
}
SecurityContext.SetThreadPrincipal(user);
return(user.Password);
}
private void Create()
{
// impersonate thread
if (ThreadUserId != -1)
{
SecurityContext.SetThreadPrincipal(ThreadUserId);
}
// perform backup
VirtualizationServerController.CreateVirtualMachineInternal(TaskId, Item, OsTemplate,
ExternalAddressesNumber, RandomExternalAddresses, ExternalAddresses,
PrivateAddressesNumber, RandomPrivateAddresses, PrivateAddresses,
SummaryLetterEmail);
}
public void DeletePackagesServiceItems()
{
// impersonate thread
if (userId != -1)
{
SecurityContext.SetThreadPrincipal(userId);
}
// delete package by package
foreach (PackageInfo package in packages)
{
TaskManager.StartTask("SPACE", "DELETE_ITEMS", package.PackageName);
TaskManager.WriteParameter("User", package.UserId);
// get package service items
List <ServiceProviderItem> items = PackageController.GetServiceItemsForStatistics(
0, package.PackageId, false, false, false, true); // disposable items
// order items by service
Dictionary <int, List <ServiceProviderItem> > orderedItems =
PackageController.OrderServiceItemsByServices(items);
// delete service items by service sets
foreach (int serviceId in orderedItems.Keys)
{
ServiceInfo service = ServerController.GetServiceInfo(serviceId);
//Delete Exchange Organization
if (service.ProviderId == 103 /*Organizations*/)
{
OrganizationController.DeleteOrganization(orderedItems[serviceId][0].Id);
//int exchangeId = PackageController.GetPackageServiceId(package.PackageId, ResourceGroups.Exchange2007);
//ExchangeServerController.DeleteOrganization(orderedItems[serviceId][0].Id);
}
else
{
ProcessServiceItems(false, false, serviceId, orderedItems[serviceId]);
}
}
// delete package from database
DataProvider.DeletePackage(SecurityContext.User.UserId, package.PackageId);
}
// add log record
TaskManager.CompleteTask();
}
// Implementation of ThreadStart delegate.
// Used by Scheduler to kick off events on a seperate thread
private void RunSchedule()
{
// impersonate thread
UserInfo user = PackageController.GetPackageOwner(scheduleInfo.PackageId);
SecurityContext.SetThreadPrincipal(user.UserId);
TaskManager.StartTask("SCHEDULER", "RUN_SCHEDULE", scheduleInfo.ScheduleName);
TaskManager.PackageId = scheduleInfo.PackageId;
TaskManager.ItemId = scheduleInfo.ScheduleId;
TaskManager.ScheduleId = scheduleInfo.ScheduleId;
TaskManager.MaximumExecutionTime = scheduleInfo.MaxExecutionTime;
// set task parameters
foreach (ScheduleTaskParameterInfo prm in scheduleInfo.Parameters)
{
TaskManager.TaskParameters[prm.ParameterId] = prm.ParameterValue;
}
// run task
try
{
// create scheduled task object
SchedulerTask objTask = (SchedulerTask)Activator.CreateInstance(Type.GetType(task.TaskType));
if (objTask != null)
{
objTask.DoWork();
}
else
{
throw new Exception(String.Format("Could not create scheduled task of '{0}' type",
task.TaskType));
}
}
catch (Exception ex)
{
// log error
TaskManager.WriteError(ex, "Error executing scheduled task");
}
finally
{
// complete task
TaskManager.CompleteTask();
}
}
private void ProcessBasicAuthRequest()
{
string authStr = HttpContext.Current.Request.Headers["Authorization"];
if (authStr == null || authStr.Length == 0)
{
// No credentials; anonymous request
DenyAccess();
return;
}
authStr = authStr.Trim();
if (authStr.IndexOf("Basic", 0) != 0)
{
// Don't understand this header...we'll pass it along and
// assume someone else will handle it
DenyAccess();
return;
}
string encodedCredentials = authStr.Substring(6);
byte[] decodedBytes = Convert.FromBase64String(encodedCredentials);
string s = new ASCIIEncoding().GetString(decodedBytes);
string[] userPass = s.Split(new char[] { ':' });
string username = userPass[0];
string password = userPass[1];
UserInfo user = UserController.GetUserByUsernamePassword(
username, password, System.Web.HttpContext.Current.Request.UserHostAddress);
if (user == null)
{
// Invalid credentials; deny access
DenyAccess();
return;
//throw new Exception("Wrong BASIC credentials have been supplied");
}
SecurityContext.SetThreadPrincipal(user);
}
public void DeleteUser()
{
// impersonate thread
if (threadUserId != -1)
{
SecurityContext.SetThreadPrincipal(threadUserId);
}
// get user details
UserInfo user = UserController.GetUserInternally(userId);
// place log record
TaskManager.StartTask(taskId, "USER", "DELETE", user.Username);
TaskManager.ItemId = userId;
try
{
// delete user packages
List <PackageInfo> packages = PackageController.GetMyPackages(userId);
// delete user packages synchronously
if (packages.Count > 0)
{
PackageAsyncWorker packageWorker = new PackageAsyncWorker();
packageWorker.UserId = SecurityContext.User.UserId;
packageWorker.Packages = packages;
// invoke worker
packageWorker.DeletePackagesServiceItems();
}
// delete user from database
DataProvider.DeleteUser(SecurityContext.User.UserId, userId);
}
catch (Exception ex)
{
throw TaskManager.WriteError(ex);
}
finally
{
TaskManager.CompleteTask();
}
}
private static void CalculatePackageDiskspaceAsync(object objPrms)
{
ThreadStartParameters prms = (ThreadStartParameters)objPrms;
// impersonate thread
SecurityContext.SetThreadPrincipal(prms.UserId);
int packageId = (int)prms.Parameters[0];
try
{
// calculate
CalculatePackagesDiskspaceTask calc = new CalculatePackagesDiskspaceTask();
calc.CalculatePackage(packageId);
}
catch (Exception ex)
{
// write to audit log
TaskManager.WriteError(ex);
}
}
public void DownloadGalleryWebApplication()
{
SecurityContext.SetThreadPrincipal(UserId);
//
TaskManager.StartTask(WebAppGalleryController.TASK_MANAGER_SOURCE, "DOWNLOAD_WEB_APP", GalleryApp.Title);
TaskManager.WriteParameter("Version", GalleryApp.Version);
TaskManager.WriteParameter("Download URL", GalleryApp.DownloadUrl);
TaskManager.WriteParameter("Author", GalleryApp.AuthorName);
TaskManager.WriteParameter("Last Updated", GalleryApp.LastUpdated);
TaskManager.WriteParameter("Web App ID", WebAppId);
//
try
{
//
WebServer webServer = WebAppGalleryController.GetAssociatedWebServer(PackageId);
//
TaskManager.Write("Application package download has been started");
//
GalleryWebAppStatus appStatus = webServer.DownloadGalleryApplication(WebAppId);
//
if (appStatus == GalleryWebAppStatus.Failed)
{
TaskManager.WriteError("Could not download application package requested");
TaskManager.WriteError("Please check WebsitePanel Server log for further information on this issue");
TaskManager.WriteParameter("Status returned", appStatus);
return;
}
//
TaskManager.Write("Application package download has been started successfully");
}
catch (Exception ex)
{
TaskManager.WriteError(ex);
}
finally
{
//
TaskManager.CompleteTask();
}
}
public static GalleryApplicationsResult GetGalleryApplications(int packageId, string categoryId)
{
GalleryApplicationsResult result;
//
try
{
TaskManager.StartTask(TASK_MANAGER_SOURCE, GET_GALLERY_APPS_TASK);
//
WebServer webServer = GetAssociatedWebServer(packageId);
// ERROR: WAG is unavailable
if (!webServer.IsMsDeployInstalled())
{
return(WAG_MODULE_NOT_AVAILABLE <GalleryApplicationsResult>());
}
//
result = webServer.GetGalleryApplications(categoryId);
//
if (!result.IsSuccess)
{
foreach (string errorMessage in result.ErrorCodes)
{
TaskManager.WriteError(errorMessage);
}
//
return(WAG_GENERIC_MODULE_ERROR <GalleryApplicationsResult>());
}
//
PackageContext context = PackageController.GetPackageContext(packageId);
//
List <string> appsFilter = new List <string>();
// if either ASP.NET 1.1 or 2.0 enabled in the hosting plan
if (context.Quotas[Quotas.WEB_ASPNET11].QuotaAllocatedValue == 1 ||
context.Quotas[Quotas.WEB_ASPNET20].QuotaAllocatedValue == 1 ||
context.Quotas[Quotas.WEB_ASPNET40].QuotaAllocatedValue == 1)
{
appsFilter.AddRange(SupportedAppDependencies.ASPNET_SCRIPTING);
}
// if either PHP 4 or 5 enabled in the hosting plan
if (context.Quotas[Quotas.WEB_PHP4].QuotaAllocatedValue == 1 ||
context.Quotas[Quotas.WEB_PHP5].QuotaAllocatedValue == 1)
{
appsFilter.AddRange(SupportedAppDependencies.PHP_SCRIPTING);
}
// if either MSSQL 2000, 2005 or 2008 enabled in the hosting plan
if (context.Groups.ContainsKey(ResourceGroups.MsSql2000) ||
context.Groups.ContainsKey(ResourceGroups.MsSql2005) ||
context.Groups.ContainsKey(ResourceGroups.MsSql2008))
{
appsFilter.AddRange(SupportedAppDependencies.MSSQL_DATABASE);
}
// if either MySQL 4 or 5 enabled in the hosting plan
if (context.Groups.ContainsKey(ResourceGroups.MySql4) ||
context.Groups.ContainsKey(ResourceGroups.MySql5))
{
appsFilter.AddRange(SupportedAppDependencies.MYSQL_DATABASE);
}
// Match applications based on the hosting plan restrictions collected
result.Value = new List <GalleryApplication>(Array.FindAll <GalleryApplication>(result.Value.ToArray(),
x => MatchGalleryAppDependencies(x.Dependency, appsFilter.ToArray()) ||
MatchMenaltoGalleryApp(x, appsFilter.ToArray())));
{
int userId = SecurityContext.User.UserId;
//
SecurityContext.SetThreadSupervisorPrincipal();
//
string[] filteredApps = GetServiceAppsCatalogFilter(packageId);
//
if (filteredApps != null)
{
result.Value = new List <GalleryApplication>(Array.FindAll(result.Value.ToArray(),
x => !Array.Exists(filteredApps,
z => z.Equals(x.Id, StringComparison.InvariantCultureIgnoreCase))));
}
//
SecurityContext.SetThreadPrincipal(userId);
}
}
catch (Exception ex)
{
TaskManager.WriteError(ex);
//
return(WAG_GENERIC_MODULE_ERROR <GalleryApplicationsResult>());
}
finally
{
TaskManager.CompleteTask();
}
//
return(result);
}