public WindowsUpdateServiceCoordinator(IConfigStore configStore, string configSection, KeyValueStoreReplica kvsReplica, IStatefulServicePartition partition, IExceptionHandlingPolicy exceptionPolicy)
        {
            configStore.ThrowIfNull("configStore");
            configSection.ThrowIfNullOrWhiteSpace("configSectionName");
            kvsReplica.ThrowIfNull("kvsReplica");
            partition.ThrowIfNull("partition");
            exceptionPolicy.ThrowIfNull("exceptionPolicy");

            this.commandProcessor  = new FabricClientWrapper();
            this.store             = kvsReplica;
            this.partition         = partition;
            this.packageRetriever  = new UpdatePackageRetriever();
            this.serviceName       = new Uri(Constants.SystemServicePrefix + configSection);
            this.configStore       = configStore;
            this.configSectionName = configSection;
            this.exceptionPolicy   = exceptionPolicy;

            // Read all the configuration values
            string coordinatorType = configStore.ReadUnencryptedString(configSection, Constants.ConfigurationSection.CoordinatorType);

            this.testMode   = false;
            this.testSrcDir = string.Empty;
            if (coordinatorType.Equals(Constants.ConfigurationSection.WUTestCoordinator))
            {
                this.testSrcDir = configStore.ReadUnencryptedString(configSection, Constants.WUSCoordinator.TestCabFolderParam);
                this.testMode   = true;
            }

            this.waitTimeBeforePolling   = TimeSpan.FromMinutes(Constants.WUSCoordinator.PollingIntervalInMinutesDefault);
            this.windowsUpdateApiTimeout = TimeSpan.FromMinutes(Constants.WUSCoordinator.WuApiTimeoutInMinutesDefault);
        }
        public PaasCoordinator(
            IConfigStore configStore,
            string configSectionName,
            KeyValueStoreReplica kvsStore,
            IStatefulServicePartition partition)
        {
            configStore.ThrowIfNull("configStore");
            configSectionName.ThrowIfNullOrWhiteSpace("configSectionName");
            partition.ThrowIfNull("partition");

            this.Initialize(configStore, configSectionName, kvsStore, partition);
        }
        public NodeStatusManager(
            KeyValueStoreReplica kvsStore,
            IConfigStore configStore,
            string configSectionName)
        {
            kvsStore.ThrowIfNull(nameof(kvsStore));
            configStore.ThrowIfNull(nameof(configStore));
            configSectionName.ThrowIfNullOrWhiteSpace(nameof(configSectionName));

            this.kvsStore          = kvsStore;
            this.configStore       = configStore;
            this.configSectionName = configSectionName;
        }
Beispiel #4
0
        public NodeStatusManager(
            KeyValueStoreReplica kvsStore,
            IConfigStore configStore,
            string configSectionName,
            IExceptionHandlingPolicy exceptionPolicy)
        {
            kvsStore.ThrowIfNull(nameof(kvsStore));
            configStore.ThrowIfNull(nameof(configStore));
            configSectionName.ThrowIfNullOrWhiteSpace(nameof(configSectionName));

            this.kvsStore          = kvsStore;
            this.configStore       = configStore;
            this.configSectionName = configSectionName;
            this.exceptionPolicy   = exceptionPolicy;
        }
Beispiel #5
0
        internal static async Task <Transaction> CreateTransactionWithRetryAsync(this KeyValueStoreReplica kvsStore, IExceptionHandlingPolicy exceptionPolicy, CancellationToken token)
        {
            // TODO:
            // There's currently a bug in KVS where a service gets identified as a primary but doesn't actually have KVS write access.
            // Retrying solves the issue until the bug gets solved.
            while (!token.IsCancellationRequested)
            {
                try
                {
                    return(kvsStore.CreateTransaction());
                }
                catch (Exception e)
                {
                    exceptionPolicy.ReportError(e, false);

                    await Task.Delay(Constants.KvsCreateTransactionRetryTime, token);
                }
            }

            return(null);
        }
        internal ResourceCoordinator(
            KeyValueStoreReplica kvsStore,
            IConfigStore configStore,
            string configSectionName,
            IDictionary <ResourceType, IResourceCommandProcessor> resourceCommandProcessors,
            IWrpPackageRetriever packageRetriever,
            IExceptionHandlingPolicy healthPolicy)
        {
            kvsStore.ThrowIfNull(nameof(kvsStore));
            configStore.ThrowIfNull(nameof(configStore));
            configSectionName.ThrowIfNullOrWhiteSpace(nameof(configSectionName));
            resourceCommandProcessors.ThrowIfNull(nameof(resourceCommandProcessors));
            packageRetriever.ThrowIfNull(nameof(packageRetriever));
            healthPolicy.ThrowIfNull(nameof(healthPolicy));

            this.kvsStore          = kvsStore;
            this.configStore       = configStore;
            this.configSectionName = configSectionName;
            this.commandProcessors = resourceCommandProcessors;
            this.packageRetriever  = packageRetriever;
            this.exceptionPolicy   = healthPolicy;
        }
        private void Initialize(
            IConfigStore configStore,
            string configSectionName,
            KeyValueStoreReplica kvsStore,
            IStatefulServicePartition partition)
        {
            var baseUrlStr       = configStore.ReadUnencryptedString(configSectionName, Constants.ConfigurationSection.BaseUrl);
            var clusterId        = configStore.ReadUnencryptedString(Constants.ConfigurationSection.PaasSectionName, Constants.ConfigurationSection.ClusterId);
            var primaryNodeTypes = GetPrimaryNodeTypes(configStore, configSectionName);

            // Error checking
            baseUrlStr.ThrowIfNullOrWhiteSpace("baseUrlStr");
            clusterId.ThrowIfNullOrWhiteSpace("clusterId");
            Uri baseUrl;

            if (!Uri.TryCreate(baseUrlStr, UriKind.Absolute, out baseUrl))
            {
                throw new ArgumentException("BaseUrl in clusterManifest is not of Uri type");
            }

            Trace.WriteNoise(TraceType, "BaseUrl: {0}", baseUrl);

            var wrpStreamChannelUrlStr = Path.Combine(baseUrlStr, clusterId);
            Uri wrpStreamChannelUri;

            if (!Uri.TryCreate(wrpStreamChannelUrlStr, UriKind.Absolute, out wrpStreamChannelUri))
            {
                throw new ArgumentException($"StreamChannel URL is not of Uri type: {wrpStreamChannelUrlStr}");
            }

            Trace.WriteInfo(TraceType, "StreamChannel URL: {0}", wrpStreamChannelUrlStr);

            var wrpPollUrlStr = $"{wrpStreamChannelUrlStr}?api-version={ApiVersion}";
            Uri wrpPollUri;

            if (!Uri.TryCreate(wrpPollUrlStr, UriKind.Absolute, out wrpPollUri))
            {
                throw new ArgumentException($"Poll URL is not of Uri type: {wrpPollUrlStr}");
            }
            Trace.WriteInfo(TraceType, "Poll URL: {0}", wrpPollUrlStr);

            var fabricClientWrapper = new FabricClientWrapper();

            var resourceCommandProcessors = new Dictionary <ResourceType, IResourceCommandProcessor>()
            {
                {
                    ResourceType.Cluster,
                    new ClusterCommandProcessor(
                        configStore,
                        configSectionName,
                        fabricClientWrapper,
                        new CommandParameterGenerator(fabricClientWrapper),
                        new NodeStatusManager(kvsStore, configStore, configSectionName),
                        JsonSerializer.Create(WrpGatewayClient.SerializerSettings),
                        primaryNodeTypes)
                },
                {
                    ResourceType.ApplicationType,
                    new ApplicationTypeCommandProcessor(
                        new ApplicationTypeClient(fabricClientWrapper.FabricClient, configStore, configSectionName))
                },
                {
                    ResourceType.Application,
                    new ApplicationCommandProcessor(
                        new ApplicationClient(fabricClientWrapper.FabricClient))
                },
                {
                    ResourceType.Service,
                    new ServiceCommandProcessor(
                        new ServiceClient(fabricClientWrapper.FabricClient))
                }
            };

            this.coordinators = new List <IUpgradeCoordinator>
            {
                new ResourceCoordinator(
                    kvsStore,
                    configStore,
                    configSectionName,
                    resourceCommandProcessors,
                    new WrpPackageRetriever(wrpPollUri, clusterId, configStore, configSectionName),
                    new ExceptionHandlingPolicy(Constants.PaasCoordinator.SFRPPollHealthProperty, ResourceCoordinator.TaskName, configStore, configSectionName, partition)),

                new StreamChannelCoordinator(
                    new WrpStreamChannel(wrpStreamChannelUri, clusterId, configStore, configSectionName),
                    new ExceptionHandlingPolicy(Constants.PaasCoordinator.SFRPStreamChannelHealthProperty, StreamChannelCoordinator.TaskName, configStore, configSectionName, partition))
            };
        }
Beispiel #8
0
 public SewingSession(KeyValueStoreReplica store)
 {
     this.store = store;
     tx         = store.CreateTransaction();
 }
Beispiel #9
0
 void SetReplica(KeyValueStoreReplica replica)
 {
     Replica = replica;
 }