Beispiel #1
0
        private void MakeVisibleInWsusConsole(IUpdate PublishedUpdate)
        {
            Logger.EnteringMethod();
            SqlHelper sqlHelper       = SqlHelper.GetInstance();
            string    sqlServerName   = _wsus.GetSqlServerName();
            string    sqlDataBaseName = _wsus.GetSqlDataBaseName();

            System.Version wsusVersion = _wsus.GetServerVersion();

            if (PublishedUpdate == null)
            {
                return;
            }

            if (sqlServerName.Contains("MICROSOFT##SSEE") || sqlServerName.Contains("MICROSOFT##WID"))
            {
                if (wsusVersion.Major == 3)
                {
                    sqlHelper.ServerName = @"\\.\pipe\MSSQL$MICROSOFT##SSEE\sql\query";
                }
                if (wsusVersion.Major == 6)
                {
                    sqlHelper.ServerName = @"\\.\pipe\Microsoft##WID\tsql\query";
                }
                sqlHelper.DataBaseName = "SUSDB";
            }
            else
            {
                sqlHelper.ServerName   = _wsus.GetSqlServerName();
                sqlHelper.DataBaseName = _wsus.GetSqlDataBaseName();
            }
            Logger.Write(sqlHelper.ServerName);
            Logger.Write(sqlHelper.DataBaseName);
            if (sqlHelper.Connect(string.Empty, string.Empty))
            {
                Logger.Write("Connected to SQL.");
                List <Guid> updateIDs = new List <Guid>();

                updateIDs.Add(PublishedUpdate.Id.UpdateId);
                UpdateCategoryCollection categories = PublishedUpdate.GetUpdateCategories();
                foreach (IUpdateCategory category in categories)
                {
                    if (!updateIDs.Contains(category.Id))
                    {
                        updateIDs.Add(category.Id);
                    }
                    if (category.ProhibitsSubcategories && !category.ProhibitsUpdates)
                    {
                        IUpdateCategory parentCategory = category.GetParentUpdateCategory();
                        if (!updateIDs.Contains(parentCategory.Id))
                        {
                            updateIDs.Add(parentCategory.Id);
                        }
                    }
                }

                sqlHelper.ShowUpdatesInConsole(updateIDs);
                sqlHelper.Disconnect();
            }
        }
Beispiel #2
0
        /// <summary>
        /// Gets a list of update categories by searching for the guids specified in the config
        /// </summary>
        /// <param name="server">
        /// wsus server connection
        /// </param>
        /// <param name="products">
        /// list of product guids from config
        /// </param>
        /// <returns>
        /// collection of update categories
        /// </returns>
        private static UpdateCategoryCollection GetUpdateCategoryCollection(
            IUpdateServer server,
            ProductCollection products)
        {
            if (products == null)
            {
                throw new ArgumentNullException("products");
            }

            if (products.Count < 1)
            {
                throw new ArgumentException("products has no product items.");
            }

            var result = new UpdateCategoryCollection();

            foreach (Product product in products)
            {
                IUpdateCategory category = server.GetUpdateCategory(product.Guid);

                result.Add(category);
            }

            return(result);
        }
Beispiel #3
0
        /// <summary>
        /// checks for superseded updates and approves the new revision
        /// </summary>
        /// <param name="server">
        /// The WSUS Server
        /// </param>
        /// <param name="approveLicenseAgreement">
        /// Whether to approve any license agreement
        /// </param>
        /// <param name="computerTargetGroup">
        /// The target group to check
        /// </param>
        /// <param name="classification">
        /// Classification to process
        /// </param>
        /// <param name="products">
        /// Collection of products to process
        /// </param>
        /// <param name="isTest">
        /// Whether we are in test mode
        /// </param>
        /// <param name="shouldApproveUninstalledSupersededUpdate">
        /// The should Approve Uninstalled Superseded Update.
        /// </param>
        private static void CheckSupersededUpdates(
            IUpdateServer server,
            bool approveLicenseAgreement,
            IComputerTargetGroup computerTargetGroup,
            IUpdateClassification classification,
            UpdateCategoryCollection products,
            bool isTest,
            bool shouldApproveUninstalledSupersededUpdate)
        {
            var searchScope = new UpdateScope {
                ApprovedStates = ApprovedStates.HasStaleUpdateApprovals
            };

            if (computerTargetGroup != null)
            {
                searchScope.ApprovedComputerTargetGroups.Add(computerTargetGroup);
            }

            if (classification != null)
            {
                searchScope.Classifications.Add(classification);
            }

            if (products != null)
            {
                searchScope.Categories.AddRange(products);
            }

            UpdateCollection updates = server.GetUpdates(searchScope);

            if (updates.Count <= 0)
            {
                return;
            }

            var recentlyApproved = new List <Guid>();

            if (updates.Count == 0)
            {
                Console.Out.WriteLine(" No updates required.");
                return;
            }

            foreach (IUpdate update in updates)
            {
                if (update.IsSuperseded)
                {
                    CheckSupersededUpdate(
                        update,
                        approveLicenseAgreement,
                        isTest,
                        recentlyApproved,
                        shouldApproveUninstalledSupersededUpdate);
                }
            }
        }
Beispiel #4
0
        private int NumberOfVisibleCategory(UpdateCategoryCollection updateCategoryCollection)
        {
            Logger.EnteringMethod();
            int number = 0;

            foreach (IUpdateCategory category in updateCategoryCollection)
            {
                if (category.UpdateSource == UpdateSource.MicrosoftUpdate)
                {
                    number++;
                }
            }
            Logger.Write("Returning " + number.ToString());
            return(number);
        }
Beispiel #5
0
        /// <summary>
        /// The do run set classification.
        /// </summary>
        /// <param name="server">
        /// Object representing the WSUS server
        /// </param>
        /// <param name="computerTargetGroup">
        /// The target group to check
        /// </param>
        /// <param name="classification">
        /// </param>
        /// <param name="isTest">
        /// Whether we are in test mode
        /// </param>
        /// <param name="alreadyProcessed">
        /// List of target groups that have already been processed
        /// </param>
        private static void DoRunSetClassification(
            IUpdateServer server,
            IComputerTargetGroup computerTargetGroup,
            Classification classification,
            bool isTest,
            List <IComputerTargetGroup> alreadyProcessed)
        {
            // check the classification exists on wsus
            IUpdateClassification uc = server.GetUpdateClassification(classification.Guid);

            // check for a product collection
            UpdateCategoryCollection products = classification.Products.ElementInformation.IsPresent
                                                    ? GetUpdateCategoryCollection(server, classification.Products)
                                                    : null;

            if (classification.ApproveStaleUpdates)
            {
                CheckStaleUpdates(
                    server,
                    classification.AcceptLicenseAgreement,
                    computerTargetGroup,
                    uc,
                    products,
                    isTest);
            }

            if (classification.ApproveSupersededUpdates)
            {
                CheckSupersededUpdates(
                    server,
                    classification.AcceptLicenseAgreement,
                    computerTargetGroup,
                    uc,
                    products,
                    isTest,
                    classification.ShouldApproveUninstalledSupersededUpdate);
            }

            if (classification.ApproveNeededUpdates)
            {
                CheckClassification(server, uc, computerTargetGroup, isTest, alreadyProcessed);
            }
        }
Beispiel #6
0
        /// <summary>
        /// Checks for updates that may have a new revision
        /// </summary>
        /// <param name="server">
        /// The WSUS Server
        /// </param>
        /// <param name="approveLicenseAgreement">
        /// Whether to approve any license agreement
        /// </param>
        /// <param name="computerTargetGroup">
        /// The target group to check
        /// </param>
        /// <param name="classifications">
        /// Classification to process
        /// </param>
        /// <param name="products">
        /// Collection of products to process
        /// </param>
        /// <param name="isTest">
        /// Whether we are in test mode
        /// </param>
        private static void CheckStaleUpdates(
            IUpdateServer server,
            bool approveLicenseAgreement,
            IComputerTargetGroup computerTargetGroup,
            IUpdateClassification classifications,
            UpdateCategoryCollection products,
            bool isTest)
        {
            var searchScope = new UpdateScope {
                ApprovedStates = ApprovedStates.HasStaleUpdateApprovals
            };

            if (computerTargetGroup != null)
            {
                searchScope.ApprovedComputerTargetGroups.Add(computerTargetGroup);
            }

            if (classifications != null)
            {
                searchScope.Classifications.Add(classifications);
            }

            if (products != null)
            {
                searchScope.Categories.AddRange(products);
            }

            UpdateCollection updates = server.GetUpdates(searchScope);

            if (updates.Count > 0)
            {
                foreach (IUpdate update in updates)
                {
                    CheckStaleUpdate(update, isTest, approveLicenseAgreement);
                }
            }
            else
            {
                Console.Out.WriteLine(" No updates required.");
            }
        }
Beispiel #7
0
        private static UpdateCollection getUpdates()
        {
            Console.WriteLine("Getting updates from WSUS..");
            IUpdateServer            server     = AdminProxy.GetUpdateServer("localhost", false, 8530);
            UpdateScope              scope      = new UpdateScope();
            UpdateCategoryCollection categories = server.GetUpdateCategories();

            foreach (IUpdateCategory cat in categories)
            {
                if (cat.Description.Contains("10"))
                {
                    Console.WriteLine(cat.Description);
                    scope.Categories.Add(cat);
                }
            }

            int updateCount = server.GetUpdateCount(scope);

            Console.WriteLine($"Updates found: {updateCount}");

            UpdateCollection updates = server.GetUpdates(scope);

            return(updates);
        }
Beispiel #8
0
        /// <summary>
        /// checks for superseded updates and approves the new revision
        /// </summary>
        /// <param name="server">
        /// The WSUS Server
        /// </param>
        /// <param name="approveLicenseAgreement">
        /// Whether to approve any license agreement
        /// </param>
        /// <param name="computerTargetGroup">
        /// The target group to check
        /// </param>
        /// <param name="classification">
        /// Classification to process
        /// </param>
        /// <param name="products">
        /// Collection of products to process
        /// </param>
        /// <param name="isTest">
        /// Whether we are in test mode
        /// </param>
        /// <param name="shouldApproveUninstalledSupersededUpdate">
        /// The should Approve Uninstalled Superseded Update.
        /// </param>
        private static void CheckSupersededUpdates(
            IUpdateServer server,
            bool approveLicenseAgreement,
            IComputerTargetGroup computerTargetGroup,
            IUpdateClassification classification,
            UpdateCategoryCollection products,
            bool isTest,
            bool shouldApproveUninstalledSupersededUpdate)
        {
            var searchScope = new UpdateScope { ApprovedStates = ApprovedStates.HasStaleUpdateApprovals };

            if (computerTargetGroup != null)
            {
                searchScope.ApprovedComputerTargetGroups.Add(computerTargetGroup);
            }

            if (classification != null)
            {
                searchScope.Classifications.Add(classification);
            }

            if (products != null)
            {
                searchScope.Categories.AddRange(products);
            }

            UpdateCollection updates = server.GetUpdates(searchScope);

            if (updates.Count <= 0)
            {
                return;
            }

            var recentlyApproved = new List<Guid>();

            if (updates.Count == 0)
            {
                Console.Out.WriteLine(" No updates required.");
                return;
            }

            foreach (IUpdate update in updates)
            {
                if (update.IsSuperseded)
                {
                    CheckSupersededUpdate(
                        update,
                        approveLicenseAgreement,
                        isTest,
                        recentlyApproved,
                        shouldApproveUninstalledSupersededUpdate);
                }
            }
        }
Beispiel #9
0
        /// <summary>
        /// Checks for updates that may have a new revision
        /// </summary>
        /// <param name="server">
        /// The WSUS Server
        /// </param>
        /// <param name="approveLicenseAgreement">
        /// Whether to approve any license agreement
        /// </param>
        /// <param name="computerTargetGroup">
        /// The target group to check
        /// </param>
        /// <param name="classifications">
        /// Classification to process
        /// </param>
        /// <param name="products">
        /// Collection of products to process
        /// </param>
        /// <param name="isTest">
        /// Whether we are in test mode
        /// </param>
        private static void CheckStaleUpdates(
            IUpdateServer server,
            bool approveLicenseAgreement,
            IComputerTargetGroup computerTargetGroup,
            IUpdateClassification classifications,
            UpdateCategoryCollection products,
            bool isTest)
        {
            var searchScope = new UpdateScope { ApprovedStates = ApprovedStates.HasStaleUpdateApprovals };

            if (computerTargetGroup != null)
            {
                searchScope.ApprovedComputerTargetGroups.Add(computerTargetGroup);
            }

            if (classifications != null)
            {
                searchScope.Classifications.Add(classifications);
            }

            if (products != null)
            {
                searchScope.Categories.AddRange(products);
            }

            UpdateCollection updates = server.GetUpdates(searchScope);

            if (updates.Count > 0)
            {
                foreach (IUpdate update in updates)
                {
                    CheckStaleUpdate(update, isTest, approveLicenseAgreement);
                }
            }
            else
            {
                Console.Out.WriteLine(" No updates required.");
            }
        }
Beispiel #10
0
        /// <summary>
        /// Gets a list of update categories by searching for the guids specified in the config
        /// </summary>
        /// <param name="server">
        /// wsus server connection
        /// </param>
        /// <param name="products">
        /// list of product guids from config
        /// </param>
        /// <returns>
        /// collection of update categories
        /// </returns>
        private static UpdateCategoryCollection GetUpdateCategoryCollection(
            IUpdateServer server,
            ProductCollection products)
        {
            if (products == null)
            {
                throw new ArgumentNullException("products");
            }

            if (products.Count < 1)
            {
                throw new ArgumentException("products has no product items.");
            }

            var result = new UpdateCategoryCollection();

            foreach (Product product in products)
            {
                IUpdateCategory category = server.GetUpdateCategory(product.Guid);

                result.Add(category);
            }

            return result;
        }
Beispiel #11
0
        private void ChangeVisibiltyInWsusConsole(UpdateCollection updates, int status)
        {
            Logger.EnteringMethod();
            SqlHelper   sqlHelper       = SqlHelper.GetInstance();
            List <Guid> updateIDs       = new List <Guid>();
            string      sqlServerName   = _wsus.GetSqlServerName();
            string      sqlDataBaseName = _wsus.GetSqlDataBaseName();

            System.Version wsusVersion = _wsus.GetServerVersion();

            if (sqlServerName.Contains("MICROSOFT##SSEE") || sqlServerName.Contains("MICROSOFT##WID"))
            {
                if (wsusVersion.Major == 3)
                {
                    sqlHelper.ServerName = @"\\.\pipe\MSSQL$MICROSOFT##SSEE\sql\query";
                }
                if (wsusVersion.Major == 6)
                {
                    sqlHelper.ServerName = @"\\.\pipe\Microsoft##WID\tsql\query";
                }
                sqlHelper.DataBaseName = "SUSDB";
            }
            else
            {
                sqlHelper.ServerName   = _wsus.GetSqlServerName();
                sqlHelper.DataBaseName = _wsus.GetSqlDataBaseName();
            }

            if (sqlHelper.Connect(string.Empty, string.Empty))
            {
                foreach (IUpdate update in updates)
                {
                    updateIDs.Add(update.Id.UpdateId);
                    if (status == 0)
                    {
                        sqlHelper.ShowUpdatesInConsole(updateIDs);
                    }
                    if (status == 1)
                    {
                        sqlHelper.HideUpdatesInConsole(updateIDs);
                    }
                }

                updateIDs.Clear();
                foreach (IUpdate update in updates)
                {
                    UpdateCategoryCollection categories = update.GetUpdateCategories();
                    foreach (IUpdateCategory category in categories)
                    {
                        if (!updateIDs.Contains(category.Id) && (status == 0 || NumberOfVisibleUpdate(category.GetUpdates()) == 0))
                        {
                            updateIDs.Add(category.Id);
                            if (category.ProhibitsSubcategories && !category.ProhibitsUpdates)
                            {
                                IUpdateCategory parentCategory = category.GetParentUpdateCategory();
                                if (!updateIDs.Contains(parentCategory.Id) && (status == 0 || NumberOfVisibleCategory(parentCategory.GetSubcategories()) == 1))
                                {
                                    updateIDs.Add(parentCategory.Id);
                                }
                            }
                        }
                    }
                }

                if (status == 0)
                {
                    sqlHelper.ShowUpdatesInConsole(updateIDs);
                }
                if (status == 1)
                {
                    sqlHelper.HideUpdatesInConsole(updateIDs);
                }
                sqlHelper.Disconnect();
            }
        }