示例#1
0
        private void RollbackInstallation(InstallationInfo inst)
        {
            // remove virtual dir
            if (inst[PROPERTY_VDIR_CREATED] != null)
            {
                // delete virtual directory
                WebServerController.DeleteVirtualDirectory(inst.WebSiteId, inst.VirtualDir);

                // delete folder
                FilesController.DeleteFiles(inst.PackageId, new string[] { inst[PROPERTY_CONTENT_PATH] });
            }

            // remove database
            if (inst[PROPERTY_DATABASE_CREATED] != null)
            {
                DatabaseServerController.DeleteSqlDatabase(inst.DatabaseId);
            }

            // remove database user
            if (inst[PROPERTY_USER_CREATED] != null)
            {
                DatabaseServerController.DeleteSqlUser(inst.UserId);
            }
        }
 public string BackupSqlDatabase(int itemId, string backupName,
                                 bool zipBackup, bool download, string folderName)
 {
     return(DatabaseServerController.BackupSqlDatabase(itemId, backupName, zipBackup,
                                                       download, folderName));
 }
 public int UpdateSqlDatabase(SqlDatabase item)
 {
     return(DatabaseServerController.UpdateSqlDatabase(item));
 }
 public int DeleteSqlDatabase(int itemId)
 {
     return(DatabaseServerController.DeleteSqlDatabase(itemId));
 }
示例#5
0
        public override void DoWork()
        {
            // Input parameters:
            //  - DATABASE_GROUP
            //  - DATABASE_NAME
            //  - BACKUP_FOLDER
            //  - BACKUP_NAME
            //  - ZIP_BACKUP

            string databaseGroup = (string)TaskManager.TaskParameters["DATABASE_GROUP"];
            string databaseName  = (string)TaskManager.TaskParameters["DATABASE_NAME"];
            string backupFolder  = (string)TaskManager.TaskParameters["BACKUP_FOLDER"];
            string backupName    = (string)TaskManager.TaskParameters["BACKUP_NAME"];
            string strZipBackup  = (string)TaskManager.TaskParameters["ZIP_BACKUP"];

            // check input parameters
            if (String.IsNullOrEmpty(databaseName))
            {
                TaskManager.WriteWarning("Specify 'Database Name' task parameter.");
                return;
            }

            bool zipBackup = (strZipBackup.ToLower() == "true");

            if (String.IsNullOrEmpty(backupName))
            {
                backupName = databaseName + (zipBackup ? ".zip" : ".bak");
            }
            else
            {
                // check extension
                string ext = Path.GetExtension(backupName);
                if (zipBackup && String.Compare(ext, ".zip", true) != 0)
                {
                    // change extension to .zip
                    backupName = Path.GetFileNameWithoutExtension(backupName) + ".zip";
                }
            }

            // try to find database
            SqlDatabase item = (SqlDatabase)PackageController.GetPackageItemByName(TaskManager.PackageId, databaseGroup,
                                                                                   databaseName, typeof(SqlDatabase));

            if (item == null)
            {
                TaskManager.WriteError("Database with the specified name was not found in the current hosting space.");
                return;
            }

            if (String.IsNullOrEmpty(backupFolder))
            {
                backupFolder = "\\";
            }

            // substitute parameters
            DateTime d    = DateTime.Now;
            string   date = d.ToString("yyyyMMdd");
            string   time = d.ToString("HHmm");

            backupFolder = Utils.ReplaceStringVariable(backupFolder, "date", date);
            backupFolder = Utils.ReplaceStringVariable(backupFolder, "time", time);
            backupName   = Utils.ReplaceStringVariable(backupName, "date", date);
            backupName   = Utils.ReplaceStringVariable(backupName, "time", time);

            // backup database
            DatabaseServerController.BackupSqlDatabase(item.Id, backupName, zipBackup, false, backupFolder);
        }
 public string AppendSqlBackupBinaryChunk(int itemId, string fileName, string path, byte[] chunk)
 {
     return(DatabaseServerController.AppendSqlBackupBinaryChunk(itemId, fileName, path, chunk));
 }
 public DataSet GetRawSqlDatabasesPaged(int packageId, string groupName,
                                        string filterColumn, string filterValue, string sortColumn, int startRow, int maximumRows)
 {
     return(DatabaseServerController.GetRawSqlDatabasesPaged(packageId, groupName, filterColumn, filterValue,
                                                             sortColumn, startRow, maximumRows));
 }
示例#8
0
        public static int DeleteSite(int itemId)
        {
            // check account
            int accountCheck = SecurityContext.CheckAccount(DemandAccount.NotDemo);

            if (accountCheck < 0)
            {
                return(accountCheck);
            }

            // load original meta item
            SharePointSite origItem = (SharePointSite)PackageController.GetPackageItem(itemId);

            if (origItem == null)
            {
                return(BusinessErrorCodes.ERROR_SHAREPOINT_PACKAGE_ITEM_NOT_FOUND);
            }

            // place log record
            TaskManager.StartTask("SHAREPOINT", "DELETE_SITE", origItem.Name);
            TaskManager.ItemId = itemId;

            try
            {
                // get service
                SharePointServer sps = GetSharePoint(origItem.ServiceId);

                // delete service item
                sps.UnextendVirtualServer(origItem.Name, true);

                try
                {
                    // delete database
                    ServiceProviderItem dbItem = PackageController.GetPackageItemByName(origItem.PackageId, origItem.DatabaseGroupName,
                                                                                        origItem.DatabaseName, typeof(SqlDatabase));
                    if (dbItem != null)
                    {
                        DatabaseServerController.DeleteSqlDatabase(dbItem.Id);
                    }

                    // delete database user
                    dbItem = PackageController.GetPackageItemByName(origItem.PackageId, origItem.DatabaseGroupName,
                                                                    origItem.DatabaseUser, typeof(SqlUser));
                    if (dbItem != null)
                    {
                        DatabaseServerController.DeleteSqlUser(dbItem.Id);
                    }
                }
                catch (Exception ex2)
                {
                    TaskManager.WriteError(ex2);
                }

                // delete meta item
                PackageController.DeletePackageItem(origItem.Id);

                try
                {
                    // start web site
                    WebSite site = WebServerController.GetWebSite(origItem.PackageId, origItem.Name);
                    if (site != null)
                    {
                        WebServerController.ChangeSiteState(site.Id, ServerState.Started);
                    }
                }
                catch (Exception ex)
                {
                    TaskManager.WriteError(ex);
                }

                return(0);
            }
            catch (Exception ex)
            {
                throw TaskManager.WriteError(ex);
            }
            finally
            {
                TaskManager.CompleteTask();
            }
        }
 public DatabaseBrowserConfiguration GetDatabaseBrowserLogonScript(int packageId,
                                                                   string groupName, string username)
 {
     return(DatabaseServerController.GetDatabaseBrowserLogonScript(packageId, groupName, username));
 }
 public int UpdateSqlUser(SqlUser item)
 {
     return(DatabaseServerController.UpdateSqlUser(item));
 }
 public DatabaseBrowserConfiguration GetDatabaseBrowserConfiguration(int packageId, string groupName)
 {
     return(DatabaseServerController.GetDatabaseBrowserConfiguration(packageId, groupName));
 }
 public int TruncateSqlDatabase(int itemId)
 {
     return(DatabaseServerController.TruncateSqlDatabase(itemId));
 }
 public int RestoreSqlDatabase(int itemId, string[] uploadedFiles, string[] packageFiles)
 {
     return(DatabaseServerController.RestoreSqlDatabase(itemId, uploadedFiles, packageFiles));
 }
示例#14
0
        public int InstallWebApplication(InstallationInfo inst)
        {
            // place log record
            TaskManager.StartTask("APP_INSTALLER", "INSTALL_APPLICATION", inst.PackageId);

            TaskManager.WriteParameter("Virtual directory", inst.VirtualDir);
            TaskManager.WriteParameter("Database group", inst.DatabaseGroup);

            try
            {
                // get application info
                app = GetApplication(inst.PackageId, inst.ApplicationId);

                BackgroundTask topTask = TaskManager.TopTask;

                topTask.ItemName = app.Name;

                TaskController.UpdateTask(topTask);

                // check web site for existance
                WebSite webSite = WebServerController.GetWebSite(inst.WebSiteId);

                if (webSite == null)
                {
                    return(BusinessErrorCodes.ERROR_WEB_INSTALLER_WEBSITE_NOT_EXISTS);
                }

                TaskManager.WriteParameter("Web site", webSite.Name);

                webSiteName = webSite.Name;
                siteId      = webSite.SiteId;

                // change web site properties if required
                if (String.IsNullOrEmpty(inst.VirtualDir))
                {
                    ChangeVirtualDirectoryProperties(webSite, app.WebSettings);
                    WebServerController.UpdateWebSite(webSite);
                }

                // get OS service
                int osId = PackageController.GetPackageServiceId(inst.PackageId, "os");
                os = new OS.OperatingSystem();
                ServiceProviderProxy.Init(os, osId);

                // get remote content path
                contentPath = webSite.ContentPath;

                // create virtual dir if required
                if (!String.IsNullOrEmpty(inst.VirtualDir))
                {
                    // check if the required virtual dir already exists
                    contentPath = Path.Combine(contentPath, inst.VirtualDir);

                    WebVirtualDirectory vdir = null;
                    int result = WebServerController.AddVirtualDirectory(inst.WebSiteId, inst.VirtualDir, contentPath);
                    if (result == BusinessErrorCodes.ERROR_VDIR_ALREADY_EXISTS)
                    {
                        // the directory alredy exists
                        vdir = WebServerController.GetVirtualDirectory(
                            inst.WebSiteId, inst.VirtualDir);

                        contentPath = vdir.ContentPath;
                    }
                    else
                    {
                        vdir = WebServerController.GetVirtualDirectory(
                            inst.WebSiteId, inst.VirtualDir);

                        inst[PROPERTY_VDIR_CREATED] = "True";
                    }

                    // change virtual directory properties if required
                    ChangeVirtualDirectoryProperties(vdir, app.WebSettings);
                    WebServerController.UpdateVirtualDirectory(inst.WebSiteId, vdir);
                }

                // deploy application codebase ZIP and then unpack it
                string codebasePath       = app.Codebase;
                string remoteCodebasePath = Path.Combine(contentPath, Path.GetFileName(app.Codebase));

                // make content path absolute
                string absContentPath = FilesController.GetFullPackagePath(inst.PackageId, contentPath);

                // save content path
                inst[PROPERTY_CONTENT_PATH]          = contentPath;
                inst[PROPERTY_ABSOLUTE_CONTENT_PATH] = absContentPath;

                // copy ZIP to the target server
                FileStream stream        = File.OpenRead(codebasePath);
                int        BUFFER_LENGTH = 5000000;

                byte[] buffer    = new byte[BUFFER_LENGTH];
                int    readBytes = 0;
                while (true)
                {
                    readBytes = stream.Read(buffer, 0, BUFFER_LENGTH);

                    if (readBytes < BUFFER_LENGTH)
                    {
                        Array.Resize <byte>(ref buffer, readBytes);
                    }

                    FilesController.AppendFileBinaryChunk(inst.PackageId, remoteCodebasePath, buffer);

                    if (readBytes < BUFFER_LENGTH)
                    {
                        break;
                    }
                }



                // unpack codebase
                inst[PROPERTY_INSTALLED_FILES] = String.Join(";",
                                                             FilesController.UnzipFiles(inst.PackageId, new string[] { remoteCodebasePath }));

                // delete codebase zip
                FilesController.DeleteFiles(inst.PackageId, new string[] { remoteCodebasePath });

                // check/create databases
                if (!String.IsNullOrEmpty(inst.DatabaseGroup) &&
                    String.Compare(inst.DatabaseGroup, "None", true) != 0)
                {
                    // database
                    if (inst.DatabaseId == 0)
                    {
                        TaskManager.WriteParameter("Database name", inst.DatabaseName);

                        // we should create a new database
                        SqlDatabase db = new SqlDatabase();
                        db.PackageId    = inst.PackageId;
                        db.Name         = inst.DatabaseName;
                        inst.DatabaseId = DatabaseServerController.AddSqlDatabase(db, inst.DatabaseGroup);
                        if (inst.DatabaseId < 0)
                        {
                            // rollback installation
                            RollbackInstallation(inst);

                            // return error
                            return(inst.DatabaseId); // there was an error when creating database
                        }

                        inst[PROPERTY_DATABASE_CREATED] = "True";
                    }
                    else
                    {
                        // existing database
                        SqlDatabase db = DatabaseServerController.GetSqlDatabase(inst.DatabaseId);
                        inst.DatabaseName = db.Name;

                        TaskManager.WriteParameter("Database name", inst.DatabaseName);
                    }

                    SqlUser user = null;
                    // database user
                    if (inst.UserId == 0)
                    {
                        TaskManager.WriteParameter("Database user", inst.Username);

                        // NEW USER
                        user           = new SqlUser();
                        user.PackageId = inst.PackageId;
                        user.Name      = inst.Username;
                        user.Databases = new string[] { inst.DatabaseName };
                        user.Password  = inst.Password;
                        inst.UserId    = DatabaseServerController.AddSqlUser(user, inst.DatabaseGroup);
                        if (inst.UserId < 0)
                        {
                            // rollback installation
                            RollbackInstallation(inst);

                            // return error
                            return(inst.UserId); // error while adding user
                        }

                        inst[PROPERTY_USER_CREATED] = "True";
                    }
                    else
                    {
                        // EXISTING USER
                        user          = DatabaseServerController.GetSqlUser(inst.UserId);
                        inst.Username = user.Name;

                        TaskManager.WriteParameter("Database user", inst.Username);

                        List <string> databases = new List <string>();
                        databases.AddRange(user.Databases);

                        if (!databases.Contains(inst.DatabaseName))
                        {
                            databases.Add(inst.DatabaseName);

                            user.Databases = databases.ToArray();
                            DatabaseServerController.UpdateSqlUser(user);
                        }
                    }

                    // check connectivity with SQL Server and credentials provided
                    // load user item
                    int sqlServiceId = PackageController.GetPackageServiceId(inst.PackageId, inst.DatabaseGroup);
                    sql = new DatabaseServer();
                    ServiceProviderProxy.Init(sql, sqlServiceId);

                    if (!sql.CheckConnectivity(inst.DatabaseName, inst.Username,
                                               inst.Password))
                    {
                        // can't connect to the database
                        RollbackInstallation(inst);

                        return(BusinessErrorCodes.ERROR_WEB_INSTALLER_CANT_CONNECT_DATABASE);
                    }

                    // read SQL server settings
                    StringDictionary settings = ServerController.GetServiceSettings(sqlServiceId);
                    serverIpAddressExternal = settings["ExternalAddress"];
                    if (settings.ContainsKey("InternalAddress"))
                    {
                        serverIpAddressInternal = settings["InternalAddress"];
                    }
                }

                // ********* RUN INSTALL SCENARIO ***********
                int scriptResult = RunInstallScenario(inst);
                if (scriptResult < 0)
                {
                    // rollback installation
                    RollbackInstallation(inst);

                    // return error
                    return(scriptResult);
                }

                // add new installation to the database
                return(0);
            }
            catch (Exception ex)
            {
                // rollback installation
                RollbackInstallation(inst);

                throw TaskManager.WriteError(ex);
            }
            finally
            {
                TaskManager.CompleteTask();
            }
        }
 public List <SqlDatabase> GetSqlDatabases(int packageId, string groupName, bool recursive)
 {
     return(DatabaseServerController.GetSqlDatabases(packageId, groupName, recursive));
 }
        public static StringResultObject Install(int packageId, string webAppId, string siteName, string virtualDir, List <DeploymentParameter> parameters)
        {
            StringResultObject result = new StringResultObject();

            try
            {
                // database operation results
                int databaseResult     = -1;
                int databaseUserResult = -1;

                // initialize task manager
                TaskManager.StartTask(TASK_MANAGER_SOURCE, "INSTALL_WEB_APP");
                TaskManager.WriteParameter("Package ID", packageId);
                TaskManager.WriteParameter("Site Name", siteName);

                #region Check Space and Account
                // Check account
                int accountCheck = SecurityContext.CheckAccount(DemandAccount.NotDemo | DemandAccount.IsActive);
                if (accountCheck < 0)
                {
                    return(Warning <StringResultObject>((-accountCheck).ToString()));
                }

                // Check space
                int packageCheck = SecurityContext.CheckPackage(packageId, DemandPackage.IsActive);
                if (packageCheck < 0)
                {
                    return(Warning <StringResultObject>((-packageCheck).ToString()));
                }
                #endregion

                #region Check MS Deploy, web site and application pack
                // get target web server
                WebServer webServer = GetAssociatedWebServer(packageId);

                // Check if Web App Gallery is installed
                if (!webServer.IsMsDeployInstalled())
                {
                    return(Error <StringResultObject>(GalleryErrors.MsDeployIsNotInstalled));
                }

                // Check web site for existence
                WebSite webSite = WebServerController.GetWebSite(packageId, siteName);
                if (webSite == null)
                {
                    return(Error <StringResultObject>(GalleryErrors.WebSiteNotFound, siteName));
                }

                // get application pack details
                GalleryApplicationResult app = webServer.GetGalleryApplication(webAppId);
                if (!app.IsSuccess)
                {
                    return(Error <StringResultObject>(app, GalleryErrors.GeneralError));
                }
                if (app.Value == null)
                {
                    return(Error <StringResultObject>(GalleryErrors.WebApplicationNotFound, webAppId));
                }
                #endregion

                #region Trace app details

                // Assign web app pack title to the currently running task
                TaskManager.ItemName = app.Value.Title;

                // Trace additional details from the feed
                TaskManager.WriteParameter("Title", app.Value.Title);
                TaskManager.WriteParameter("Version", app.Value.Version);
                TaskManager.WriteParameter("Download URL", app.Value.DownloadUrl);
                TaskManager.WriteParameter("Author", app.Value.AuthorName);
                TaskManager.WriteParameter("Last Updated", app.Value.LastUpdated);

                // Trace out all deployment parameters
                Array.ForEach <DeploymentParameter>(parameters.ToArray(), p => TaskManager.WriteParameter(p.Name, p.Value));
                #endregion

                // elevate security context
                SecurityContext.SetThreadSupervisorPrincipal();

                #region Set AppPath
                // set correct application path
                DeploymentParameter appPath = FindParameterByTag(parameters, DeploymentParameterWellKnownTag.IisApp);
                if (appPath == null)
                {
                    return(Error <StringResultObject>(GalleryErrors.AppPathParameterNotFound));
                }

                appPath.Value = String.IsNullOrEmpty(virtualDir) ? siteName : String.Format("{0}/{1}", siteName, virtualDir);
                #endregion

                // database context
                // find database resource parameter
                DeploymentParameter databaseResoure = parameters.Find(p =>
                {
                    return(p.Name == DeploymentParameter.ResourceGroupParameterName);
                });

                // database is required for this application
                if (databaseResoure != null)
                {
                    // try to get database service
                    int dbServiceId = PackageController.GetPackageServiceId(packageId, databaseResoure.Value);
                    if (dbServiceId == 0)
                    {
                        return(Error <StringResultObject>(GalleryErrors.DatabaseServiceIsNotAvailable));
                    }

                    #region Setup Database server and DB Admin credentials
                    // get database service settings
                    StringDictionary dbSettings = ServerController.GetServiceSettingsAdmin(dbServiceId);

                    // database server
                    DeploymentParameter databaseServer = FindParameterByTag(parameters, DeploymentParameterWellKnownTag.DBServer);
                    if (databaseServer != null)
                    {
                        databaseServer.Value = dbSettings["ExternalAddress"];
                        if (String.IsNullOrEmpty(databaseServer.Value))
                        {
                            return(Error <StringResultObject>(GalleryErrors.DatabaseServerExternalAddressIsEmpty));
                        }
                    }

                    // database admin
                    DeploymentParameter databaseAdminUsername = FindParameterByTag(parameters, DeploymentParameterWellKnownTag.DBAdminUserName);
                    if (databaseAdminUsername != null)
                    {
                        databaseAdminUsername.Value = dbSettings["RootLogin"];
                        if (String.IsNullOrEmpty(databaseAdminUsername.Value))
                        {
                            databaseAdminUsername.Value = dbSettings["SaLogin"];
                        }

                        // raise error if database service is in Integrated Security mode (for SQL Server)
                        // or DB Admin username is not provided
                        if (String.IsNullOrEmpty(databaseAdminUsername.Value))
                        {
                            return(Error <StringResultObject>(GalleryErrors.DatabaseAdminUsernameNotSpecified));
                        }
                    }

                    // database admin password
                    DeploymentParameter databaseAdminPassword = FindParameterByTag(parameters, DeploymentParameterWellKnownTag.DBAdminPassword);
                    if (databaseAdminPassword != null)
                    {
                        databaseAdminPassword.Value = dbSettings["RootPassword"];
                        if (String.IsNullOrEmpty(databaseAdminPassword.Value))
                        {
                            databaseAdminPassword.Value = dbSettings["SaPassword"];
                        }

                        // raise error if database service is in Integrated Security mode (for SQL Server)
                        // or DB Admin password is not provided
                        if (String.IsNullOrEmpty(databaseAdminPassword.Value))
                        {
                            return(Error <StringResultObject>(GalleryErrors.DatabaseAdminPasswordNotSpecified));
                        }
                    }
                    #endregion

                    #region Create database and db user account if new selected

                    // create database
                    DeploymentParameter databaseName = FindParameterByTag(parameters, DeploymentParameterWellKnownTag.DBName);
                    if (databaseName != null)
                    {
                        SqlDatabase db = PackageController.GetPackageItemByName(packageId, databaseResoure.Value, databaseName.Value, typeof(SqlDatabase)) as SqlDatabase;

                        if (db == null)
                        {
                            try
                            {
                                db           = new SqlDatabase();
                                db.PackageId = packageId;
                                db.Name      = databaseName.Value;

                                // create
                                databaseResult = DatabaseServerController.AddSqlDatabase(db, databaseResoure.Value);
                                if (databaseResult < 0)
                                {
                                    result.ErrorCodes.Add((-databaseResult).ToString());
                                    return(Error <StringResultObject>(result, GalleryErrors.DatabaseCreationError));
                                }
                            }
                            catch (Exception ex)
                            {
                                // log exception
                                TaskManager.WriteError(ex);

                                // return error
                                return(Error <StringResultObject>(GalleryErrors.DatabaseCreationException));
                            }
                        }
                    }

                    // create database user
                    DeploymentParameter databaseUsername     = FindParameterByTag(parameters, DeploymentParameterWellKnownTag.DBUserName);
                    DeploymentParameter databaseUserPassword = FindParameterByTag(parameters, DeploymentParameterWellKnownTag.DBUserPassword);

                    if (databaseUsername != null && databaseUserPassword != null)
                    {
                        SqlUser user = PackageController.GetPackageItemByName(packageId, databaseResoure.Value, databaseUsername.Value, typeof(SqlUser)) as SqlUser;
                        //
                        if (user == null)
                        {
                            // create new user account
                            try
                            {
                                user           = new SqlUser();
                                user.PackageId = packageId;
                                user.Name      = databaseUsername.Value;
                                user.Databases = (databaseName != null) ? new string[] { databaseName.Value } : new string[0];
                                user.Password  = databaseUserPassword.Value;

                                // create
                                databaseUserResult = DatabaseServerController.AddSqlUser(user, databaseResoure.Value);

                                // check results
                                if (databaseUserResult < 0)
                                {
                                    // Rollback and remove db if created
                                    if (databaseResult > 0)
                                    {
                                        DatabaseServerController.DeleteSqlDatabase(databaseResult);
                                    }

                                    // raise error
                                    result.ErrorCodes.Add((-databaseUserResult).ToString());
                                    return(Error <StringResultObject>(result, GalleryErrors.DatabaseUserCreationError));
                                }
                            }
                            catch (Exception ex)
                            {
                                // log exception
                                TaskManager.WriteError(ex);

                                // return error
                                return(Error <StringResultObject>(GalleryErrors.DatabaseUserCreationException, ex.Message));
                            }
                        }
                        else
                        {
                            // check existing user account
                            DatabaseServer databaseService = DatabaseServerController.GetDatabaseServer(dbServiceId);
                            if (!databaseService.CheckConnectivity(databaseName.Value, databaseUsername.Value, databaseUserPassword.Value))
                            {
                                return(Error <StringResultObject>(GalleryErrors.DatabaseUserCannotAccessDatabase, databaseUsername.Value));
                            }
                        }
                    }
                    #endregion

                    // remove database resource parameter from the list
                    // before calling "install" method
                    parameters.Remove(databaseResoure);
                }

                // install application
                result = webServer.InstallGalleryApplication(webAppId, parameters.ToArray());

                #region Rollback in case of failure
                // Rollback - remove resources have been created previously
                if (!result.IsSuccess)
                {
                    // delete database
                    if (databaseUserResult > 0)
                    {
                        DatabaseServerController.DeleteSqlUser(databaseUserResult);
                    }

                    // delete database user
                    if (databaseResult > 0)
                    {
                        DatabaseServerController.DeleteSqlDatabase(databaseResult);
                    }

                    // exit with errors
                    return(Error <StringResultObject>(result, GalleryErrors.ApplicationInstallationError));
                }
                #endregion

                #region Update Web Application settings

                WebVirtualDirectory iisApp = null;
                if (String.IsNullOrEmpty(virtualDir))
                {
                    // load web site
                    iisApp = WebServerController.GetWebSite(packageId, siteName);
                }
                else
                {
                    // load virtual directory
                    iisApp = WebServerController.GetVirtualDirectory(webSite.Id, virtualDir);
                }

                // put correct extensions
                if ((app.Value.WellKnownDependencies & GalleryApplicationWellKnownDependency.AspNet20) == GalleryApplicationWellKnownDependency.AspNet20)
                {
                    // ASP.NET 2.0
                    iisApp.AspNetInstalled = (iisApp.IIs7) ? "2I" : "2";
                    AddDefaultDocument(iisApp, "default.aspx");
                }
                else if ((app.Value.WellKnownDependencies & GalleryApplicationWellKnownDependency.AspNet40) == GalleryApplicationWellKnownDependency.AspNet40)
                {
                    // ASP.NET 4.0
                    iisApp.AspNetInstalled = (iisApp.IIs7) ? "4I" : "4";
                    AddDefaultDocument(iisApp, "default.aspx");
                }
                else if ((app.Value.WellKnownDependencies & GalleryApplicationWellKnownDependency.PHP) == GalleryApplicationWellKnownDependency.PHP)
                {
                    // PHP 5
                    iisApp.PhpInstalled = "5";
                    AddDefaultDocument(iisApp, "index.php");
                }

                // update web site or virtual directory
                int updateResult = 0;
                if (String.IsNullOrEmpty(virtualDir))
                {
                    // update web site
                    updateResult = WebServerController.UpdateWebSite(iisApp as WebSite);
                }
                else
                {
                    // update virtual directory
                    updateResult = WebServerController.UpdateVirtualDirectory(webSite.Id, iisApp);
                }

                if (updateResult < 0)
                {
                    TaskManager.WriteWarning("Cannot update website or virtual directory programming extensions and default documents. Result code: {0}", updateResult.ToString());
                }

                #endregion

                return(result);
            }
            catch (Exception ex)
            {
                // log error
                TaskManager.WriteError(ex);

                // exit with error code
                return(Error <StringResultObject>(GalleryErrors.GeneralError));
            }
            finally
            {
                TaskManager.CompleteTask();
            }
        }
 public SqlDatabase GetSqlDatabase(int itemId)
 {
     return(DatabaseServerController.GetSqlDatabase(itemId));
 }
示例#18
0
        public static int AddSite(SharePointSite item)
        {
            // check account
            int accountCheck = SecurityContext.CheckAccount(DemandAccount.NotDemo | DemandAccount.IsActive);

            if (accountCheck < 0)
            {
                return(accountCheck);
            }

            // check package
            int packageCheck = SecurityContext.CheckPackage(item.PackageId, DemandPackage.IsActive);

            if (packageCheck < 0)
            {
                return(packageCheck);
            }

            // check quota
            QuotaValueInfo quota = PackageController.GetPackageQuota(item.PackageId, Quotas.SHAREPOINT_SITES);

            if (quota.QuotaExhausted)
            {
                return(BusinessErrorCodes.ERROR_SHAREPOINT_RESOURCE_QUOTA_LIMIT);
            }

            // check if stats resource is available
            int serviceId = PackageController.GetPackageServiceId(item.PackageId, ResourceGroups.SharePoint);

            if (serviceId == 0)
            {
                return(BusinessErrorCodes.ERROR_SHAREPOINT_RESOURCE_UNAVAILABLE);
            }

            // check package items
            if (PackageController.GetPackageItemByName(item.PackageId, item.Name, typeof(SharePointSite)) != null)
            {
                return(BusinessErrorCodes.ERROR_SHAREPOINT_PACKAGE_ITEM_EXISTS);
            }

            // place log record
            TaskManager.StartTask("SHAREPOINT", "ADD_SITE", item.Name);
            TaskManager.WriteParameter("Database group", item.DatabaseGroupName);
            TaskManager.WriteParameter("Database name", item.DatabaseName);
            TaskManager.WriteParameter("Database user", item.DatabaseUser);

            int databaseItemId     = 0;
            int databaseUserItemId = 0;

            try
            {
                // load web site
                WebSite siteItem = (WebSite)PackageController.GetPackageItemByName(item.PackageId,
                                                                                   item.Name, typeof(WebSite));

                if (siteItem == null)
                {
                    return(BusinessErrorCodes.ERROR_WEB_SITE_SERVICE_UNAVAILABLE);
                }

                // get service web site
                WebServer web = new WebServer();
                ServiceProviderProxy.Init(web, siteItem.ServiceId);
                WebSite site = web.GetSite(siteItem.SiteId);

                /////////////////////////////////////////
                //
                //  PREPARE SHAREPOINT SITE INSTALLATION
                //

                ServiceInfo wssService = ServerController.GetServiceInfo(serviceId);
                bool        wss30      = (wssService.ProviderId == 23);     // WSS 3.0

                // remember original web site bindings
                ServerBinding[] bindings = site.Bindings;

                // set application pool and root folder
                item.ApplicationPool = site.ApplicationPool;
                item.RootFolder      = site.ContentPath;

                // change web site .NET framework if required
                bool siteUpdated = false;
                if (!wss30 && (site.AspNetInstalled != "1" ||
                               site.DedicatedApplicationPool))
                {
                    site.AspNetInstalled          = "1";
                    site.DedicatedApplicationPool = false;
                    web.UpdateSite(site);

                    siteUpdated = true;
                }

                if (wss30 && site.AspNetInstalled != "2")
                {
                    site.AspNetInstalled = "2";
                    web.UpdateSite(site);

                    siteUpdated = true;
                }

                if (siteUpdated)
                {
                    site = web.GetSite(siteItem.SiteId);
                    item.ApplicationPool = site.ApplicationPool;
                }

                if (site.FrontPageInstalled)
                {
                    // remove FrontPage
                    web.UninstallFrontPage(siteItem.SiteId, siteItem.FrontPageAccount);
                }

                // create SQL database
                SqlDatabase database = new SqlDatabase();
                database.PackageId = item.PackageId;
                database.Name      = item.DatabaseName;
                databaseItemId     = DatabaseServerController.AddSqlDatabase(database, item.DatabaseGroupName);
                if (databaseItemId < 0)
                {
                    return(databaseItemId);
                }

                // create SQL user
                SqlUser dbUser = new SqlUser();
                dbUser.PackageId   = item.PackageId;
                dbUser.Name        = item.DatabaseUser;
                dbUser.Password    = item.DatabasePassword;
                databaseUserItemId = DatabaseServerController.AddSqlUser(dbUser, item.DatabaseGroupName);
                if (databaseUserItemId < 0)
                {
                    return(databaseUserItemId);
                }

                // delete SQL database from service
                // and change database user role
                int sqlServiceId = PackageController.GetPackageServiceId(item.PackageId, item.DatabaseGroupName);
                if (sqlServiceId < 0)
                {
                    return(BusinessErrorCodes.ERROR_MSSQL_RESOURCE_UNAVAILABLE);
                }

                // load server settings
                StringDictionary sqlSettings = ServerController.GetServiceSettings(sqlServiceId);
                item.DatabaseServer = sqlSettings["ExternalAddress"];

                DatabaseServer dbServer = new DatabaseServer();
                ServiceProviderProxy.Init(dbServer, sqlServiceId);

                // delete database from service
                dbServer.DeleteDatabase(database.Name);

                // give SQL user "db_creator" role
                dbServer.ExecuteSqlNonQuery("master", String.Format(
                                                "sp_addsrvrolemember '{0}', 'dbcreator'\nGO", dbUser.Name));

                // install SharePoint site
                SharePointServer sps = GetSharePoint(serviceId);
                sps.ExtendVirtualServer(item);

                // remove SQL user from "db_creator" role
                dbServer.ExecuteSqlNonQuery("master", String.Format(
                                                "sp_dropsrvrolemember '{0}', 'dbcreator'\nGO", dbUser.Name));

                // restore original web site bindings
                web.UpdateSiteBindings(site.SiteId, bindings);

                // 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 int AddSqlDatabase(SqlDatabase item, string groupName)
 {
     return(DatabaseServerController.AddSqlDatabase(item, groupName));
 }
示例#20
0
        public static StringResultObject Install(int packageId, string webAppId, string siteName, string virtualDir, List <DeploymentParameter> updatedParameters)
        {
            StringResultObject result = new StringResultObject();
            //
            int                 dbItemResult = -1, dbUserResult = -1;
            WebSite             webSite       = default(WebSite);
            WebVirtualDirectory webVirtualDir = default(WebVirtualDirectory);
            WebVirtualDirectory iisAppNode    = default(WebVirtualDirectory);

            //
            try
            {
                SecurityContext.SetThreadSupervisorPrincipal();
                //
                TaskManager.StartTask(TASK_MANAGER_SOURCE, "INSTALL_WEB_APP");
                //
                TaskManager.WriteParameter("Package ID", packageId);
                TaskManager.WriteParameter("Site Name", siteName);

                //
                WebServer webServer = GetAssociatedWebServer(packageId);

                // ERROR: WAG is not available
                if (!webServer.IsMsDeployInstalled())
                {
                    return(WAG_MODULE_NOT_AVAILABLE <StringResultObject>());
                }

                //
                GalleryApplicationResult appResult = webServer.GetGalleryApplication(webAppId);

                #region Preparations and tracing
                // Trace at least Web Application Id for troubleshooting purposes
                if (!appResult.IsSuccess || appResult.Value == null)
                {
                    TaskManager.WriteError("Could not find an application to install with ID: {0}.", webAppId);
                    //
                    return(WAG_INSTALL_GENERIC_MODULE_ERROR <StringResultObject>());
                }
                // Assign web app pack title to the currently running task
                TaskManager.ItemName = appResult.Value.Title;
                // Trace additional details from the feed
                TraceGalleryAppPackInfo(appResult.Value);

                // Trace out all deployment parameters
                Array.ForEach <DeploymentParameter>(updatedParameters.ToArray(), p => TaskManager.WriteParameter(p.Name, p.Value));
                // Check account
                int accountCheck = SecurityContext.CheckAccount(DemandAccount.NotDemo | DemandAccount.IsActive);
                if (accountCheck < 0)
                {
                    TaskManager.WriteError("Account check has been failed. Status: {0};", accountCheck.ToString());
                    //
                    return(WAG_INSTALL_GENERIC_MODULE_ERROR <StringResultObject>());
                }
                // Check package
                int packageCheck = SecurityContext.CheckPackage(packageId, DemandPackage.IsActive);
                if (packageCheck < 0)
                {
                    TaskManager.WriteError("Package check has been failed. Status: {0};", packageCheck.ToString());
                    //
                    return(WAG_INSTALL_GENERIC_MODULE_ERROR <StringResultObject>());
                }
                // Check web site for existence
                webSite = WebServerController.GetWebSite(packageId, siteName);
                if (webSite == null)
                {
                    TaskManager.WriteError("Web site check has been failed. Status: {0};", BusinessErrorCodes.ERROR_WEB_INSTALLER_WEBSITE_NOT_EXISTS.ToString());
                    //
                    return(WAG_INSTALL_GENERIC_MODULE_ERROR <StringResultObject>());
                }
                #endregion

                DeploymentParametersResult appParamsResult = GetGalleryApplicationParamsInternally(packageId, webAppId);

                //
                if (!appParamsResult.IsSuccess)
                {
                    foreach (string errorMessage in appParamsResult.ErrorCodes)
                    {
                        TaskManager.WriteError(errorMessage);
                    }
                    //
                    return(WAG_INSTALL_GENERIC_MODULE_ERROR <StringResultObject>());
                }

                List <DeploymentParameter> origParams = appParamsResult.Value;
                //
                if (Array.Exists <DeploymentParameter>(origParams.ToArray(),
                                                       p => MatchParameterTag(p, DeploymentParameter.SQL_PARAM_TAG) ||
                                                       MatchParameterTag(p, DeploymentParameter.MYSQL_PARAM_TAG)))
                {
                    // Match input parameters from the client
                    DeploymentParameter dbNameParam = Array.Find <DeploymentParameter>(updatedParameters.ToArray(),
                                                                                       p => MatchParameterByNames(p, DeploymentParameter.DATABASE_NAME_PARAMS) ||
                                                                                       MatchParameterTag(p, DeploymentParameter.DB_NAME_PARAM_TAG));
                    //
                    DeploymentParameter dbUserParam = Array.Find <DeploymentParameter>(updatedParameters.ToArray(),
                                                                                       p => MatchParameterByNames(p, DeploymentParameter.DATABASE_USERNAME_PARAMS) ||
                                                                                       MatchParameterTag(p, DeploymentParameter.DB_USERNAME_PARAM_TAG));
                    //
                    DeploymentParameter dbUserPwParam = Array.Find <DeploymentParameter>(updatedParameters.ToArray(),
                                                                                         p => MatchParameterByNames(p, DeploymentParameter.DATABASE_USERPWD_PARAMS) ||
                                                                                         MatchParameterTag(p, DeploymentParameter.DB_PASSWORD_PARAM_TAG));

                    #region Pre-conditions verification...
                    //
                    if (dbNameParam == null)
                    {
                        //
                        TaskManager.WriteError(PARAMETER_IS_NULL_OR_EMPTY, DeploymentParameter.DATABASE_NAME_PARAM);
                        //
                        return(WAG_INSTALL_GENERIC_MODULE_ERROR <StringResultObject>());
                    }
                    //
                    if (String.IsNullOrEmpty(dbNameParam.Tags))
                    {
                        //
                        TaskManager.WriteError("{0} parameter tags does not contain information about the database resource group should be used", DeploymentParameter.DATABASE_NAME_PARAM);
                        //
                        return(WAG_INSTALL_GENERIC_MODULE_ERROR <StringResultObject>());
                    }
                    //
                    int dbServiceId = PackageController.GetPackageServiceId(packageId, dbNameParam.Tags);
                    //
                    if (dbServiceId <= 0)
                    {
                        //
                        TaskManager.WriteError("{0} parameter tags contains wrong information about the database resource group should be used. Resource group: " + dbNameParam.Tags, DeploymentParameter.DATABASE_NAME_PARAM);
                        //
                        return(WAG_INSTALL_GENERIC_MODULE_ERROR <StringResultObject>());
                    }
                    #endregion
                    //
                    DeploymentParameter dbServerParam = Array.Find <DeploymentParameter>(origParams.ToArray(),
                                                                                         p => MatchParameterByNames(p, DeploymentParameter.DB_SERVER_PARAMS) ||
                                                                                         MatchParameterTag(p, DeploymentParameter.DB_SERVER_PARAM_TAG));
                    //
                    DeploymentParameter dbAdminParam = Array.Find <DeploymentParameter>(origParams.ToArray(),
                                                                                        p => MatchParameterByNames(p, DeploymentParameter.DB_ADMIN_PARAMS) ||
                                                                                        MatchParameterTag(p, DeploymentParameter.DB_ADMIN_USERNAME_PARAM_TAG));
                    //
                    DeploymentParameter dbAdminPwParam = Array.Find <DeploymentParameter>(origParams.ToArray(),
                                                                                          p => MatchParameterByNames(p, DeploymentParameter.DB_ADMINPWD_PARAMS) ||
                                                                                          MatchParameterTag(p, DeploymentParameter.DB_ADMIN_PASSWORD_PARAM_TAG));

                    #region Pre-conditions verification...
                    //
                    if (dbAdminParam == null)
                    {
                        //
                        TaskManager.WriteError(NO_DB_PARAMETER_MATCHES_MSG, NAMES_MATCH,
                                               String.Join(", ", DeploymentParameter.DB_ADMIN_PARAMS));
                        //
                        return(WAG_INSTALL_GENERIC_MODULE_ERROR <StringResultObject>());
                    }
                    //
                    if (dbServerParam == null)
                    {
                        //
                        TaskManager.WriteError(NO_DB_PARAMETER_MATCHES_MSG, NAMES_MATCH,
                                               String.Join(", ", DeploymentParameter.DB_SERVER_PARAMS));
                        //
                        return(WAG_INSTALL_GENERIC_MODULE_ERROR <StringResultObject>());
                    }
                    //
                    if (dbAdminPwParam == null)
                    {
                        //
                        TaskManager.WriteError(NO_DB_PARAMETER_MATCHES_MSG, NAMES_MATCH,
                                               String.Join(", ", DeploymentParameter.DB_ADMINPWD_PARAMS));
                        //
                        return(WAG_INSTALL_GENERIC_MODULE_ERROR <StringResultObject>());
                    }
                    #endregion

                    #region Read & substitute database server settings
                    //
                    StringDictionary dbSettings = ServerController.GetServiceSettingsAdmin(dbServiceId);

                    // InternalAddress setting is common for all DB service providers
                    dbServerParam.Value = dbSettings["InternalAddress"];
                    // Set database administrator login
                    if (!String.IsNullOrEmpty(dbSettings["RootLogin"]))
                    {
                        dbAdminParam.Value = dbSettings["RootLogin"];
                    }
                    else if (!String.IsNullOrEmpty(dbSettings["SaLogin"]))
                    {
                        dbAdminParam.Value = dbSettings["SaLogin"];
                    }
                    else
                    {
                        //
                        TaskManager.WriteError(CANNOT_SET_PARAMETER_VALUE, dbAdminParam.Name);
                        //
                        return(WAG_INSTALL_GENERIC_MODULE_ERROR <StringResultObject>());
                    }
                    // Set database administrator password
                    if (!String.IsNullOrEmpty(dbSettings["RootPassword"]))
                    {
                        dbAdminPwParam.Value = dbSettings["RootPassword"];
                    }
                    else if (!String.IsNullOrEmpty(dbSettings["SaPassword"]))
                    {
                        dbAdminPwParam.Value = dbSettings["SaPassword"];
                    }
                    else
                    {
                        //
                        TaskManager.WriteError(CANNOT_SET_PARAMETER_VALUE, dbAdminPwParam.Name);
                        //
                        return(WAG_INSTALL_GENERIC_MODULE_ERROR <StringResultObject>());
                    }
                    #endregion

                    //
                    updatedParameters.AddRange(new List <DeploymentParameter> {
                        dbServerParam, dbAdminParam, dbAdminPwParam
                    });

                    #region Create database and db user account if new selected
                    //
                    SqlDatabase db = PackageController.GetPackageItemByName(packageId, dbNameParam.Value,
                                                                            typeof(SqlDatabase)) as SqlDatabase;
                    //
                    if (db == null)
                    {
                        db           = new SqlDatabase();
                        db.PackageId = packageId;
                        db.Name      = dbNameParam.Value;
                        //
                        dbItemResult = DatabaseServerController.AddSqlDatabase(db, dbNameParam.Tags);
                        //
                        if (dbItemResult < 0)
                        {
                            // Put specific error message into the trace log
                            TaskManager.WriteError("Could not create {0} database. Error code: {1}.", dbNameParam.Tags, dbItemResult.ToString());
                            // Return generic error
                            return(WAG_INSTALL_GENERIC_MODULE_ERROR <StringResultObject>());
                        }
                    }

                    //
                    SqlUser user = PackageController.GetPackageItemByName(packageId, dbUserParam.Value,
                                                                          typeof(SqlUser)) as SqlUser;
                    //
                    if (user == null)
                    {
                        user           = new SqlUser();
                        user.PackageId = packageId;
                        user.Name      = dbUserParam.Value;
                        user.Databases = new string[] { dbNameParam.Value };
                        user.Password  = dbUserPwParam.Value;
                        //
                        dbUserResult = DatabaseServerController.AddSqlUser(user, dbNameParam.Tags);
                        //
                        if (dbUserResult < 0)
                        {
                            // Rollback and remove db if created
                            if (dbItemResult > 0)
                            {
                                DatabaseServerController.DeleteSqlDatabase(dbItemResult);
                            }
                            // Put specific error message into the trace log
                            TaskManager.WriteError("Could not create {0} user account. Error code: {1}.", dbNameParam.Tags, dbUserResult.ToString());
                            // Return generic error
                            return(WAG_INSTALL_GENERIC_MODULE_ERROR <StringResultObject>());
                        }
                    }
                    #endregion
                }

                //
                DeploymentParameter appPathParam = Array.Find <DeploymentParameter>(origParams.ToArray(),
                                                                                    p => MatchParameterName(p, DeploymentParameter.APPICATION_PATH_PARAM) ||
                                                                                    MatchParameterTag(p, DeploymentParameter.IISAPP_PARAM_TAG));
                //
                if (String.IsNullOrEmpty(virtualDir))
                {
                    appPathParam.Value = siteName;
                }
                else
                {
                    appPathParam.Value = String.Format("{0}/{1}", siteName, virtualDir);
                }
                //
                updatedParameters.Add(appPathParam);

                //
                result = webServer.InstallGalleryApplication(webAppId, updatedParameters.ToArray());
                //
                #region Rollback in case of failure
                // Rollback - remove resources have been created previously
                if (!result.IsSuccess)
                {
                    //
                    if (dbUserResult > 0)
                    {
                        DatabaseServerController.DeleteSqlUser(dbUserResult);
                    }
                    //
                    if (dbItemResult > 0)
                    {
                        DatabaseServerController.DeleteSqlDatabase(dbItemResult);
                    }
                    //
                    foreach (string errorCode in result.ErrorCodes)
                    {
                        TaskManager.WriteError(errorCode);
                    }
                    //
                    return(result);
                }
                #endregion

                // Reload web site details
                webSite = WebServerController.GetWebSite(packageId, siteName);
                // Reload virtual directory defaults
                if (!String.IsNullOrEmpty(virtualDir))
                {
                    webVirtualDir = WebServerController.GetVirtualDirectory(webSite.Id, virtualDir);
                }

                // We are going to install application on website or virtual directory
                iisAppNode = (webVirtualDir != null) ? webVirtualDir : webSite;
                // Put correct ASP.NET version depending on a web server's version
                iisAppNode.AspNetInstalled = (iisAppNode.IIs7) ? "2I" : "2";

                //
                if (MatchParticularAppDependency(appResult.Value.Dependency, SupportedAppDependencies.PHP_SCRIPTING))
                {
                    // Enable PHP 5 extensions for web site
                    iisAppNode.PhpInstalled = "5";
                    // Set the correct default document for PHP apps
                    if (iisAppNode.DefaultDocs.IndexOf("index.php", StringComparison.InvariantCultureIgnoreCase) == -1)
                    {
                        iisAppNode.DefaultDocs += ",index.php";
                    }
                    //
                    int docsResult = 0;
                    //
                    if (webVirtualDir == null)
                    {
                        docsResult = WebServerController.UpdateWebSite(webSite);
                    }
                    else
                    {
                        docsResult = WebServerController.UpdateVirtualDirectory(webSite.Id, webVirtualDir);
                    }
                    //
                    if (docsResult < 0)
                    {
                        TaskManager.WriteWarning("Could not update website/virtual directory default documents with the value of index.php. Result code: {0}", docsResult.ToString());
                    }
                }
                //
                if (MatchParticularAppDependency(appResult.Value.Dependency, SupportedAppDependencies.ASPNET_SCRIPTING))
                {
                    // Set the correct default document for ASP.NET apps
                    if (iisAppNode.DefaultDocs.IndexOf("Default.aspx", StringComparison.InvariantCultureIgnoreCase) == -1)
                    {
                        iisAppNode.DefaultDocs += ",Default.aspx";
                    }
                    //
                    int aspnetResult = 0;
                    //
                    if (webVirtualDir == null)
                    {
                        aspnetResult = WebServerController.UpdateWebSite(webSite);
                    }
                    else
                    {
                        aspnetResult = WebServerController.UpdateVirtualDirectory(webSite.Id, webVirtualDir);
                    }
                    //
                    if (aspnetResult < 0)
                    {
                        TaskManager.WriteWarning("Could not set default documents/enable ASP.NET 2.0 (Integrated Mode) for website/virtual directory. Result code: {0}", aspnetResult.ToString());
                    }
                }

                //
                return(result);
            }
            catch (Exception ex)
            {
                //
                TaskManager.WriteError(ex);
                //
                return(WAG_INSTALL_GENERIC_MODULE_ERROR <StringResultObject>());
            }
            finally
            {
                TaskManager.CompleteTask();
            }
        }
 public byte[] GetSqlBackupBinaryChunk(int itemId, string path, int offset, int length)
 {
     return(DatabaseServerController.GetSqlBackupBinaryChunk(itemId, path, offset, length));
 }