Пример #1
0
 /// <inheritdoc/>
 public Task OnEndpointNewAsync(RegistryOperationContextModel context,
                                EndpointInfoModel endpoint)
 {
     using (_metrics.TrackDuration(nameof(OnEndpointNewAsync))) {
         return(CheckEndpointInfoAsync(endpoint));
     }
 }
Пример #2
0
 /// <inheritdoc/>
 public Task OnApplicationNewAsync(RegistryOperationContextModel context,
                                   ApplicationInfoModel application)
 {
     using (_metrics.TrackDuration(nameof(OnApplicationNewAsync))) {
         return(CheckApplicationInfoAsync(application));
     }
 }
Пример #3
0
        /// <inheritdoc/>
        public async Task DeactivateEndpointAsync(string endpointId,
                                                  RegistryOperationContextModel context, CancellationToken ct)
        {
            if (string.IsNullOrEmpty(endpointId))
            {
                throw new ArgumentException(nameof(endpointId));
            }
            context = context.Validate();
            // Get existing endpoint and compare to see if we need to patch.
            var twin = await _iothub.GetAsync(endpointId, null, ct);

            if (twin.Id != endpointId)
            {
                throw new ArgumentException("Id must be same as twin to deactivate",
                                            nameof(endpointId));
            }
            // Convert to twin registration
            var registration = twin.ToEntityRegistration(true) as EndpointRegistration;

            if (registration == null)
            {
                throw new ResourceNotFoundException(
                          $"{endpointId} is not an endpoint registration.");
            }

            if (registration.Activated ?? false)
            {
                await DeactivateAsync(registration, context, ct);
            }
        }
 /// <inheritdoc/>
 public Task PurgeDisabledApplicationsAsync(TimeSpan notSeenFor,
                                            RegistryOperationContextModel context, CancellationToken ct)
 {
     context = context.Validate();
     // TODO: Implement correctly
     return(Task.CompletedTask);
 }
Пример #5
0
        /// <summary>
        /// Deactivate
        /// </summary>
        /// <param name="registration"></param>
        /// <param name="context"></param>
        /// <param name="ct"></param>
        /// <returns></returns>
        private async Task DeactivateAsync(EndpointRegistration registration,
                                           RegistryOperationContextModel context, CancellationToken ct = default)
        {
            var endpoint = registration.ToServiceModel();

            // Deactivate twin in twin settings - do no matter what
            await ClearSupervisorTwinSecretAsync(registration.DeviceId,
                                                 registration.SupervisorId, ct);

            // Call down to supervisor to ensure deactivation is complete - do no matter what
            await Try.Async(() => _activator.DeactivateEndpointAsync(endpoint.Registration));

            try {
                // Mark as deactivated
                if (registration.Activated ?? false)
                {
                    var patch = endpoint.ToEndpointRegistration(
                        _serializer, registration.IsDisabled);

                    // Mark as deactivated
                    patch.Activated = false;

                    await _iothub.PatchAsync(registration.Patch(patch, _serializer), true);
                }
                await _broker.NotifyAllAsync(l => l.OnEndpointDeactivatedAsync(context, endpoint));
            }
            catch (Exception ex) {
                _logger.Error(ex, "Failed to deactivate twin");
                throw;
            }
        }
 /// <inheritdoc/>
 public async Task RejectApplicationAsync(string applicationId, bool force,
                                          RegistryOperationContextModel context, CancellationToken ct)
 {
     context = context.Validate();
     var app = await UpdateApplicationStateAsync(applicationId, ApplicationState.Rejected,
                                                 s => s == ApplicationState.New || force);
 }
        /// <summary>
        /// Delete all requests for the given entity
        /// </summary>
        /// <param name="entityId"></param>
        /// <param name="context"></param>
        /// <returns></returns>
        private async Task RemoveAllRequestsForEntityAsync(string entityId,
                                                           RegistryOperationContextModel context)
        {
            string nextPageLink = null;
            var    result       = await _requests.QueryRequestsAsync(
                new CertificateRequestQueryRequestModel {
                EntityId = entityId
            });

            while (true)
            {
                nextPageLink = result.NextPageLink;
                foreach (var request in result.Requests)
                {
                    if (request.State != CertificateRequestState.Accepted)
                    {
                        await Try.Async(() => _requests.AcceptRequestAsync(
                                            request.RequestId, new VaultOperationContextModel {
                            AuthorityId = context?.AuthorityId,
                            Time        = context?.Time ?? DateTime.UtcNow
                        }));
                    }
                }
                if (result.NextPageLink == null)
                {
                    break;
                }
                result = await _requests.ListRequestsAsync(result.NextPageLink);
            }
        }
        /// <inheritdoc/>
        public async Task HandleDeviceTwinEventAsync(DeviceTwinEvent ev)
        {
            if (ev.Handled)
            {
                return;
            }
            if (string.IsNullOrEmpty(ev.Twin.Id))
            {
                return;
            }
            var type = ev.Twin.Tags.GetValueOrDefault <string>(
                nameof(EntityRegistration.DeviceType), null);

            if ((ev.Event != DeviceTwinEventType.Delete && ev.IsPatch) || string.IsNullOrEmpty(type))
            {
                try {
                    ev.Twin = await _iothub.GetAsync(ev.Twin.Id);

                    ev.IsPatch = false;
                    type       = ev.Twin.Tags.GetValueOrDefault <string>(
                        nameof(EntityRegistration.DeviceType), null);
                }
                catch (Exception ex) {
                    _logger.Verbose(ex, "Failed to materialize twin");
                }
            }
            if (IdentityType.Endpoint.EqualsIgnoreCase(type))
            {
                var ctx = new RegistryOperationContextModel {
                    AuthorityId = ev.AuthorityId,
                    Time        = ev.Timestamp
                };
                switch (ev.Event)
                {
                case DeviceTwinEventType.New:
                    break;

                case DeviceTwinEventType.Create:
                    await _broker.NotifyAllAsync(l => l.OnEndpointNewAsync(ctx,
                                                                           ev.Twin.ToEndpointRegistration(false).ToServiceModel()));

                    break;

                case DeviceTwinEventType.Update:
                    await _broker.NotifyAllAsync(l => l.OnEndpointUpdatedAsync(ctx,
                                                                               ev.Twin.ToEndpointRegistration(false).ToServiceModel()));

                    break;

                case DeviceTwinEventType.Delete:
                    await _broker.NotifyAllAsync(l => l.OnEndpointDeletedAsync(ctx,
                                                                               ev.Twin.Id,
                                                                               ev.Twin.ToEndpointRegistration(false).ToServiceModel()));

                    break;
                }
                ev.Handled = true;
            }
        }
Пример #9
0
        /// <inheritdoc/>
        public async Task HandleDeviceTwinEventAsync(DeviceTwinEvent ev)
        {
            if (ev.Handled)
            {
                return;
            }
            if (string.IsNullOrEmpty(ev.Twin.Id) || string.IsNullOrEmpty(ev.Twin.ModuleId))
            {
                return;
            }
            var type = ev.Twin.Properties?.Reported.GetValueOrDefault <string>(
                TwinProperty.Type, null);

            if ((ev.Event != DeviceTwinEventType.Delete && ev.IsPatch) || string.IsNullOrEmpty(type))
            {
                try {
                    ev.Twin = await _iothub.GetAsync(ev.Twin.Id, ev.Twin.ModuleId);

                    ev.IsPatch = false;
                    type       = ev.Twin.Properties?.Reported?.GetValueOrDefault <string>(
                        TwinProperty.Type, null);
                }
                catch (Exception ex) {
                    _logger.Verbose(ex, "Failed to materialize twin");
                }
            }
            if (IdentityType.Discoverer.EqualsIgnoreCase(type))
            {
                var ctx = new RegistryOperationContextModel {
                    AuthorityId = ev.AuthorityId,
                    Time        = ev.Timestamp
                };
                switch (ev.Event)
                {
                case DeviceTwinEventType.New:
                    break;

                case DeviceTwinEventType.Create:
                    await _broker.NotifyAllAsync(l => l.OnDiscovererNewAsync(ctx,
                                                                             ev.Twin.ToDiscovererRegistration(false).ToServiceModel()));

                    break;

                case DeviceTwinEventType.Update:
                    await _broker.NotifyAllAsync(l => l.OnDiscovererUpdatedAsync(ctx,
                                                                                 ev.Twin.ToDiscovererRegistration(false).ToServiceModel()));

                    break;

                case DeviceTwinEventType.Delete:
                    await _broker.NotifyAllAsync(l => l.OnDiscovererDeletedAsync(ctx,
                                                                                 DiscovererModelEx.CreateDiscovererId(
                                                                                     ev.Twin.Id, ev.Twin.ModuleId)));

                    break;
                }
                ev.Handled = true;
            }
        }
Пример #10
0
 /// <summary>
 /// Create endpoint event
 /// </summary>
 /// <param name="type"></param>
 /// <param name="context"></param>
 /// <param name="endpoint"></param>
 /// <returns></returns>
 private static EndpointEventModel Wrap(EndpointEventType type,
                                        RegistryOperationContextModel context, EndpointInfoModel endpoint)
 {
     return(new EndpointEventModel {
         EventType = type,
         Context = context,
         Endpoint = endpoint
     });
 }
 /// <summary>
 /// Create from service model
 /// </summary>
 /// <param name="model"></param>
 public RegistryOperationContextApiModel(RegistryOperationContextModel model)
 {
     if (model == null)
     {
         throw new ArgumentNullException(nameof(model));
     }
     Time        = model.Time;
     AuthorityId = model.AuthorityId;
 }
 /// <summary>
 /// Create application event
 /// </summary>
 /// <param name="type"></param>
 /// <param name="context"></param>
 /// <param name="application"></param>
 /// <returns></returns>
 private static ApplicationEventModel Wrap(ApplicationEventType type,
                                           RegistryOperationContextModel context, ApplicationInfoModel application)
 {
     return(new ApplicationEventModel {
         EventType = type,
         Context = context,
         Application = application
     });
 }
Пример #13
0
        /// <summary>
        /// Try to activate endpoint on any supervisor in site
        /// </summary>
        /// <param name="endpoint"></param>
        /// <param name="additional"></param>
        /// <param name="context"></param>
        /// <param name="ct"></param>
        /// <returns></returns>
        private async Task <bool> ActivateAsync(EndpointRegistration endpoint,
                                                IEnumerable <string> additional, RegistryOperationContextModel context,
                                                CancellationToken ct)
        {
            // Get site of this endpoint
            var site = endpoint.SiteId;

            if (string.IsNullOrEmpty(site))
            {
                // Use discovery id gateway part if no site found
                site = DiscovererModelEx.ParseDeviceId(endpoint.DiscovererId, out _);
                if (string.IsNullOrEmpty(site))
                {
                    // Try supervisor id gateway part
                    site = DiscovererModelEx.ParseDeviceId(endpoint.SupervisorId, out _);
                }
            }

            // Get all supervisors in site
            endpoint.SiteId = site;
            var supervisorsInSite = await _supervisors.QueryAllSupervisorsAsync(
                new SupervisorQueryModel { SiteId = site });

            var candidateSupervisors = supervisorsInSite.Select(s => s.Id)
                                       .ToList().Shuffle();

            // Add all supervisors that managed this endpoint before.
            // TODO: Consider removing as it is a source of bugs
            if (additional != null)
            {
                candidateSupervisors.AddRange(additional);
            }

            // Remove previously failing one
            candidateSupervisors.Remove(endpoint.SupervisorId);
            // Loop through all randomly and try to take one that works.
            foreach (var supervisorId in candidateSupervisors)
            {
                endpoint.SupervisorId = supervisorId;
                endpoint.Activated    = false;
                try {
                    await ActivateAsync(endpoint, context, ct);

                    _logger.Information("Activate twin on supervisor {supervisorId}!",
                                        supervisorId);
                    // Done - endpoint was also patched thus has new supervisor id
                    return(true);
                }
                catch (Exception ex) {
                    _logger.Debug(ex, "Failed to activate twin on supervisor {supervisorId} " +
                                  "- trying next...", supervisorId);
                }
            }
            // Failed
            return(false);
        }
Пример #14
0
        /// <summary>
        /// Apply activation filter
        /// </summary>
        /// <param name="filter"></param>
        /// <param name="registration"></param>
        /// <param name="context"></param>
        /// <param name="ct"></param>
        /// <returns></returns>
        private async Task <string> ApplyActivationFilterAsync(
            EndpointActivationFilterModel filter, EndpointRegistration registration,
            RegistryOperationContextModel context, CancellationToken ct = default)
        {
            if (filter == null || registration == null)
            {
                return(null);
            }
            // TODO: Get trust list entry and validate endpoint.Certificate
            var mode = registration.SecurityMode ?? SecurityMode.None;

            if (!mode.MatchesFilter(filter.SecurityMode ?? SecurityMode.Best))
            {
                return(null);
            }
            var policy = registration.SecurityPolicy;

            if (filter.SecurityPolicies != null)
            {
                if (!filter.SecurityPolicies.Any(p =>
                                                 p.EqualsIgnoreCase(registration.SecurityPolicy)))
                {
                    return(null);
                }
            }
            try {
                // Ensure device scope for the registration before getting the secret.
                // Changing device's scope regenerates the secret.
                await EnsureDeviceScopeForRegistrationAsync(registration, ct);

                // Get endpoint twin secret
                var secret = await _iothub.GetPrimaryKeyAsync(registration.DeviceId, null, ct);

                var endpoint = registration.ToServiceModel();

                // Try activate endpoint - if possible...
                await _activator.ActivateEndpointAsync(endpoint.Registration, secret, ct);

                // Mark in supervisor
                await SetSupervisorTwinSecretAsync(registration.SupervisorId,
                                                   registration.DeviceId, secret, ct);

                registration.Activated = true;

                await _broker.NotifyAllAsync(
                    l => l.OnEndpointActivatedAsync(context, endpoint));

                return(secret);
            }
            catch (Exception ex) {
                _logger.Information(ex, "Failed activating {eeviceId} based off " +
                                    "filter.  Manual activation required.", registration.DeviceId);
                return(null);
            }
        }
Пример #15
0
 /// <summary>
 /// Create discoverer event
 /// </summary>
 /// <param name="type"></param>
 /// <param name="context"></param>
 /// <param name="discovererId"></param>
 /// <param name="discoverer"></param>
 /// <returns></returns>
 private static DiscovererEventModel Wrap(DiscovererEventType type,
                                          RegistryOperationContextModel context, string discovererId,
                                          DiscovererModel discoverer)
 {
     return(new DiscovererEventModel {
         EventType = type,
         Context = context,
         Id = discovererId,
         Discoverer = discoverer
     });
 }
Пример #16
0
 /// <summary>
 /// Create gateway event
 /// </summary>
 /// <param name="type"></param>
 /// <param name="context"></param>
 /// <param name="gatewayId"></param>
 /// <param name="gateway"></param>
 /// <returns></returns>
 private static GatewayEventModel Wrap(GatewayEventType type,
                                       RegistryOperationContextModel context, string gatewayId,
                                       GatewayModel gateway)
 {
     return(new GatewayEventModel {
         EventType = type,
         Context = context,
         Id = gatewayId,
         Gateway = gateway
     });
 }
Пример #17
0
 /// <summary>
 /// Create supervisor event
 /// </summary>
 /// <param name="type"></param>
 /// <param name="context"></param>
 /// <param name="supervisorId"></param>
 /// <param name="supervisor"></param>
 /// <returns></returns>
 private static SupervisorEventModel Wrap(SupervisorEventType type,
                                          RegistryOperationContextModel context, string supervisorId,
                                          SupervisorModel supervisor)
 {
     return(new SupervisorEventModel {
         EventType = type,
         Context = context,
         Id = supervisorId,
         Supervisor = supervisor
     });
 }
 /// <summary>
 /// Create publisher event
 /// </summary>
 /// <param name="type"></param>
 /// <param name="context"></param>
 /// <param name="publisherId"></param>
 /// <param name="publisher"></param>
 /// <returns></returns>
 private static PublisherEventModel Wrap(PublisherEventType type,
                                         RegistryOperationContextModel context, string publisherId,
                                         PublisherModel publisher)
 {
     return(new PublisherEventModel {
         EventType = type,
         Context = context,
         Id = publisherId,
         Publisher = publisher
     });
 }
Пример #19
0
        /// <inheritdoc/>
        public async Task ActivateEndpointAsync(string endpointId,
                                                RegistryOperationContextModel context, CancellationToken ct)
        {
            if (string.IsNullOrEmpty(endpointId))
            {
                throw new ArgumentException(nameof(endpointId));
            }
            context = context.Validate();

            // Get existing endpoint and compare to see if we need to patch.
            var twin = await _iothub.GetAsync(endpointId, null, ct);

            if (twin.Id != endpointId)
            {
                throw new ArgumentException("Id must be same as twin to activate",
                                            nameof(endpointId));
            }

            // Convert to twin registration
            var registration = twin.ToEntityRegistration(true) as EndpointRegistration;

            if (registration == null)
            {
                throw new ResourceNotFoundException(
                          $"{endpointId} is not an endpoint registration.");
            }

            if (registration.IsDisabled ?? false)
            {
                throw new ResourceInvalidStateException(
                          $"{endpointId} is disabled - cannot activate");
            }

            if (!(registration.Activated ?? false))
            {
                // Activate if not yet activated
                try {
                    if (string.IsNullOrEmpty(registration.SupervisorId))
                    {
                        throw new ArgumentException(
                                  $"Twin {endpointId} not registered with a supervisor.");
                    }
                    await ActivateAsync(registration, context, ct);
                }
                catch (Exception ex) {
                    // Try other supervisors as candidates
                    if (!await ActivateAsync(registration, null, context, ct))
                    {
                        throw ex;
                    }
                }
            }
        }
Пример #20
0
 /// <summary>
 /// Create from service model
 /// </summary>
 /// <param name="model"></param>
 public static RegistryOperationContextApiModel ToApiModel(
     this RegistryOperationContextModel model)
 {
     if (model == null)
     {
         return(null);
     }
     return(new RegistryOperationContextApiModel {
         AuthorityId = model.AuthorityId,
         Time = model.Time
     });
 }
Пример #21
0
        /// <inheritdoc/>
        public async Task DisableApplicationAsync(string applicationId,
                                                  RegistryOperationContextModel context, CancellationToken ct)
        {
            context = context.Validate();

            var app = await _database.UpdateAsync(applicationId, (application, disabled) => {
                // Disable application
                if (!(disabled ?? false))
                {
                    application.NotSeenSince = DateTime.UtcNow;
                    application.Updated      = context;
                    return(true, true);
                }
        /// <inheritdoc/>
        public async Task ApproveApplicationAsync(string applicationId, bool force,
                                                  RegistryOperationContextModel context, CancellationToken ct)
        {
            context = context.Validate();

            var app = await _database.UpdateAsync(applicationId, (application, disabled) => {
                if (disabled ?? false)
                {
                    throw new ResourceInvalidStateException("The application is disabled.");
                }
                if (application.State == ApplicationState.Approved)
                {
                    return(null, null);
                }
Пример #23
0
        /// <summary>
        /// Activate
        /// </summary>
        /// <param name="registration"></param>
        /// <param name="context"></param>
        /// <param name="ct"></param>
        /// <returns></returns>
        private async Task ActivateAsync(EndpointRegistration registration,
                                         RegistryOperationContextModel context, CancellationToken ct = default)
        {
            // Ensure device scope for the registration before getting the secret.
            // Changing device's scope regenerates the secret.
            await EnsureDeviceScopeForRegistrationAsync(registration, ct);

            // Update supervisor settings
            var secret = await _iothub.GetPrimaryKeyAsync(registration.DeviceId, null, ct);

            var endpoint = registration.ToServiceModel();

            try {
                // Call down to supervisor to activate - this can fail
                await _activator.ActivateEndpointAsync(endpoint.Registration, secret, ct);

                // Update supervisor desired properties
                await SetSupervisorTwinSecretAsync(registration.SupervisorId,
                                                   registration.DeviceId, secret, ct);

                if (!(registration.Activated ?? false))
                {
                    // Update twin activation status in twin settings
                    var patch = endpoint.ToEndpointRegistration(_serializer,
                                                                registration.IsDisabled);

                    patch.Activated = true; // Mark registration as activated

                    await _iothub.PatchAsync(registration.Patch(patch, _serializer), true, ct);
                }
                await _broker.NotifyAllAsync(l => l.OnEndpointActivatedAsync(context, endpoint));
            }
            catch (Exception ex) {
                // Undo activation
                await Try.Async(() => _activator.DeactivateEndpointAsync(
                                    endpoint.Registration));

                await Try.Async(() => ClearSupervisorTwinSecretAsync(
                                    registration.DeviceId, registration.SupervisorId));

                _logger.Error(ex, "Failed to activate twin");
                throw;
            }
        }
Пример #24
0
        /// <inheritdoc/>
        public async Task OnApplicationEnabledAsync(RegistryOperationContextModel context,
                                                    ApplicationInfoModel application)
        {
            var endpoints = await GetEndpointsAsync(application.ApplicationId, true);

            foreach (var registration in endpoints)
            {
                // Enable if disabled
                if (!(registration.IsDisabled ?? false))
                {
                    continue;
                }
                try {
                    var endpoint = registration.ToServiceModel();
                    endpoint.NotSeenSince = null;
                    var update = endpoint.ToEndpointRegistration(_serializer, false);
                    await _iothub.PatchAsync(registration.Patch(update, _serializer));

                    await _broker.NotifyAllAsync(
                        l => l.OnEndpointEnabledAsync(context, endpoint));
                }
                catch (Exception ex) {
                    _logger.Error(ex, "Failed re-enabling endpoint {id}",
                                  registration.Id);
                    continue;
                }
                // Activate if it was activated before
                if (!(registration.Activated ?? false))
                {
                    continue; // No need to re-activate on enable
                }
                try {
                    await ActivateAsync(registration, context);
                }
                catch (Exception ex) {
                    _logger.Error(ex,
                                  "Failed activating re-enabled endpoint {id}", registration.Id);
                }
            }
        }
Пример #25
0
        /// <inheritdoc/>
        public async Task OnApplicationDisabledAsync(RegistryOperationContextModel context,
                                                     ApplicationInfoModel application)
        {
            // Disable endpoints
            var endpoints = await GetEndpointsAsync(application.ApplicationId, true);

            foreach (var registration in endpoints)
            {
                if (registration.Activated ?? false)
                {
                    try {
                        registration.Activated = false; // Prevent patching...
                        await DeactivateAsync(registration, context);

                        registration.Activated = true; // reset activated state
                    }
                    catch (Exception ex) {
                        _logger.Error(ex, "Failed deactivating disabled endpoint {id}",
                                      registration.Id);
                    }
                }
                // Disable if enabled
                if (!(registration.IsDisabled ?? false))
                {
                    try {
                        var endpoint = registration.ToServiceModel();
                        endpoint.NotSeenSince = DateTime.UtcNow;
                        var update = endpoint.ToEndpointRegistration(_serializer, true);
                        await _iothub.PatchAsync(registration.Patch(update, _serializer));

                        await _broker.NotifyAllAsync(
                            l => l.OnEndpointDisabledAsync(context, endpoint));
                    }
                    catch (Exception ex) {
                        _logger.Error(ex, "Failed disabling endpoint {id}", registration.Id);
                    }
                }
            }
        }
Пример #26
0
        /// <inheritdoc/>
        public async Task OnApplicationDeletedAsync(RegistryOperationContextModel context,
                                                    ApplicationInfoModel application)
        {
            // Get all endpoint registrations and for each one, call delete, if failure,
            // stop half way and throw and do not complete.
            var endpoints = await GetEndpointsAsync(application.ApplicationId, true);

            foreach (var registration in endpoints)
            {
                var endpoint = registration.ToServiceModel();
                try {
                    registration.Activated = false; // Prevents patching since we delete below.
                    await DeactivateAsync(registration, context);
                }
                catch (Exception ex) {
                    _logger.Error(ex, "Failed deleting registered endpoint endpoint {id}",
                                  registration.Id);
                }
                await _iothub.DeleteAsync(registration.DeviceId);

                await _broker.NotifyAllAsync(l => l.OnEndpointDeletedAsync(context, endpoint));
            }
        }
        /// <inheritdoc/>
        public async Task UnregisterApplicationAsync(string applicationId,
                                                     RegistryOperationContextModel context, CancellationToken ct)
        {
            context = context.Validate();
            if (string.IsNullOrEmpty(applicationId))
            {
                throw new ArgumentNullException(nameof(applicationId),
                                                "The application id must be provided");
            }
            while (true)
            {
                var document = await _applications.FindAsync <ApplicationDocument>(applicationId);

                if (document == null)
                {
                    throw new ResourceNotFoundException(
                              "A record with the specified application id does not exist.");
                }
                var application = document.Value.Clone();
                try {
                    // Try delete
                    await _applications.DeleteAsync(document);

                    // Success -- Notify others to clean up
                    var app = document.Value.ToServiceModel();

                    // Try free record id
                    await Try.Async(() => _index.FreeAsync(document.Value.ID));

                    break;
                }
                catch (ResourceOutOfDateException) {
                    _logger.Verbose("Retry unregister application operation.");
                    continue;
                }
            }
        }
Пример #28
0
 /// <inheritdoc/>
 public Task OnSupervisorUpdatedAsync(RegistryOperationContextModel context,
                                      SupervisorModel supervisor)
 {
     return(_bus.PublishAsync(Wrap(SupervisorEventType.Updated, context,
                                   supervisor.Id, supervisor)));
 }
Пример #29
0
 /// <inheritdoc/>
 public Task OnSupervisorDeletedAsync(RegistryOperationContextModel context,
                                      string supervisorId)
 {
     return(_bus.PublishAsync(Wrap(SupervisorEventType.Deleted, context,
                                   supervisorId, null)));
 }
Пример #30
0
 /// <inheritdoc/>
 public Task OnApplicationUpdatedAsync(RegistryOperationContextModel context,
                                       ApplicationInfoModel application)
 {
     return(Task.CompletedTask);
 }