private void LoadService()
{
service = ES.Services.Servers.GetServiceInfo(PanelRequest.ServiceId);
if (service == null)
// return
RedirectBack();
// load provider details
provider = ES.Services.Servers.GetProvider(service.ProviderId);
// load resource group details
resourceGroup = ES.Services.Servers.GetResourceGroup(provider.GroupId);
}
protected void btnAdd_Click(object sender, EventArgs e)
{
// validate input
if (!Page.IsValid)
return;
// register service type
int providerId = Utils.ParseInt(ddlProviders.SelectedValue, 0);
// add a new service ...
try
{
ServiceInfo service = new ServiceInfo();
service.ServerId = PanelRequest.ServerId;
service.ProviderId = providerId;
service.ServiceName = serviceName.Text;
BoolResult res = ES.Services.Servers.IsInstalled(PanelRequest.ServerId, providerId);
if (res.IsSuccess)
{
if (!res.Value)
{
ShowErrorMessage("SOFTWARE_IS_NOT_INSTALLED");
return;
}
}
else
{
ShowErrorMessage("SERVER_ADD_SERVICE");
}
int serviceId = ES.Services.Servers.AddService(service);
if (serviceId < 0)
{
ShowResultMessage(serviceId);
return;
}
// ...and go to service configuration page
Response.Redirect(EditUrl("ServerID", PanelRequest.ServerId.ToString(), "edit_service",
"ServiceID=" + serviceId.ToString()), true);
}
catch (Exception ex)
{
ShowErrorMessage("SERVER_ADD_SERVICE", ex);
return;
}
}
public int AddService(ServiceInfo service)
{
return ServerController.AddService(service);
}
public static int UpdateService(ServiceInfo service)
{
// check account
int accountCheck = SecurityContext.CheckAccount(DemandAccount.NotDemo | DemandAccount.IsAdmin
| DemandAccount.IsActive);
if (accountCheck < 0) return accountCheck;
// load original service
ServiceInfo origService = GetServiceInfo(service.ServiceId);
TaskManager.StartTask("SERVER", "UPDATE_SERVICE");
TaskManager.ItemId = origService.ServerId;
TaskManager.ItemName = GetServerByIdInternal(origService.ServerId).ServerName;
TaskManager.WriteParameter("New service name", service.ServiceName);
DataProvider.UpdateService(service.ServiceId, service.ServiceName,
service.ServiceQuotaValue, service.ClusterId, service.Comments);
TaskManager.CompleteTask();
return 0;
}
public static int AddService(ServiceInfo service)
{
// check account
int accountCheck = SecurityContext.CheckAccount(DemandAccount.NotDemo | DemandAccount.IsAdmin
| DemandAccount.IsActive);
if (accountCheck < 0) return accountCheck;
TaskManager.StartTask("SERVER", "ADD_SERVICE");
TaskManager.ItemId = service.ServerId;
TaskManager.ItemName = GetServerByIdInternal(service.ServerId).ServerName;
TaskManager.WriteParameter("Service name", service.ServiceName);
TaskManager.WriteParameter("Provider", service.ProviderId);
int serviceId = DataProvider.AddService(service.ServerId, service.ProviderId, service.ServiceName,
service.ServiceQuotaValue, service.ClusterId, service.Comments);
// read service default settings
try
{
// load original settings
StringDictionary origSettings = GetServiceSettingsAdmin(serviceId);
// load provider settings
ServiceProvider svc = new ServiceProvider();
ServiceProviderProxy.Init(svc, serviceId);
SettingPair[] settings = svc.GetProviderDefaultSettings();
if (settings != null && settings.Length > 0)
{
// merge settings
foreach (SettingPair pair in settings)
origSettings[pair.Name] = pair.Value;
// update settings in the meta base
string[] bareSettings = new string[origSettings.Count];
int i = 0;
foreach (string key in origSettings.Keys)
bareSettings[i++] = key + "=" + origSettings[key];
UpdateServiceSettings(serviceId, bareSettings);
}
}
catch (Exception ex)
{
TaskManager.WriteError(ex, "Error reading default provider settings");
}
TaskManager.CompleteTask();
return serviceId;
}
private static void FindServices(ServerInfo server)
{
try
{
List<ProviderInfo> providers;
try
{
providers = GetProviders();
}
catch (Exception ex)
{
TaskManager.WriteError(ex);
throw new ApplicationException("Could not get providers list.");
}
foreach (ProviderInfo provider in providers)
{
if (!provider.DisableAutoDiscovery)
{
BoolResult isInstalled = IsInstalled(server.ServerId, provider.ProviderId);
if (isInstalled.IsSuccess)
{
if (isInstalled.Value)
{
try
{
ServiceInfo service = new ServiceInfo();
service.ServerId = server.ServerId;
service.ProviderId = provider.ProviderId;
service.ServiceName = provider.DisplayName;
AddService(service);
}
catch (Exception ex)
{
TaskManager.WriteError(ex);
}
}
}
else
{
string errors = string.Join("\n", isInstalled.ErrorCodes.ToArray());
string str =
string.Format(
"Could not check if specific software intalled for {0}. Following errors have been occured:\n{1}",
provider.ProviderName, errors);
TaskManager.WriteError(str);
}
}
}
}
catch (Exception ex)
{
throw new ApplicationException("Could not find services. General error was occued.", ex);
}
}
public int UpdateService(ServiceInfo service) {
object[] results = this.Invoke("UpdateService", new object[] {
service});
return ((int)(results[0]));
}
private int AddSqlService(int serverId)
{
int serviceId = -1;
try
{
Log.WriteStart("Adding Sql service");
SqlServerItem item = ParseConnectionString(Wizard.SetupVariables.DbInstallConnectionString);
string serverName = item.Server.ToLower();
if (serverName.StartsWith("(local)") ||
serverName.StartsWith("localhost") ||
serverName.StartsWith(System.Environment.MachineName.ToLower()))
{
ServiceInfo serviceInfo = new ServiceInfo();
serviceInfo.ServerId = serverId;
serviceInfo.ServiceName = "SQL Server";
serviceInfo.Comments = string.Empty;
string connectionString = Wizard.SetupVariables.DbInstallConnectionString;
//check SQL version
if (SqlUtils.CheckSqlConnection(connectionString))
{
// check SQL server version
string sqlVersion = SqlUtils.GetSqlServerVersion(connectionString);
if (sqlVersion.StartsWith("9."))
{
serviceInfo.ProviderId = 16;
}
else if (sqlVersion.StartsWith("10."))
{
serviceInfo.ProviderId = 202;
}
serviceId = ES.Services.Servers.AddService(serviceInfo);
}
else
Log.WriteInfo("SQL Server connection error");
//configure service
if (serviceId > 0)
{
StringDictionary settings = GetServiceSettings(serviceId);
if (settings != null)
{
settings["InternalAddress"] = item.Server;
settings["ExternalAddress"] = string.Empty;
settings["UseTrustedConnection"] = item.WindowsAuthentication.ToString();
settings["SaLogin"] = item.User;
settings["SaPassword"] = item.Password;
UpdateServiceSettings(serviceId, settings);
}
InstallService(serviceId);
Log.WriteEnd("Added Sql service");
}
else
{
Log.WriteError(string.Format("Enterprise Server error: {0}", serviceId));
}
}
else
{
Log.WriteError("Microsoft SQL Server was not found");
}
return serviceId;
}
catch (Exception ex)
{
if (!Utils.IsThreadAbortException(ex))
Log.WriteError("Sql service configuration error", ex);
return -1;
}
}
private int AddOSService(int serverId)
{
try
{
Log.WriteStart("Adding OS service");
ServiceInfo serviceInfo = new ServiceInfo();
serviceInfo.ServerId = serverId;
serviceInfo.ServiceName = "OS";
serviceInfo.Comments = string.Empty;
//check OS version
OS.WindowsVersion version = OS.GetVersion();
if (version == OS.WindowsVersion.WindowsServer2003)
{
serviceInfo.ProviderId = 1;
}
else if (version == OS.WindowsVersion.WindowsServer2008)
{
serviceInfo.ProviderId = 100;
}
int serviceId = ES.Services.Servers.AddService(serviceInfo);
if (serviceId > 0)
{
InstallService(serviceId);
Log.WriteEnd("Added OS service");
}
else
{
Log.WriteError(string.Format("Enterprise Server error: {0}", serviceId));
}
return serviceId;
}
catch (Exception ex)
{
if (!Utils.IsThreadAbortException(ex))
Log.WriteError("OS service configuration error", ex);
return -1;
}
}
protected void btnUpdate_Click(object sender, EventArgs e)
{
// validate input
if (!Page.IsValid)
return;
service = new ServiceInfo();
service.ServiceId = PanelRequest.ServiceId;
service.ServiceName = txtServiceName.Text.Trim();
service.ServiceQuotaValue = Utils.ParseInt(txtQuotaValue.Text, 0);
service.ClusterId = Utils.ParseInt(ddlClusters.SelectedValue, 0);
service.Comments = txtComments.Text;
// update service
try
{
int result = ES.Services.Servers.UpdateService(service);
if (result < 0)
{
ShowResultMessage(result);
return;
}
}
catch (Exception ex)
{
ShowErrorMessage("SERVER_UPDATE_SERVICE", ex);
return;
}
// save properties
SaveServiceProperties();
// install service
string[] installResults = null;
try
{
installResults = ES.Services.Servers.InstallService(PanelRequest.ServiceId);
}
catch (Exception ex)
{
ShowErrorMessage("SERVER_INSTALL_SERVICE", ex);
return;
}
// check results
if (installResults != null && installResults.Length > 0)
{
rowInstallResults.Visible = true;
blInstallResults.Items.Clear();
foreach (string installResult in installResults)
blInstallResults.Items.Add(installResult);
return;
}
// save quotas
//SaveServiceQuotas();
// return
RedirectBack();
}
public override void DoWork()
{
// Input parameters:
// - FILE_PATH
// - FTP_SERVER
// - FTP_USERNAME
// - FTP_PASSWORD
// - FTP_FOLDER
// get input parameters
string filePath = (string)TaskManager.TaskParameters["FILE_PATH"];
string ftpServer = (string)TaskManager.TaskParameters["FTP_SERVER"];
string ftpUsername = (string)TaskManager.TaskParameters["FTP_USERNAME"];
string ftpPassword = (string)TaskManager.TaskParameters["FTP_PASSWORD"];
string ftpFolder = (string)TaskManager.TaskParameters["FTP_FOLDER"];
// check input parameters
if (String.IsNullOrEmpty(filePath))
{
TaskManager.WriteWarning("Specify 'File' task parameter");
return;
}
if (String.IsNullOrEmpty(ftpServer))
{
TaskManager.WriteWarning("Specify 'FTP Server' task parameter");
return;
}
// substitute parameters
DateTime d = DateTime.Now;
string date = d.ToString("yyyyMMdd");
string time = d.ToString("HHmm");
filePath = Utils.ReplaceStringVariable(filePath, "date", date);
filePath = Utils.ReplaceStringVariable(filePath, "time", time);
// build FTP command file
StringBuilder sb = new StringBuilder();
StringWriter writer = new StringWriter(sb);
// FTP server
writer.WriteLine("open " + ftpServer);
// check if anonymous mode
if (String.IsNullOrEmpty(ftpUsername))
{
ftpUsername = "******";
ftpPassword = "******";
}
// FTP username/password
writer.WriteLine(ftpUsername);
writer.WriteLine(ftpPassword);
// check if we need to change remote folder
if (!String.IsNullOrEmpty(ftpFolder))
{
writer.WriteLine("cd " + ftpFolder.Replace("\\", "/"));
}
// file to send
writer.WriteLine("binary");
writer.WriteLine("put " + FilesController.GetFullPackagePath(TaskManager.PackageId, filePath));
// bye
writer.WriteLine("bye");
string cmdBatch = sb.ToString();
// create temp file in user space
string cmdPath = Utils.GetRandomString(10) + ".txt";
string fullCmdPath = FilesController.GetFullPackagePath(TaskManager.PackageId, cmdPath);
// upload batch
FilesController.UpdateFileBinaryContent(TaskManager.PackageId, cmdPath, Encoding.UTF8.GetBytes(cmdBatch));
// execute system command
// load OS service
int serviceId = PackageController.GetPackageServiceId(TaskManager.PackageId, ResourceGroups.Os);
// load service
ServiceInfo service = ServerController.GetServiceInfo(serviceId);
if (service == null)
{
return;
}
WindowsServer winServer = new WindowsServer();
ServiceProviderProxy.ServerInit(winServer, service.ServerId);
TaskManager.Write(winServer.ExecuteSystemCommand("ftp.exe", "-s:" + fullCmdPath));
// delete batch file
FilesController.DeleteFiles(TaskManager.PackageId, new string[] { cmdPath });
}
/// <remarks/>
public void UpdateServiceAsync(ServiceInfo service, object userState) {
if ((this.UpdateServiceOperationCompleted == null)) {
this.UpdateServiceOperationCompleted = new System.Threading.SendOrPostCallback(this.OnUpdateServiceOperationCompleted);
}
this.InvokeAsync("UpdateService", new object[] {
service}, this.UpdateServiceOperationCompleted, userState);
}
/// <remarks/>
public void UpdateServiceAsync(ServiceInfo service) {
this.UpdateServiceAsync(service, null);
}
/// <remarks/>
public System.IAsyncResult BeginUpdateService(ServiceInfo service, System.AsyncCallback callback, object asyncState) {
return this.BeginInvoke("UpdateService", new object[] {
service}, callback, asyncState);
}
public int UpdateService(ServiceInfo service)
{
return ServerController.UpdateService(service);
}
public int AddService(ServiceInfo service)
{
return(ServerController.AddService(service));
}
public int UpdateService(ServiceInfo service)
{
return(ServerController.UpdateService(service));
}
private int AddWebService(int serverId, int ipAddressId)
{
try
{
Log.WriteStart("Adding Web service");
ServiceInfo serviceInfo = new ServiceInfo();
serviceInfo.ServerId = serverId;
serviceInfo.ServiceName = "Web";
serviceInfo.Comments = string.Empty;
//check IIS version
if (Wizard.SetupVariables.IISVersion.Major == 7)
{
serviceInfo.ProviderId = 101;
}
else if (Wizard.SetupVariables.IISVersion.Major == 6)
{
serviceInfo.ProviderId = 2;
}
int serviceId = ES.Services.Servers.AddService(serviceInfo);
if (serviceId > 0)
{
StringDictionary settings = GetServiceSettings(serviceId);
if (settings != null)
{
// set ip address
if (ipAddressId > 0)
settings["sharedip"] = ipAddressId.ToString();
// settings for win2003 x64
if (Wizard.SetupVariables.IISVersion.Major == 6 &&
Utils.IsWin64() && !Utils.IIS32Enabled())
{
settings["AspNet20Path"] = @"%SYSTEMROOT%\Microsoft.NET\Framework64\v2.0.50727\aspnet_isapi.dll";
settings["Php4Path"] = @"%SYSTEMDRIVE%\Program Files (x86)\PHP\php.exe";
settings["Php5Path"] = @"%SYSTEMDRIVE%\Program Files (x86)\PHP\php-cgi.exe";
}
// settings for win2008 x64
if (Wizard.SetupVariables.IISVersion.Major > 6 &&
Utils.IsWin64())
{
settings["Php4Path"] = @"%SYSTEMDRIVE%\Program Files (x86)\PHP\php.exe";
settings["Php5Path"] = @"%SYSTEMDRIVE%\Program Files (x86)\PHP\php-cgi.exe";
settings["phppath"] = @"%SYSTEMDRIVE%\Program Files (x86)\PHP\php-cgi.exe";
}
UpdateServiceSettings(serviceId, settings);
}
InstallService(serviceId);
Log.WriteEnd("Added Web service");
}
else
{
Log.WriteError(string.Format("Enterprise Server error: {0}", serviceId));
}
return serviceId;
}
catch (Exception ex)
{
if (!Utils.IsThreadAbortException(ex))
Log.WriteError("Web service configuration error", ex);
return -1;
}
}
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();
}
}
private int AddDnsService(int serverId, int ipAddressId)
{
try
{
Log.WriteStart("Adding DNS service");
int providerId = 7;
int serviceId = -1;
BoolResult result = ES.Services.Servers.IsInstalled(serverId, providerId);
if (result.IsSuccess && result.Value)
{
ServiceInfo serviceInfo = new ServiceInfo();
serviceInfo.ServerId = serverId;
serviceInfo.ServiceName = "DNS";
serviceInfo.Comments = string.Empty;
serviceInfo.ProviderId = providerId;
serviceId = ES.Services.Servers.AddService(serviceInfo);
}
else
{
Log.WriteInfo("Microsoft DNS was not found");
return -1;
}
if (serviceId > 0)
{
StringDictionary settings = GetServiceSettings(serviceId);
if (settings != null)
{
if (ipAddressId > 0)
settings["listeningipaddresses"] = ipAddressId.ToString();
UpdateServiceSettings(serviceId, settings);
}
InstallService(serviceId);
Log.WriteEnd("Added DNS service");
}
else
{
Log.WriteError(string.Format("Enterprise Server error: {0}", serviceId));
}
return serviceId;
}
catch (Exception ex)
{
if (!Utils.IsThreadAbortException(ex))
Log.WriteError("DNS service configuration error", ex);
return -1;
}
}
/// <remarks/>
public void AddServiceAsync(ServiceInfo service) {
this.AddServiceAsync(service, null);
}
