void initLazyLoaders(bool newOrder) { _OemInfoLoader = new LazyLoader <OEMInfo>(() => OEMService.QueryOEMById(OEMID.Value)); if (newOrder) { _applyformLoader = new EnumerableLazyLoader <BaseApplyform>(); _operationLoader = new EnumerableLazyLoader <Log.Domain.OrderLog>(); _coordinationLoader = new EnumerableLazyLoader <Coordination>(); } else { _applyformLoader = new EnumerableLazyLoader <BaseApplyform>(() => { return(ApplyformQueryService.QueryApplyforms(this.Id)); }); _operationLoader = new EnumerableLazyLoader <Log.Domain.OrderLog>(() => { return(LogService.QueryOrderLog(this.Id)); }); _coordinationLoader = new EnumerableLazyLoader <Coordination>(() => { return(CoordinationService.QueryOrderCoordinations(this.Id)); }); } _associateOrderLoader = new LazyLoader <Order>(); _distributionBillLoader = new LazyLoader <Service.Distribution.Domain.OrderBill>(() => { return(DistributionQueryService.QueryOrderBill(this.Id)); }); }
private void StopListeners() { DebugTrace.TraceEnter(this, "StopListeners"); if (this.twoPhaseCommitCoordinatorListener != null) { this.twoPhaseCommitCoordinatorListener.Stop(); this.twoPhaseCommitCoordinatorListener = null; } if (this.twoPhaseCommitParticipantListener != null) { this.twoPhaseCommitParticipantListener.Stop(); this.twoPhaseCommitParticipantListener = null; } if (this.completionCoordinatorListener != null) { this.completionCoordinatorListener.Stop(); this.completionCoordinatorListener = null; } if (this.registrationCoordinatorListener != null) { this.registrationCoordinatorListener.Stop(); this.registrationCoordinatorListener = null; } if (this.activationCoordinatorListener != null) { this.activationCoordinatorListener.Stop(); this.activationCoordinatorListener = null; } if (this.coordination != null) { this.coordination.Cleanup(); this.coordination = null; } DebugTrace.TraceLeave(this, "StopListeners"); }
private CoordinationService GetCoordinationService() { if (this.coordinationService == null) { lock (this.proxyLock) { if (this.coordinationService == null) { try { CoordinationServiceConfiguration config = new CoordinationServiceConfiguration { Mode = CoordinationServiceMode.Formatter, RemoteClientsEnabled = this.wsatConfig.RemoteActivationService(this.protocolVersion) != null }; this.coordinationService = new CoordinationService(config, this.protocolVersion); } catch (MessagingInitializationException exception) { DiagnosticUtility.ExceptionUtility.TraceHandledException(exception, TraceEventType.Error); throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new TransactionException(System.ServiceModel.SR.GetString("WsatMessagingInitializationFailed"), exception)); } } } } return(this.coordinationService); }
//============================================================================================= //[SuppressMessage(FxCop.Category.Security, FxCop.Rule.AptcaMethodsShouldOnlyCallAptcaMethods, Justification = "We call PartialTrustHelpers.DemandForFullTrust().")] CoordinationService GetCoordinationService() { if (this.coordinationService == null) { lock (this.proxyLock) { if (this.coordinationService == null) { // The demand is not added now (in 4.5), to avoid a breaking change. To be considered in the next version. /* * // We demand full trust because CoordinationService is defined in a non-APTCA assembly and can call Environment.FailFast. * // It's recommended to not let partially trusted callers to bring down the process. * System.Runtime.PartialTrustHelpers.DemandForFullTrust(); */ try { CoordinationServiceConfiguration config = new CoordinationServiceConfiguration(); config.Mode = CoordinationServiceMode.Formatter; config.RemoteClientsEnabled = this.wsatConfig.RemoteActivationService(this.protocolVersion) != null; this.coordinationService = new CoordinationService(config, this.protocolVersion); } catch (MessagingInitializationException e) { DiagnosticUtility.TraceHandledException(e, TraceEventType.Error); throw DiagnosticUtility.ExceptionUtility.ThrowHelperError( new TransactionException(SR.GetString(SR.WsatMessagingInitializationFailed), e)); } } } } return(this.coordinationService); }
public void RecoveryBeginning() { DebugTrace.TraceEnter(this, "RecoveryBeginning"); if (this.config.NetworkEndpointsEnabled) { try { this.coordination = new CoordinationService(this.config.PortConfiguration, this.protocolVersion); this.activationCoordinatorListener = this.coordination.Add(this.activationCoordinator); this.registrationCoordinatorListener = this.coordination.Add(this.registrationCoordinator); this.completionCoordinatorListener = this.coordination.Add(this.completionCoordinator); this.twoPhaseCommitCoordinatorListener = this.coordination.Add(this.twoPhaseCommitCoordinator); this.twoPhaseCommitParticipantListener = this.coordination.Add(this.twoPhaseCommitParticipant); } catch (MessagingInitializationException exception) { if (DebugTrace.Error) { DebugTrace.Trace(TraceLevel.Error, "Error initializing CoordinationService: {0}", exception); } this.CleanupOnFailure(); throw Microsoft.Transactions.Bridge.DiagnosticUtility.ExceptionUtility.ThrowHelperError(new PluggableProtocolException(exception.Message, exception)); } catch (Exception exception2) { if (DebugTrace.Error) { DebugTrace.Trace(TraceLevel.Error, "Unknown exception initializing CoordinationService: {0}", exception2); } this.CleanupOnFailure(); throw; } } DebugTrace.TraceLeave(this, "RecoveryBeginning"); }
protected Proxy(CoordinationService coordination, EndpointAddress to, EndpointAddress from) { this.coordinationService = coordination; this.to = to; this.from = from; this.protocolVersion = coordination.ProtocolVersion; this.coordinationStrings = CoordinationStrings.Version(coordination.ProtocolVersion); this.atomicTransactionStrings = AtomicTransactionStrings.Version(coordination.ProtocolVersion); }
void initLazyLoaders() { _operationLoader = new EnumerableLazyLoader <Log.Domain.OrderLog>(() => LogService.QueryApplyformLog(this.Id)); _coordinationLoader = new EnumerableLazyLoader <Coordination>(() => CoordinationService.QueryApplyformCoordinations(this.Id)); _orderLoader = new LazyLoader <Order>(() => OrderQueryService.QueryOrder(this.OrderId)); _purchaserLoader = new LazyLoader <DataTransferObject.Organization.CompanyInfo>(() => Organization.CompanyService.GetCompanyDetail(this.PurchaserId)); _providerLoader = new LazyLoader <DataTransferObject.Organization.CompanyInfo>(() => Organization.CompanyService.GetCompanyDetail(this.ProviderId)); _OemInfoLoader = new LazyLoader <OEMInfo>(() => OEMService.QueryOEMById(OEMID.Value)); }
public static IWSActivationCoordinator Instance(CoordinationService service, IActivationCoordinator dispatch) { ProtocolVersionHelper.AssertProtocolVersion(service.ProtocolVersion, typeof(ActivationCoordinatorDispatcher), "Instance"); switch (service.ProtocolVersion) { case ProtocolVersion.Version10: return new ActivationCoordinatorDispatcher10(service, dispatch); case ProtocolVersion.Version11: return new ActivationCoordinatorDispatcher11(service, dispatch); } return null; }
public static IWSTwoPhaseCommitParticipant Instance(CoordinationService service, ITwoPhaseCommitParticipant dispatch) { ProtocolVersionHelper.AssertProtocolVersion(service.ProtocolVersion, typeof(TwoPhaseCommitParticipantDispatcher), "V"); switch (service.ProtocolVersion) { case ProtocolVersion.Version10: return new TwoPhaseCommitParticipantDispatcher10(service, dispatch); case ProtocolVersion.Version11: return new TwoPhaseCommitParticipantDispatcher11(service, dispatch); } return null; }
//============================================================================================= // The demand is not added now (in 4.5), to avoid a breaking change. To be considered in the next version. /* * [PermissionSet(SecurityAction.Demand, Unrestricted = true)] // because we call code from a non-APTCA assembly; WSATs are not supported in partial trust, so customers should not be broken by this demand */ ActivationProxy CreateActivationProxy(EndpointAddress address) { CoordinationService coordination = GetCoordinationService(); try { return(coordination.CreateActivationProxy(address, false)); } catch (CreateChannelFailureException e) { DiagnosticUtility.TraceHandledException(e, TraceEventType.Error); throw DiagnosticUtility.ExceptionUtility.ThrowHelperError( new TransactionException(SR.GetString(SR.WsatProxyCreationFailed), e)); } }
private ActivationProxy CreateActivationProxy(EndpointAddress address) { ActivationProxy proxy; CoordinationService coordinationService = this.GetCoordinationService(); try { proxy = coordinationService.CreateActivationProxy(address, false); } catch (CreateChannelFailureException exception) { DiagnosticUtility.ExceptionUtility.TraceHandledException(exception, TraceEventType.Error); throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new TransactionException(System.ServiceModel.SR.GetString("WsatProxyCreationFailed"), exception)); } return(proxy); }
public void Setup() { TestDatabase = new TestDatabase(); Context = new AppDbContext(TestDatabase.ContextOptions); Context.AddTestData(); CS = new CoordinationService( new CoordinationRepository(Context), new NotificationService(new NotificationRepository(Context), new UnitOfWork(Context)), new PublisherRepository(Context), new CategoryRepository(Context), new TagsRepository(Context), new UnitOfWork(Context), new GitlabService(new DatasetServiceTests.SoullessGitlabCLient(), new Microsoft.Extensions.Configuration.ConfigurationBuilder().Build())); ExampleV = new Coordination { Id = 103, Title = "Samordning av museumsdata", Description = "Dette er en samordning av data rundt museumer i kommunene: Bodø og Trondheim", PublisherId = 100, CategoryId = 100, UnderCoordination = false }; }
public RegistrationCoordinatorDispatcher(CoordinationService service, IRegistrationCoordinator dispatch) { this.service = service; this.dispatch = dispatch; }
public ActivationCoordinatorDispatcher11(CoordinationService service, IActivationCoordinator dispatch) { ProtocolVersionHelper.AssertProtocolVersion11(service.ProtocolVersion, typeof(ActivationCoordinatorDispatcher11), "constr"); this.activationCoordinatorDispatcher = new ActivationCoordinatorDispatcher(service, dispatch); }
public TwoPhaseCommitParticipantDispatcher11(CoordinationService service, ITwoPhaseCommitParticipant dispatch) { ProtocolVersionHelper.AssertProtocolVersion11(service.ProtocolVersion, typeof(TwoPhaseCommitParticipantDispatcher11), "constr"); this.twoPhaseCommitParticipantDispatcher = new TwoPhaseCommitParticipantDispatcher(service, dispatch); }
public TwoPhaseCommitParticipantDispatcher(CoordinationService service, ITwoPhaseCommitParticipant dispatch) : base(service.ProtocolVersion) { this.service = service; this.dispatch = dispatch; this.protocolVersion = service.ProtocolVersion; }
public RegistrationProxy(CoordinationService coordination, EndpointAddress to) : base(coordination, to) { }
public TwoPhaseCommitCoordinatorDispatcher10(CoordinationService service, ITwoPhaseCommitCoordinator dispatch) { ProtocolVersionHelper.AssertProtocolVersion10(service.ProtocolVersion, typeof(TwoPhaseCommitCoordinatorDispatcher10), "constr"); this.twoPhaseCommitCoordinatorDispatcher = new TwoPhaseCommitCoordinatorDispatcher(service, dispatch); }
//============================================================================================= //[SuppressMessage(FxCop.Category.Security, FxCop.Rule.AptcaMethodsShouldOnlyCallAptcaMethods, Justification = "We call PartialTrustHelpers.DemandForFullTrust().")] CoordinationService GetCoordinationService() { if (this.coordinationService == null) { lock (this.proxyLock) { if (this.coordinationService == null) { // The demand is not added now (in 4.5), to avoid a breaking change. To be considered in the next version. /* // We demand full trust because CoordinationService is defined in a non-APTCA assembly and can call Environment.FailFast. // It's recommended to not let partially trusted callers to bring down the process. System.Runtime.PartialTrustHelpers.DemandForFullTrust(); */ try { CoordinationServiceConfiguration config = new CoordinationServiceConfiguration(); config.Mode = CoordinationServiceMode.Formatter; config.RemoteClientsEnabled = this.wsatConfig.RemoteActivationService(this.protocolVersion) != null; this.coordinationService = new CoordinationService(config, this.protocolVersion); } catch (MessagingInitializationException e) { DiagnosticUtility.TraceHandledException(e, TraceEventType.Error); throw DiagnosticUtility.ExceptionUtility.ThrowHelperError( new TransactionException(SR.GetString(SR.WsatMessagingInitializationFailed), e)); } } } } return this.coordinationService; }
public CompletionCoordinatorDispatcher(CoordinationService service, ICompletionCoordinator dispatch) : base(service.ProtocolVersion) { this.service = service; this.dispatch = dispatch; }
private CoordinationService GetCoordinationService() { if (this.coordinationService == null) { lock (this.proxyLock) { if (this.coordinationService == null) { try { CoordinationServiceConfiguration config = new CoordinationServiceConfiguration { Mode = CoordinationServiceMode.Formatter, RemoteClientsEnabled = this.wsatConfig.RemoteActivationService(this.protocolVersion) != null }; this.coordinationService = new CoordinationService(config, this.protocolVersion); } catch (MessagingInitializationException exception) { DiagnosticUtility.ExceptionUtility.TraceHandledException(exception, TraceEventType.Error); throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new TransactionException(System.ServiceModel.SR.GetString("WsatMessagingInitializationFailed"), exception)); } } } } return this.coordinationService; }
public TwoPhaseCommitParticipantProxy(CoordinationService coordination, EndpointAddress to, EndpointAddress from) : base(coordination, to, from) { }
public RegistrationCoordinatorDispatcher11(CoordinationService service, IRegistrationCoordinator dispatch) { ProtocolVersionHelper.AssertProtocolVersion11(service.ProtocolVersion, typeof(RegistrationCoordinatorDispatcher11), "constr"); this.registrationCoordinatorDispatcher = new RegistrationCoordinatorDispatcher(service, dispatch); }
public ActivationProxy(CoordinationService coordination, EndpointAddress to) : base(coordination, to) { }
public CompletionParticipantProxy(CoordinationService coordination, EndpointAddress to) : base(coordination, to, null) { }
public CoordinationServiceHost(CoordinationService service, object serviceInstance) { this.service = service; base.InitializeDescription(serviceInstance, new UriSchemeKeyedCollection(new Uri[0])); }
public ActivationCoordinatorDispatcher(CoordinationService service, IActivationCoordinator dispatch) { this.service = service; this.dispatch = dispatch; }
public CompletionCoordinatorDispatcher10(CoordinationService service, ICompletionCoordinator dispatch) { ProtocolVersionHelper.AssertProtocolVersion10(service.ProtocolVersion, typeof(CompletionCoordinatorDispatcher10), "constr"); this.completionCoordinatorDispatcher = new CompletionCoordinatorDispatcher(service, dispatch); }
public CompletionParticipantDispatcher11(CoordinationService service, ICompletionParticipant dispatch) { ProtocolVersionHelper.AssertProtocolVersion11(service.ProtocolVersion, typeof(CompletionParticipantDispatcher11), "constr"); this.completionParticipantDispatcher = new CompletionParticipantDispatcher(service, dispatch); }