static IPresenter BuildPresenter(
HttpContextBase httpContext,
ITraceContext traceContext,
IMessageBus messageBus,
Action <IPresenter> presenterCreatedCallback,
IPresenterFactory presenterFactory,
PresenterBinding binding,
IView viewInstance)
{
traceContext.Write(typeof(PresenterBinder), () => string.Format(
CultureInfo.InvariantCulture,
"Creating presenter of type {0} for view of type {1}. (The actual view instance is of type {2}.)",
binding.PresenterType.FullName,
binding.ViewType.FullName,
viewInstance.GetType().FullName));
var presenter = presenterFactory.Create(binding.PresenterType, binding.ViewType, viewInstance);
presenter.HttpContext = httpContext;
presenter.Messages = messageBus;
if (presenterCreatedCallback != null)
{
presenterCreatedCallback(presenter);
}
return(presenter);
}
/// <summary>
/// Initializes a new instance of the <see cref="SpanContext"/> class
/// that is the child of the specified parent context.
/// </summary>
/// <param name="parent">The parent context.</param>
/// <param name="traceContext">The trace context.</param>
/// <param name="serviceName">The service name to propagate to child spans.</param>
internal SpanContext(ISpanContext parent, ITraceContext traceContext, string serviceName)
: this(parent?.TraceId, serviceName)
{
SpanId = _random.Value.NextUInt63();
Parent = parent;
TraceContext = traceContext;
}
public Span Remove(ITraceContext traceContext)
{
Span span = null;
_spanMap.TryRemove(traceContext, out span);
return(span); //Will return null if span doesn't exist
}
static IEnumerable <IPresenter> PerformBinding(
IEnumerable <object> hosts,
IEnumerable <IView> candidates,
IPresenterDiscoveryStrategy presenterDiscoveryStrategy,
HttpContextBase httpContext,
ITraceContext traceContext,
IMessageBus messageBus,
Action <IPresenter> presenterCreatedCallback,
IPresenterFactory presenterFactory)
{
var bindings = GetBindings(
hosts,
candidates,
presenterDiscoveryStrategy,
traceContext);
var newPresenters = BuildPresenters(
httpContext,
traceContext,
messageBus,
presenterCreatedCallback,
presenterFactory,
bindings);
return(newPresenters);
}
protected override void OnLoad(IServiceProvider serviceProvider)
{
base.OnLoad(serviceProvider);
_traceService = (ITraceContext)serviceProvider.GetService(typeof(ITraceContext));
_traceService.Always("SAP C4C addin loaded");
}
public void Load(IServiceProvider serviceProvider)
{
try
{
s_traceContext = (ITraceContext)serviceProvider.GetService(typeof(ITraceContext));
//must have the icelib sdk license to get the session as a service
s_session = (Session)serviceProvider.GetService(typeof(Session));
s_connection = new Connection.Connection(s_session);
}
catch (ArgumentNullException)
{
s_traceContext.Error("unable to get Icelib Session, is the ICELIB SDK License available?");
Debug.Fail("unable to get service. Is the ICELIB SDK licence available?");
throw;
}
s_interactionManager = new InteractionManager(s_session, (IQueueService)serviceProvider.GetService(typeof(IQueueService)), s_traceContext);
s_statusManager = new CicStatusService(s_session, s_traceContext);
s_notificationService = (INotificationService)serviceProvider.GetService(typeof(INotificationService));
s_settingsManager = new SettingsManager();
s_deviceManager = new DeviceManager(s_traceContext, new SpokesDebugLogger(s_traceContext));
s_statusChanger = new StatusChanger(s_session, s_statusManager, s_deviceManager, s_settingsManager);
s_notificationServer = new NotificationServer(s_deviceManager, s_settingsManager, s_notificationService);
s_hookSwitchManager = new InteractionSyncManager(s_interactionManager, s_deviceManager, (IQueueService)serviceProvider.GetService(typeof(IQueueService)), s_traceContext, s_connection);
s_outboundEventNotificationService = new OutboundEventNotificationService(s_session, s_statusManager, s_deviceManager, s_traceContext);
s_traceContext.Always("Plantronics AddIn Loaded");
}
static IEnumerable <PresenterBinding> GetBindings(
IEnumerable <object> hosts,
IEnumerable <IView> candidates,
IPresenterDiscoveryStrategy presenterDiscoveryStrategy,
ITraceContext traceContext)
{
traceContext.Write(typeof(PresenterBinder), () => string.Format(
CultureInfo.InvariantCulture,
"Finding presenter bindings using {0} for {1} view {2}: {3}",
presenterDiscoveryStrategy.GetType().Name,
candidates.Count(),
candidates.Count() == 1 ? "instance" : "instances",
string.Join(", ", candidates.Select(v => v.GetType().FullName).ToArray())
));
var results = presenterDiscoveryStrategy
.GetBindings(hosts, candidates);
traceContext.Write(typeof(PresenterBinder), () =>
BuildTraceMessagesForBindings(presenterDiscoveryStrategy, results));
ThrowExceptionsForViewsWithNoPresenterBound(results);
return(results
.SelectMany(r => r.Bindings));
}
public PlantronicsManager(IStatusManager statusManager,
IInteractionManager interactionManager,
INotificationService notificationService,
ITraceContext traceContext)
{
_statusManager = statusManager;
_interactionManager = interactionManager;
_traceContext = traceContext;
_notificationService = notificationService;
m_sessionComManager = new SessionComManagerClass();
m_sessionManagerEvents = m_sessionComManager as ISessionCOMManagerEvents_Event;
m_comSession = m_sessionComManager.Register("Interaction Client Plantronics AddIn");
// Now check if our plugin session was created
if (m_comSession != null)
{
// detect devices added/removed
m_sessionManagerEvents.DeviceStateChanged += OnDeviceStateChanged;
//Get current Device
m_device = m_comSession.ActiveDevice;
// if we have a device register for events
if (m_device != null)
{
// Register for device events
RegisterEvents();
}
}
}
private static bool TryExtract <C>(C carrier, IExtractor <C> extractor, out Trace trace)
{
ITraceContext traceContext = default(SpanState);
traceContext = extractor.Extract(carrier);
return(TryCreateTraceFromTraceContext(traceContext, out trace));
}
public void Load(IServiceProvider serviceProvider)
{
_trace = serviceProvider.GetService(typeof(ITraceContext)) as ITraceContext;
if (_trace == null)
{
return;
}
_trace.Always("CallTo registry monitor loaded");
try
{
CheckRegistry();
_timer = new Timer(new TimerCallback(o => {
try{
CheckRegistry();
}
catch {}
}), null, 1000, 1000);
}
catch (Exception ex)
{
_trace.Exception(ex, "Exception caught getting registry value");
}
}
protected override void OnLoad(IServiceProvider serviceProvider)
{
base.OnLoad(serviceProvider);
_traceContext = (ITraceContext)serviceProvider.GetService(typeof(ITraceContext));
_traceContext.Note("My interaction queue monitor loaded...");
base.StartMonitoring();
}
public ExecutionService(IRouteRepository routeRepository, IRequestRepository requestRepository, ITopicFactory topicFactory, IResponsePipeline responsePipeline, ITraceContext traceContext)
{
_routeRepository = routeRepository;
_requestRepository = requestRepository;
_topicFactory = topicFactory;
_responsePipeline = responsePipeline;
_traceContext = traceContext;
}
public MvcInterceptor(ILoggerFactory loggerFactory, ITracer tracer, ITraceContext traceContext)
: base(loggerFactory, tracer, traceContext)
{
_proxyAdapter = new ProxyAdapter();
_proxyAdapter.Register("Microsoft.AspNetCore.Mvc.Controllers.ControllerActionDescriptor");
_proxyAdapter.Register("Microsoft.AspNetCore.Mvc.Abstractions.ActionDescriptor");
}
public Span(ITraceContext spanState, DateTime spanCreated)
{
Annotations = new List <ZipkinAnnotation>();
BinaryAnnotations = new List <BinaryAnnotation>();
Complete = false;
SpanState = spanState;
SpanCreated = spanCreated;
}
protected override void OnLoad(IServiceProvider serviceProvider)
{
base.OnLoad(serviceProvider);
_traceContext = (ITraceContext)serviceProvider.GetService(typeof(ITraceContext));
_traceContext.Note("My interaction queue monitor loaded...");
base.StartMonitoring();
}
/// <summary>
/// Invokes the next <see cref="RequestDelegate"/> and traces the time
/// taken for the next delegate to run, reporting the results to the
/// Google Cloud Trace API.
/// </summary>
/// <param name="httpContext">The current HTTP context.</param>
/// <param name="traceContext">Trace information from the current request. Must not be null.</param>
/// <param name="fallback">Predicate to be used if the trace context has no information about whether
/// the request should be traced or not.</param>
/// <param name="traceContextPropagator">Trace context propagator to be used to set the trace context
/// on the <see cref="HttpResponse"/>. Must not be null.</param>
public async Task Invoke(
HttpContext httpContext, ITraceContext traceContext, TraceDecisionPredicate fallback, Action <HttpResponse, ITraceContext> traceContextPropagator)
{
GaxPreconditions.CheckNotNull(traceContext, nameof(traceContext));
GaxPreconditions.CheckNotNull(traceContextPropagator, nameof(traceContextPropagator));
// Applies the trace decision fallback, if needed.
traceContext = WithShouldTraceFallback(traceContext, fallback.ShouldTrace(httpContext.Request));
// Create a tracer for the given request and set it on the context manager so
// the tracer can be used in other places.
var tracer = _tracerFactory(traceContext);
ContextTracerManager.SetCurrentTracer(tracer);
if (tracer.GetCurrentTraceId() == null)
{
await _next(httpContext).ConfigureAwait(false);
}
else
{
if (traceContext.TraceId != null)
{
// Set the current trace context on the response.
var currentTraceContext = ContextTracerManager.GetCurrentTraceContext();
traceContextPropagator.Invoke(httpContext.Response, currentTraceContext);
}
// Trace the delegate and annotate it with information from the current
// HTTP context.
var traceName = await _nameProvider.GetTraceNameAsync(httpContext).ConfigureAwait(false);
var span = tracer.StartSpan(traceName);
try
{
await _next(httpContext).ConfigureAwait(false);
}
catch (Exception exception)
{
try
{
StackTrace stackTrace = new StackTrace(exception, true);
tracer.SetStackTrace(stackTrace);
}
catch (Exception innerException)
{
throw new AggregateException(innerException, exception);
}
throw;
}
finally
{
tracer.AnnotateSpan(Labels.AgentLabel);
tracer.AnnotateSpan(Labels.FromHttpContext(httpContext));
span.Dispose();
}
}
}
private void RemoveThenLogSpan(ITraceContext spanState)
{
var spanToLog = _spanMap.Remove(spanState);
if (spanToLog != null)
{
_reporter.Report(spanToLog);
}
}
/// <summary>
/// 设置 HttpContextItem
/// </summary>
/// <param name="key"></param>
/// <param name="val"></param>
public void SetContextItem(ITraceContext traceContext, string key, object val)
{
if (string.IsNullOrWhiteSpace(key) || traceContext == null)
{
return;
}
traceContext.Items[key] = val;
}
internal static (string Parent, string Context) CreateHeaderValues(ITraceContext traceContext)
{
var traceId = "00-" + traceContext.TraceIdHigh.ToString("x16") + traceContext.TraceId.ToString("x16") + "-" + traceContext.SpanId.ToString("x16") + "-" + ((traceContext.Sampled ?? false) ? "01" : "00");
var previousContext = (traceContext.Extra == null || traceContext.Extra.Count == 0) ? null : (string)traceContext.Extra[0];
var flags = (byte)((traceContext.Debug ? 2 : 0) | (traceContext.ParentSpanId.HasValue ? 1 : 0));
var context = c_vendorKeyEquals + flags.ToString("x2", CultureInfo.InvariantCulture) + (traceContext.ParentSpanId.HasValue ? traceContext.ParentSpanId.Value.ToString("x16") : "") + (previousContext == null ? "" : ("," + previousContext));
return(traceId, context);
}
/// <summary>
/// Adds the specified message to the trace context and will output the message on the response.
/// </summary>
/// <param name="context">Current trace context for lifetime scope (request).</param>
/// <param name="name">Unique name of the tracer. Usually related to the current operation being performed. Must contain alphanumeric and hyphen characters only.</param>
/// <param name="message"></param>
public static void WriteMessageTracer(this ITraceContext context, string name, string message)
{
TraceContext.EnsureValidTracerName(name);
var traceContext = (TraceContext)context;
var tracer = new MessageTracer(message);
traceContext.Tracers.Add(name, tracer);
}
private void RemoveThenLogSpan(ITraceContext spanState)
{
Span spanToLog;
if (_spanMap.TryRemove(spanState, out spanToLog))
{
_reporter.Report(spanToLog);
}
}
public InteractionManager(Session session, IQueueService queueService, ITraceContext traceContext)
{
_traceContext = traceContext;
_interactionManager = InteractionsManager.GetInstance(session);
_queueService = queueService;
//We could use icelib to get the queue and interactions, but the AddIn API wraps things up to be a little simpler to use.
_myInteractionsQueue = _queueService.GetMyInteractions(new[] { InteractionAttributes.State });
}
private static string SerializeTraceId(ITraceContext spanState)
{
var hexTraceId = NumberUtils.EncodeLongToLowerHexString(spanState.TraceId);
if (spanState.TraceIdHigh == SpanState.NoTraceIdHigh)
{
return(hexTraceId);
}
return(NumberUtils.EncodeLongToLowerHexString(spanState.TraceIdHigh) + hexTraceId);
}
private static bool TryCreateTraceFromTraceContext(ITraceContext traceContext, out Trace trace)
{
if (traceContext == default(SpanState))
{
trace = default(Trace);
return(false);
}
trace = Trace.CreateFromId(traceContext);
return(true);
}
public AdvancedSpan(ISpan innerSpan, ITraceContext traceContext, bool active)
{
_innerSpan = innerSpan;
_traceContext = traceContext;
_active = active;
if (_active)
{
_traceContext.Push(this);
}
}
/// <inheritdoc />
internal IManagedTracer CreateTracer(ITraceContext traceContext)
{
GaxPreconditions.CheckNotNull(traceContext, nameof(traceContext));
if (!ShouldTrace(traceContext))
{
return(NullManagedTracer.Instance);
}
var traceId = traceContext.TraceId ?? _traceIdFactory.NextId();
return(SimpleManagedTracer.Create(_consumer, _projectId, traceId, traceContext.SpanId));
}
/// <summary>
/// Initializes a new instance of the <see cref="SpanContext"/> class
/// that is the child of the specified parent context.
/// </summary>
/// <param name="parent">The parent context.</param>
/// <param name="traceContext">The trace context.</param>
/// <param name="serviceName">The service name to propagate to child spans.</param>
internal SpanContext(ISpanContext parent, ITraceContext traceContext, string serviceName)
: this(parent?.TraceId, serviceName)
{
SpanId = SpanIdGenerator.CreateNew();
Parent = parent;
TraceContext = traceContext;
if (parent is SpanContext spanContext)
{
Origin = spanContext.Origin;
}
}
/// <summary>
/// Initializes a new instance of the <see cref="SpanContext"/> class
/// that is the child of the specified parent context.
/// </summary>
/// <param name="parent">The parent context.</param>
/// <param name="traceContext">The trace context.</param>
/// <param name="serviceName">The service name to propagate to child spans.</param>
internal SpanContext(ISpanContext parent, ITraceContext traceContext, string serviceName)
: this(parent?.TraceId, serviceName)
{
Parent = parent;
TraceContext = traceContext;
if (SpanId == 0)
{
SpanId = GenerateId();
}
}
/// <summary>
/// Initializes a new instance of the <see cref="SpanContext"/> class
/// that is the child of the specified parent context.
/// </summary>
/// <param name="parent">The parent context.</param>
/// <param name="traceContext">The trace context.</param>
/// <param name="serviceName">The service name to propagate to child spans.</param>
/// <param name="spanId">The propagated span id.</param>
internal SpanContext(ISpanContext parent, ITraceContext traceContext, string serviceName, ulong?spanId = null)
: this(parent?.TraceId, serviceName)
{
SpanId = spanId ?? SpanIdGenerator.ThreadInstance.CreateNew();
Parent = parent;
TraceContext = traceContext;
if (parent is SpanContext spanContext)
{
Origin = spanContext.Origin;
}
}
private HttpHandlerInterceptor GetInterceptor(
ITracer tracer = null,
ITraceContext traceContext = null
)
{
var loggerFactory = new LoggerFactory();
tracer = tracer ?? new TestTracer();
traceContext = traceContext ?? new TraceContext();
return(new HttpHandlerInterceptor(loggerFactory, tracer, traceContext));
}
public void Inject(ITraceContext traceContext, C carrier)
{
foreach (var elt in traceContext.Extra)
{
var extra = elt as ExtraFieldPropagation.Extra;
if (extra != null)
{
extra.SetAll(carrier, _setter, _nameToKey);
break;
}
}
_underlyingInjector.Inject(traceContext, carrier);
}
/// <summary>
/// Finds an existing <see cref="TimerTracer"/> and marks it as complete.
/// </summary>
/// <param name="context">Current trace context for lifetime scope (request).</param>
/// <param name="name">Unique name of the timer. Usually related to the current operation being performed. Must contain alphanumeric and hyphen characters only.</param>
public static void CompleteTimerTracer(this ITraceContext context, string name)
{
TraceContext.EnsureValidTracerName(name);
TracerBase tracer;
if (!context.Tracers.TryGetValue(name, out tracer))
{
return;
}
var typedTracer = tracer as TimerTracer;
typedTracer?.Complete();
}
public OrdersController(HttpClient httpClient, ITraceContext traceContext)
{
if (httpClient == null)
{
throw new ArgumentNullException(nameof(httpClient));
}
if (traceContext == null)
{
throw new ArgumentNullException(nameof(traceContext));
}
_httpClient = httpClient;
_traceContext = traceContext;
}
internal static IEnumerable <object> FindHosts(Page page, ITraceContext traceContext)
{
traceContext.Write(typeof(PageViewHost), () => "Finding hosts (pages and master pages).");
yield return(page);
var masterHost = page.Master;
while (masterHost != null)
{
yield return(masterHost);
masterHost = masterHost.Master;
}
}
public CicStatusService(Session session, ITraceContext traceContext)
{
_userId = session.UserId;
_traceContext = traceContext;
_peopleManager = PeopleManager.GetInstance(session);
_userStatusList = new UserStatusList(_peopleManager);
_userStatusList.StartWatching(new[] { _userId });
_userStatusList.WatchedObjectsChanged += OnUserStatusChanged;
_statusMessageList = new StatusMessageList(_peopleManager);
_statusMessageList.StartWatching();
_filteredStatusList = new FilteredStatusMessageList(_peopleManager);
_filteredStatusList.StartWatching(new[] { _userId });
}
public InteractionSyncManager(IInteractionManager interactionManager, IDeviceManager deviceManager, IQueueService queueService, ITraceContext traceContext, IConnection connection)
{
_interactionManager = interactionManager;
_deviceManager = deviceManager;
_traceContext = traceContext;
_connection = connection;
_connection.UpChanged += OnConnectionUpChanged;
_deviceManager.CallAnsweredByDevice += OnCallAnsweredByDevice;
_deviceManager.CallEndedByDevice += OnCallEndedByDevice;
_deviceManager.MuteChanged += OnMuteChangedByDevice;
_deviceManager.OnCall += OnOnCall;
// _deviceManager.TalkButtonPressed += OnTalkButtonPressed;
_deviceManager.TalkButtonHeld += OnTalkButtonHeld;
_myInteractions = queueService.GetMyInteractions(new[] { InteractionAttributes.State, InteractionAttributes.Muted });
_myInteractions.InteractionAdded += OnInteractionAdded;
_myInteractions.InteractionChanged += OnInteractionChanged;
_myInteractions.InteractionRemoved += OnInteractionRemoved;
}
public void Load(IServiceProvider serviceProvider)
{
try
{
_traceContext = (ITraceContext)serviceProvider.GetService(typeof(ITraceContext));
//must have the icelib sdk license to get the session as a service
_session = (Session)serviceProvider.GetService(typeof(Session));
_interactionManager = new InteractionManager(_session, (IQueueService)serviceProvider.GetService(typeof(IQueueService)), _traceContext);
_statusManager = new StatusManager(_session);
_notificationService = (INotificationService)serviceProvider.GetService(typeof(INotificationService));
_plantronicsManager = new PlantronicsManager(_statusManager, _interactionManager, _notificationService, _traceContext);
_traceContext.Always("Plantronics AddIn Loaded");
}
catch (ArgumentNullException)
{
Debug.Fail("unable to get service. Is the ICELIB SDK licence available?");
throw;
}
}
public OutboundEventNotificationService(Session session, ICicStatusService statusService, IDeviceManager deviceManager, ITraceContext traceContext)
{
_deviceManager = deviceManager;
_session = session;
_traceContext = traceContext;
_statusService = statusService;
_statusService.UserStatusChanged += OnUserStatusChanged;
_session.ConnectionStateChanged += OnConnectionStateChanged;
_deviceManager.HeadsetConnected += OnDeviceEvent;
_deviceManager.HeadsetDisconnected += OnDeviceEvent;
_deviceManager.MuteChanged += OnDeviceEvent;
_deviceManager.PlantronicsDeviceAttached += OnDeviceEvent;
_deviceManager.PlantronicsDeviceDetached += OnDeviceEvent;
_serverParams = new ServerParameters(_session);
_serverParams.StartWatching(new []{ShouldSendHandlerNotificationParam, WebServerUrlParam});
PostToWebService();
}
public DeviceManager(ITraceContext traceContext, DebugLogger logger)
{
_traceContext = traceContext;
_spokes = Spokes.Instance;
_spokes.SetLogger(logger);
_spokes.Attached += OnDeviceAttached;
_spokes.Detached += OnDeviceDetached;
_spokes.Connected +=OnHeadsetConnected;
_spokes.Disconnected += OnHeadsetDisconnected;
_spokes.MuteChanged += OnMuteChanged;
_spokes.ButtonPress += OnButtonPress;
_spokes.CallAnswered += OnCallAnswered;
_spokes.CallEnded += OnCallEnded;
_spokes.OnCall += OnDeviceCall;
_spokes.Connect("Interaction Client AddIn");
// _spokes.
}
/// <summary>
/// Initializes a new instance of the <see cref="PresenterBinder"/> class.
/// </summary>
/// <param name="hosts">The array of hosts, useful in scenarios like ASP.NET master pages.</param>
/// <param name="httpContext">The owning HTTP context.</param>
/// <param name="traceContext">The tracing context.</param>
internal PresenterBinder(IEnumerable<object> hosts, HttpContextBase httpContext, ITraceContext traceContext)
{
this.httpContext = httpContext;
this.traceContext = traceContext;
traceContext.Write(this, () => string.Format(
CultureInfo.InvariantCulture,
"Web Forms MVP version is {0}",
libraryVersion = libraryVersion ?? typeof(PresenterBinder).Assembly.GetNameSafe().Version.ToString()));
traceContext.Write(this, () => string.Format(
CultureInfo.InvariantCulture,
"Initializing presenter binder for {0} hosts: {1}",
hosts.Count(),
string.Join(", ", hosts.Select(h => h.GetType().FullName).ToArray())));
this.hosts = hosts.ToList();
foreach (var selfHostedView in hosts.OfType<IView>())
{
RegisterView(selfHostedView);
}
}
static IEnumerable<IPresenter> PerformBinding(
IEnumerable<object> hosts,
IEnumerable<IView> candidates,
IPresenterDiscoveryStrategy presenterDiscoveryStrategy,
HttpContextBase httpContext,
ITraceContext traceContext,
IMessageBus messageBus,
Action<IPresenter> presenterCreatedCallback,
IPresenterFactory presenterFactory)
{
var bindings = GetBindings(
hosts,
candidates,
presenterDiscoveryStrategy,
traceContext);
var newPresenters = BuildPresenters(
httpContext,
traceContext,
messageBus,
presenterCreatedCallback,
presenterFactory,
bindings);
return newPresenters;
}
public Linetracer(ITraceContext context)
{
this.context = context;
}
static IEnumerable<PresenterBinding> GetBindings(
IEnumerable<object> hosts,
IEnumerable<IView> candidates,
IPresenterDiscoveryStrategy presenterDiscoveryStrategy,
ITraceContext traceContext)
{
traceContext.Write(typeof(PresenterBinder), () => string.Format(
CultureInfo.InvariantCulture,
"Finding presenter bindings using {0} for {1} view {2}: {3}",
presenterDiscoveryStrategy.GetType().Name,
candidates.Count(),
candidates.Count() == 1 ? "instance" : "instances",
string.Join(", ", candidates.Select(v => v.GetType().FullName).ToArray())
));
var results = presenterDiscoveryStrategy
.GetBindings(hosts, candidates);
traceContext.Write(typeof(PresenterBinder), () =>
BuildTraceMessagesForBindings(presenterDiscoveryStrategy, results));
ThrowExceptionsForViewsWithNoPresenterBound(results);
return results
.SelectMany(r => r.Bindings);
}
public JobContext(ITraceContext traceContext, IDictionary<string, string> parameters)
{
Parameters = parameters;
TraceContext = traceContext;
}
static IEnumerable<IPresenter> BuildPresenters(
HttpContextBase httpContext,
ITraceContext traceContext,
IMessageBus messageBus,
Action<IPresenter> presenterCreatedCallback,
IPresenterFactory presenterFactory,
IEnumerable<PresenterBinding> bindings)
{
return bindings
.SelectMany(binding =>
BuildPresenters(
httpContext,
traceContext,
messageBus,
presenterCreatedCallback,
presenterFactory,
binding));
}
static IEnumerable<IPresenter> BuildPresenters(
HttpContextBase httpContext,
ITraceContext traceContext,
IMessageBus messageBus,
Action<IPresenter> presenterCreatedCallback,
IPresenterFactory presenterFactory,
PresenterBinding binding)
{
IEnumerable<IView> viewsToCreateFor;
switch (binding.BindingMode)
{
case BindingMode.Default:
viewsToCreateFor = binding.ViewInstances;
break;
case BindingMode.SharedPresenter:
viewsToCreateFor = new[]
{
CreateCompositeView(binding.ViewType, binding.ViewInstances, traceContext)
};
break;
default:
throw new NotSupportedException(string.Format(
CultureInfo.InvariantCulture,
"Binding mode {0} is not supported by this method.",
binding.BindingMode));
}
return viewsToCreateFor.Select(viewInstance =>
BuildPresenter(
httpContext,
traceContext,
messageBus,
presenterCreatedCallback,
presenterFactory,
binding,
viewInstance));
}
static IPresenter BuildPresenter(
HttpContextBase httpContext,
ITraceContext traceContext,
IMessageBus messageBus,
Action<IPresenter> presenterCreatedCallback,
IPresenterFactory presenterFactory,
PresenterBinding binding,
IView viewInstance)
{
traceContext.Write(typeof(PresenterBinder), () => string.Format(
CultureInfo.InvariantCulture,
"Creating presenter of type {0} for view of type {1}. (The actual view instance is of type {2}.)",
binding.PresenterType.FullName,
binding.ViewType.FullName,
viewInstance.GetType().FullName));
var presenter = presenterFactory.Create(binding.PresenterType, binding.ViewType, viewInstance);
presenter.HttpContext = httpContext;
presenter.Messages = messageBus;
if (presenterCreatedCallback != null)
{
presenterCreatedCallback(presenter);
}
return presenter;
}
internal static IView CreateCompositeView(Type viewType, IEnumerable<IView> childViews, ITraceContext traceContext)
{
traceContext.Write(typeof(PresenterBinder), () => string.Format(
CultureInfo.InvariantCulture,
"Creating composite view for type {0} based on {1} child views: {2}",
viewType.GetType().FullName,
childViews.Count(),
string.Join(", ", childViews.Select(v => v.GetType().FullName).ToArray())));
var compositeViewType = compositeViewTypeFactory.BuildCompositeViewType(viewType);
var view = (ICompositeView)Activator.CreateInstance(compositeViewType);
foreach (var v in childViews)
{
view.Add(v);
}
return view;
}
public SpokesDebugLogger(ITraceContext traceContext)
{
_traceContext = traceContext;
}
