コード例 #1
0
        internal async override Task InitializeAsync()
        {
            this.BackupMappingStore = await BackupMappingStore.CreateOrGetBackupMappingStore(this.StatefulService).ConfigureAwait(false);

            this.BackupPolicyStore = await BackupPolicyStore.CreateOrGetBackupPolicyStore(this.StatefulService).ConfigureAwait(false);

            this.WorkItemQueue = await WorkItemQueue.CreateOrGetWorkItemQueue(this.StatefulService).ConfigureAwait(false);
        }
コード例 #2
0
        private async Task UpdateSecretsAsync(string thumbprintFromManifest, string x509StoreNameFromManifest, CancellationToken cancellationToken)
        {
            BackupRestoreTrace.TraceSource.WriteInfo(TraceType, String.Format("Updating secrets using the new thumbprint {0}", thumbprintFromManifest));
            using (var transaction = this.StateManager.CreateTransaction())
            {
                try
                {
                    var policyStore = await BackupPolicyStore.CreateOrGetBackupPolicyStore(this);

                    var workItemQueue = await WorkItemQueue.CreateOrGetWorkItemQueue(this);

                    var policies = await policyStore.GetValuesAsync(Common.Constants.StoreTimeOut, cancellationToken, transaction);

                    foreach (var policy in policies)
                    {
                        cancellationToken.ThrowIfCancellationRequested();
                        var updatedStorage = this.UpdateSecretInStorage(policy.Storage, thumbprintFromManifest, x509StoreNameFromManifest, cancellationToken);
                        var newPolicy      = policy.ToBuilder()
                                             .WithBackupStorage(updatedStorage)
                                             .UpdateUniqueId()
                                             .Build();

                        if (!await policyStore.UpdateValueAsync(policy.Name, policy, newPolicy, Common.Constants.StoreTimeOut, cancellationToken, transaction))
                        {
                            throw new InvalidOperationException(String.Format("Failed to update secret for policy with name {0}", newPolicy.Name));
                        }

                        if (newPolicy.BackupEnabledSet.Count > 0)
                        {
                            await workItemQueue.AddWorkItem(
                                new UpdateEnablementWorkItem(newPolicy.BackupEnabledSet.ToList(),
                                                             new WorkItemInfo
                            {
                                WorkItemType = WorkItemPropogationType.UpdateBackupPolicy,
                                BackupPolicyUpdateGuid = newPolicy.UniqueId
                            }), Common.Constants.StoreTimeOut, cancellationToken, transaction);
                        }
                    }

                    // Update the config store
                    var configStore = await ConfigStore.CreateOrGetConfigStore(this);

                    await configStore.UpdateValueAsync(Common.Constants.SecretUpdateInProgress, String.Empty, Common.Constants.StoreTimeOut, cancellationToken, transaction);

                    await configStore.UpdateValueAsync(Common.Constants.EncryptionCertThumbprintKey, thumbprintFromManifest, Common.Constants.StoreTimeOut, cancellationToken, transaction);

                    await transaction.CommitAsync();

                    BackupRestoreTrace.TraceSource.WriteInfo(TraceType, "All secrets updated with manifest {0}", thumbprintFromManifest);
                    FabricEvents.Events.BRSSecretsUpdated(TraceType, thumbprintFromManifest);
                }
                catch (Exception ex)
                {
                    BackupRestoreTrace.TraceSource.WriteExceptionAsWarning(TraceType, ex, "Exception encountered while updating secrets");
                    throw;
                }
            }
        }
コード例 #3
0
        internal override async Task <HttpResponseMessage> RunAsync(TimeSpan timeout, CancellationToken cancellationToken)
        {
            this.ThrowInvalidArgumentIfNull(this.backupPolicy);
            if (string.IsNullOrEmpty(this.backupPolicyName))
            {
                throw new ArgumentException();
            }

            var workItemQueue = await WorkItemQueue.CreateOrGetWorkItemQueue(this.StatefulService);

            var modelBackupPolicy = BackupPolicyModel.FromBackupPolicyView(this.backupPolicy);
            var policyBuilder     = modelBackupPolicy.ToBuilder()
                                    .WithName(this.backupPolicyName);
            RetentionManager retentionManager = await RetentionManager.CreateOrGetRetentionManager(this.StatefulService);

            using (var transaction = this.StatefulService.StateManager.CreateTransaction())
            {
                var existingBackupPolicy = await this.BackupPolicyStore.GetValueWithUpdateLockModeAsync(this.backupPolicyName, timeout, cancellationToken, transaction);

                if (existingBackupPolicy == null)
                {
                    throw new FabricException(StringResources.BackupPolicyDoesNotExist, FabricErrorCode.BackupPolicyDoesNotExist);
                }

                var existingEnablementSet = existingBackupPolicy.BackupEnabledSet;
                policyBuilder.WithBackupEnabledSet(existingEnablementSet);

                var updatedBackupPolicy = policyBuilder.Build();

                await this.BackupPolicyStore.UpdateValueAsync(this.backupPolicyName, existingBackupPolicy, updatedBackupPolicy, timeout, cancellationToken, transaction);

                if (existingEnablementSet.Count > 0)
                {
                    await
                    workItemQueue.AddWorkItem(
                        new UpdateEnablementWorkItem(existingEnablementSet.ToList(),
                                                     new WorkItemInfo {
                        WorkItemType = WorkItemPropogationType.UpdateBackupPolicy,
                        BackupPolicyUpdateGuid = updatedBackupPolicy.UniqueId
                    } ), timeout, cancellationToken, transaction);
                }

                await retentionManager.UpdatePolicyAsync(this.backupPolicyName, timeout, cancellationToken, transaction);

                await transaction.CommitAsync();
            }


            return(new HttpResponseMessage(HttpStatusCode.OK));
        }
コード例 #4
0
    public async Task RestoreOperationResultAsync(RestoreOperationResult operationResult, TimeSpan timeout,
                                                  CancellationToken cancellationToken)
    {
        BackupRestoreTrace.TraceSource.WriteInfo(TraceType, "RestoreOperationResultAsync invoked for partition {0}, ErrorCode {1}, message {2}",
                                                 operationResult.PartitionId, operationResult.ErrorCode, operationResult.Message);

        var restoreStore = await RestoreStore.CreateOrGetRestoreStatusStore(this.statefulService);

        var workItemQueue = await WorkItemQueue.CreateOrGetWorkItemQueue(this.statefulService);

        string brsServiceUri = await UtilityHelper.GetCustomServiceUri(operationResult.ServiceName, timeout, cancellationToken);

        var fabricUri = UtilityHelper.GetBackupMappingKey(brsServiceUri, operationResult.PartitionId.ToString());

        WorkItem pushPolicyAfterRestore = new SendToServiceNodeWorkItem(brsServiceUri, operationResult.PartitionId.ToString(), new WorkItemInfo()
        {
            WorkItemType = WorkItemPropogationType.UpdatePolicyAfterRestore,
        });
        await UtilityHelper.InvokeWithRetry(async() =>
        {
            BackupRestoreTrace.TraceSource.WriteInfo(TraceType, "Trying to Update the Restore request for partition {0}", operationResult.PartitionId);
            using (ITransaction transaction = this.statefulService.StateManager.CreateTransaction())
            {
                var restoreStatus = await restoreStore.GetValueWithUpdateLockModeAsync(fabricUri, timeout, cancellationToken, transaction);
                if ((restoreStatus != null) &&
                    (restoreStatus.RestoreStatusState == RestoreState.RestoreInProgress ||
                     restoreStatus.RestoreStatusState == RestoreState.Accepted) &&
                    (restoreStatus.RestoreRequestGuid.Equals(operationResult.OperationId)))
                //TODO: Add check for each request by Guid
                {
                    var updatedRestoreStatus = restoreStatus.ToBuilder()
                                               .WithState(operationResult.ErrorCode != 0 ? RestoreState.Failure : RestoreState.Success)
                                               .WithErrorCode(operationResult.ErrorCode)
                                               .WithMessage(operationResult.Message)
                                               .WithTimeStampUtc(operationResult.TimeStampUtc)
                                               .Build();

                    await restoreStore.UpdateValueAsync(fabricUri, updatedRestoreStatus, timeout, cancellationToken, transaction);
                    await workItemQueue.AddWorkItem(pushPolicyAfterRestore, timeout, cancellationToken, transaction);
                    await transaction.CommitAsync();
                    BackupRestoreTrace.TraceSource.WriteInfo(TraceType, "Updated the Restore request for partition {0}", operationResult.PartitionId);
                }
                else
                {
                    transaction.Abort();
                }
            }
        });
    }