/// <summary>
        /// Sets up or cleans up two types of networks -
        /// 1) Open Network
        /// 2) Isolated Network
        /// </summary>
        private void ManageNetworks(DeploymentParameters parameters, ClusterManifestType clusterManifest, Infrastructure infrastructure)
        {
            #region Container Network Setup

            if (parameters.ContainerNetworkSetup)
            {
                var containerNetworkSetupOperation = new ContainerNetworkSetupOperation();
                containerNetworkSetupOperation.ExecuteOperation(parameters, clusterManifest, infrastructure);
            }
            else
            {
                // Clean up docker network set up. This is needed for the SFRP scenario (there is no explicit uninstall)
                // when customers want to clean up container network set up through config upgrade.

                var containerServiceArguments = (parameters.UseContainerServiceArguments) ? (parameters.ContainerServiceArguments) : (FlatNetworkConstants.ContainerServiceArguments);

#if !DotNetCoreClrLinux
                containerServiceArguments = (parameters.EnableContainerServiceDebugMode)
                    ? (string.Format("{0} {1}", containerServiceArguments, FlatNetworkConstants.ContainerProviderServiceDebugModeArg)) : containerServiceArguments;

                // This check is needed to allow clean up on azure. This is symmetrical to the set up condition.
                if (clusterManifest.Infrastructure.Item is ClusterManifestTypeInfrastructureWindowsAzure ||
                    clusterManifest.Infrastructure.Item is ClusterManifestTypeInfrastructurePaaS)
                {
                    var containerNetworkCleanupOperation = new ContainerNetworkCleanupOperation();
                    containerNetworkCleanupOperation.ExecuteOperation(parameters.ContainerNetworkName, containerServiceArguments, parameters.FabricDataRoot, parameters.Operation);
                }
#else
                // This check is needed to disallow one box clean up on linux. This is symmetrical to the set up condition.
                // This was also needed because one box clean up resulted in an exception in the GetNetwork api.
                // Exception => System.Threading.Tasks.TaskCanceledException: A task was canceled
                if (clusterManifest.Infrastructure.Item is ClusterManifestTypeInfrastructurePaaS)
                {
                    var containerNetworkCleanupOperation = new ContainerNetworkCleanupOperation();
                    containerNetworkCleanupOperation.ExecuteOperation(parameters.ContainerNetworkName, containerServiceArguments, parameters.FabricDataRoot, parameters.Operation);
                }
#endif // !DotNetCoreClrLinux
            }

            #endregion

            #region Isolated Network Setup

            if (parameters.EnableUnsupportedPreviewFeatures)
            {
                if (parameters.IsolatedNetworkSetup)
                {
                    var isolatedNetworkSetupOperation = new IsolatedNetworkSetupOperation();
                    isolatedNetworkSetupOperation.ExecuteOperation(parameters, clusterManifest, infrastructure);
                }
                else
                {
                    var isolatedNetworkCleanupOperation = new IsolatedNetworkCleanupOperation();
                    isolatedNetworkCleanupOperation.ExecuteOperation(parameters.IsolatedNetworkName, parameters.FabricBinRoot, parameters.Operation);
                }
            }
            else
            {
                DeployerTrace.WriteInfo("Isolated Network preview feature disabled for the cluster.");
            }
            #endregion
        }
Beispiel #2
0
        /// <summary>
        /// CreateOrUpdate operation inherits from RestartOperation.
        /// This api will invoke network reset only in the restart case.
        /// </summary>
        /// <param name="clusterManifest"></param>
        private void ResetNetworks(DeploymentParameters parameters, ClusterManifestType clusterManifest, Infrastructure infrastructure)
        {
            if (parameters.Operation == DeploymentOperations.None)
            {
                var lastBootUpTimeFromRegistry = Utility.GetNodeLastBootUpTimeFromRegistry();
                var lastBootUpTimeFromSystem   = Utility.GetNodeLastBootUpTimeFromSystem();
                DeployerTrace.WriteInfo("Last boot up time from registry:{0} from system:{1}", lastBootUpTimeFromRegistry, lastBootUpTimeFromSystem);

                // This is a work around to handle the case where the flat network was not usable after VM reboot.
                #region Container Network Reset
                if (!parameters.SkipContainerNetworkResetOnReboot)
                {
                    if (!string.Equals(lastBootUpTimeFromRegistry.ToString(), lastBootUpTimeFromSystem.ToString(), StringComparison.OrdinalIgnoreCase))
                    {
                        DeployerTrace.WriteInfo("Invoking container network reset.");

                        var containerServiceArguments = (parameters.UseContainerServiceArguments) ? (parameters.ContainerServiceArguments) : (FlatNetworkConstants.ContainerServiceArguments);
                        containerServiceArguments = (parameters.EnableContainerServiceDebugMode)
                            ? (string.Format("{0} {1}", containerServiceArguments, FlatNetworkConstants.ContainerProviderServiceDebugModeArg))
                            : containerServiceArguments;

                        // This check is needed to allow clean up on azure. This is symmetrical to the set up condition.
                        if (clusterManifest.Infrastructure.Item is ClusterManifestTypeInfrastructureWindowsAzure ||
                            clusterManifest.Infrastructure.Item is ClusterManifestTypeInfrastructurePaaS)
                        {
                            var containerNetworkCleanupOperation = new ContainerNetworkCleanupOperation();
                            containerNetworkCleanupOperation.ExecuteOperation(parameters.ContainerNetworkName, containerServiceArguments, parameters.FabricDataRoot, parameters.Operation);
                        }

                        if (parameters.ContainerNetworkSetup)
                        {
                            // Set up docker network.
                            var containerNetworkSetupOperation = new ContainerNetworkSetupOperation();
                            containerNetworkSetupOperation.ExecuteOperation(parameters, clusterManifest, infrastructure);
                        }

                        // Record last boot up time.
                        Utility.SaveNodeLastBootUpTimeToRegistry(lastBootUpTimeFromSystem);
                    }
                }
                else
                {
                    DeployerTrace.WriteInfo("Skipping container network reset on reboot because SkipContainerNetworkResetOnReboot flag is enabled.");
                }
                #endregion

                // This is a work around to handle the case where the isolated network was not usable after VM reboot.
                #region Isolated Network Reset
                if (parameters.EnableUnsupportedPreviewFeatures)
                {
                    if (!parameters.SkipIsolatedNetworkResetOnReboot)
                    {
                        if (!string.Equals(lastBootUpTimeFromRegistry.ToString(), lastBootUpTimeFromSystem.ToString(), StringComparison.OrdinalIgnoreCase))
                        {
                            DeployerTrace.WriteInfo("Invoking isolated network reset.");

                            // Clean up isolated network set up
                            var isolatedNetworkCleanupOperation = new IsolatedNetworkCleanupOperation();
                            isolatedNetworkCleanupOperation.ExecuteOperation(parameters.IsolatedNetworkName, parameters.FabricBinRoot, parameters.Operation);

                            if (parameters.IsolatedNetworkSetup)
                            {
                                var isolatedNetworkSetupOperation = new IsolatedNetworkSetupOperation();
                                isolatedNetworkSetupOperation.ExecuteOperation(parameters, clusterManifest, infrastructure);
                            }

                            // Record last boot up time.
                            Utility.SaveNodeLastBootUpTimeToRegistry(lastBootUpTimeFromSystem);
                        }
                    }
                    else
                    {
                        DeployerTrace.WriteInfo("Skipping isolated network reset on reboot because SkipIsolatedNetworkResetOnReboot flag is enabled.");
                    }
                }
                else
                {
                    DeployerTrace.WriteInfo("Isolated Network preview feature disabled for the cluster.");
                }
                #endregion
            }
        }
Beispiel #3
0
        private static void ExecuteOperationPrivate(DeploymentParameters parameters)
        {
            DeployerTrace.WriteInfo("Executing {0}", parameters.ToString());
            DeploymentOperation operation = null;

            switch (parameters.Operation)
            {
            case DeploymentOperations.Configure:
                operation = new ConfigureOperation();
                break;

            case DeploymentOperations.ValidateClusterManifest:
                operation = new ValidateClusterManifestOperation();
                break;

            case DeploymentOperations.Create:
                operation = new CreateorUpdateOperation();
                break;

            case DeploymentOperations.Update:
                operation = new CreateorUpdateOperation();
                break;

            case DeploymentOperations.UpdateInstanceId:
                operation = new UpdateInstanceIdOperation();
                break;

            case DeploymentOperations.UpdateNodeState:
                operation = new UpdateNodeStateOperation();
                break;

            case DeploymentOperations.None:
                operation = new RestartOperation();
                break;

            case DeploymentOperations.Remove:
                operation = new RemoveOperation();
                break;

#if !DotNetCoreClrLinux
            case DeploymentOperations.RemoveNodeConfig:
                operation = new RemoveNodeConfigOperation();
                break;
#endif
            case DeploymentOperations.Rollback:
                operation = new RollbackOperation();
                break;

            case DeploymentOperations.Validate:
                operation = new ValidateOperation();
                break;

#if !DotNetCoreClrIOT
            case DeploymentOperations.DockerDnsSetup:
                operation = new DockerDnsSetupOperation();
                break;

            case DeploymentOperations.DockerDnsCleanup:
                operation = new DockerDnsCleanupOperation();
                break;

            case DeploymentOperations.ContainerNetworkSetup:
                operation = new ContainerNetworkSetupOperation();
                break;

            case DeploymentOperations.ContainerNetworkCleanup:
                operation = new ContainerNetworkCleanupOperation();
                break;

            case DeploymentOperations.IsolatedNetworkSetup:
                operation = new IsolatedNetworkSetupOperation();
                break;

            case DeploymentOperations.IsolatedNetworkCleanup:
                operation = new IsolatedNetworkCleanupOperation();
                break;
#endif
            default:
                throw new ArgumentException(StringResources.Warning_DeploymentOperationCantBeNull);
            }

            ClusterManifestType clusterManifest = parameters.ClusterManifestLocation == null ?
                                                  null :
                                                  XmlHelper.ReadXml <ClusterManifestType>(parameters.ClusterManifestLocation, SchemaLocation.GetWindowsFabricSchemaLocation());

            if (parameters.Operation != DeploymentOperations.Validate &&
                parameters.Operation != DeploymentOperations.ValidateClusterManifest &&
                parameters.Operation != DeploymentOperations.UpdateInstanceId &&
                parameters.Operation != DeploymentOperations.Remove &&
                parameters.Operation != DeploymentOperations.RemoveNodeConfig &&
                parameters.Operation != DeploymentOperations.Rollback &&
                parameters.Operation != DeploymentOperations.DockerDnsSetup &&
                parameters.Operation != DeploymentOperations.DockerDnsCleanup &&
                parameters.Operation != DeploymentOperations.ContainerNetworkSetup &&
                parameters.Operation != DeploymentOperations.ContainerNetworkCleanup &&
                parameters.Operation != DeploymentOperations.None &&
                clusterManifest.Infrastructure.Item is ClusterManifestTypeInfrastructureWindowsAzure &&
                parameters.InfrastructureManifestLocation == null)
            {
                throw new ArgumentException("InfrastructureManifestLocation");
            }

            InfrastructureInformationType infrastructureManifest = parameters.InfrastructureManifestLocation == null ?
                                                                   null :
                                                                   XmlHelper.ReadXml <InfrastructureInformationType>(parameters.InfrastructureManifestLocation, SchemaLocation.GetWindowsFabricSchemaLocation());


            Infrastructure infrastructure = clusterManifest == null ? null : Infrastructure.Create(clusterManifest.Infrastructure, infrastructureManifest == null ? null : infrastructureManifest.NodeList, clusterManifest.NodeTypes);
            DeployerTrace.WriteInfo("Running operation {0}", operation.GetType());
#if !DotNetCoreClrLinux
            bool isChangeDeploymentOperationToRemove = false;
#endif

            try
            {
                operation.OnExecuteOperation(parameters, clusterManifest, infrastructure);
            }
            catch (ChangeDeploymentOperationToRemoveException)
            {
#if !DotNetCoreClrLinux
                isChangeDeploymentOperationToRemove = true;
#endif
                DeployerTrace.WriteInfo("Deployment operation modification to remove detected");
            }

#if !DotNetCoreClrLinux
            if (isChangeDeploymentOperationToRemove)
            {
                var infraNode = infrastructure.InfrastructureNodes.SingleOrDefault(n => n.NodeName == parameters.NodeName);
                parameters.DeleteLog             = false;
                parameters.MachineName           = infraNode.IPAddressOrFQDN;
                parameters.DeploymentPackageType = FabricPackageType.XCopyPackage;
                operation = new RemoveNodeConfigOperation();
                DeployerTrace.WriteInfo("Deployment modified to RemoveNodeConfig. New parameters set: parameter.DeleteLog: {0}, parameters.MachineName: {1}, parameters.DeploymentPackageType: {2}",
                                        parameters.DeleteLog,
                                        parameters.MachineName,
                                        parameters.DeploymentPackageType);
                operation.OnExecuteOperation(parameters, clusterManifest, infrastructure);
            }

            if (Utility.GetTestFailDeployer())
            {
                DeployerTrace.WriteInfo("Failing deployment as test hook is found");
                Utility.DeleteTestFailDeployer();
                throw new InvalidDeploymentException(StringResources.Error_FabricDeployer_TestHookFound_Formatted);
            }
#endif
        }