/// <summary>
/// Obtains the interceptors associated with the component.
/// </summary>
/// <param name="kernel">The kernel instance</param>
/// <param name="model">The component model</param>
/// <param name="context">The creation context</param>
/// <returns>interceptors array</returns>
protected IInterceptor[] ObtainInterceptors(IKernel kernel, ComponentModel model, CreationContext context)
{
var interceptors = new List<IInterceptor>();
foreach (IReference<IInterceptor> interceptorRef in GetInterceptorsFor(model))
{
try
{
var interceptor = interceptorRef.Resolve(kernel, context);
SetOnBehalfAware(interceptor as IOnBehalfAware, model);
interceptors.Add(interceptor);
}
catch (Exception e)
{
foreach (var interceptor in interceptors)
{
kernel.ReleaseComponent(interceptor);
}
if(e is InvalidCastException)
{
var message = String.Format(
"An interceptor registered for {0} doesn't implement the {1} interface",
model.Name, typeof(IInterceptor).Name);
throw new DependencyResolverException(message);
}
throw;
}
}
return interceptors.ToArray();
}
private void OnCreateTaskWizardViewModel(IKernel k, TaskWizardViewModel o)
{
o.Closed += (s, e) =>
{
k.ReleaseComponent(o);
};
}
private static CloudQueueClient CreateCloudQueueClient(IKernel kernel)
{
var storageAccount = kernel.Resolve<CloudStorageAccount>();
CloudQueueClient client = storageAccount.CreateCloudQueueClient();
kernel.ReleaseComponent(storageAccount);
return client;
}
private void ReleaseHook(ProxyGenerationOptions proxyGenOptions, IKernel kernel)
{
if (proxyGenOptions.Hook == null)
{
return;
}
kernel.ReleaseComponent(proxyGenOptions.Hook);
}
private static CloudStorageAccount CreateCloudStorageAccount(IKernel kernel)
{
// Get Azure configurations
var configRetriever = kernel.Resolve<IGetEnvironmentConfiguration>();
string storageConnectionString = configRetriever.GetSetting(StorageConnectionStringAppSettingsKey);
kernel.ReleaseComponent(configRetriever);
return CloudStorageAccount.Parse(storageConnectionString);
}
private static LeaseManagerConfig CreateLeaseManagerConfig(IKernel kernel)
{
// Configure the lease manager
var configRetriever = kernel.Resolve<IGetEnvironmentConfiguration>();
var leaseManagerConfig = new LeaseManagerConfig { LeaseName = "SampleDataJobs", UniqueId = configRetriever.UniqueInstanceId };
kernel.ReleaseComponent(configRetriever);
return leaseManagerConfig;
}
private static MediaServicesCredentials CreateCredentials(IKernel kernel)
{
// Get Azure configurations
var configRetriever = kernel.Resolve<IGetEnvironmentConfiguration>();
string mediaServicesAccountName = configRetriever.GetSetting(MediaServicesNameAppSettingsKey);
string mediaServicesAccountKey = configRetriever.GetSetting(MediaServicesKeyAppSettingsKey);
kernel.ReleaseComponent(configRetriever);
// Return the credentials
return new MediaServicesCredentials(mediaServicesAccountName, mediaServicesAccountKey);
}
private static ISession CreateSession(IKernel kernel)
{
var sessionFactory = kernel.Resolve<ISessionFactory>();
try
{
return sessionFactory.OpenSession();
}
finally
{
kernel.ReleaseComponent(sessionFactory);
}
}
private static YouTubeService CreateYouTubeService(IKernel kernel)
{
var configRetriever = kernel.Resolve<IGetEnvironmentConfiguration>();
string apiKey = configRetriever.GetSetting(YouTubeApiKey);
kernel.ReleaseComponent(configRetriever);
// Create client for YouTube API
var youTubeInit = new BaseClientService.Initializer
{
ApiKey = apiKey,
ApplicationName = "KillrVideo.SampleData.Worker"
};
return new YouTubeService(youTubeInit);
}
private static ISession CreateCassandraSession(IKernel kernel)
{
// Get cluster IP/host and keyspace from .config file
var configRetriever = kernel.Resolve<IGetEnvironmentConfiguration>();
string clusterLocation = configRetriever.GetSetting(ClusterLocationAppSettingsKey);
kernel.ReleaseComponent(configRetriever);
// Start a cluster builder for connecting to Cassandra
Builder builder = Cluster.Builder();
// Allow multiple comma delimited locations to be specified in the configuration
string[] locations = clusterLocation.Split(new[] { ',' }, StringSplitOptions.RemoveEmptyEntries).Select(l => l.Trim()).ToArray();
foreach (string location in locations)
{
string[] hostAndPort = location.Split(new[] { ':' }, StringSplitOptions.RemoveEmptyEntries);
if (hostAndPort.Length == 1)
{
// Just an IP address or host name
builder = builder.AddContactPoint(hostAndPort[0]);
}
else if (hostAndPort.Length == 2)
{
// IP Address plus host name
var ipEndPoint = new IPEndPoint(IPAddress.Parse(hostAndPort[0]), int.Parse(hostAndPort[1]));
builder = builder.AddContactPoint(ipEndPoint);
}
else
{
throw new InvalidOperationException(string.Format("Unable to parse Cassandra cluster location '{0}' from configuration.", location));
}
}
// Use the Cluster builder to create a cluster
Cluster cluster = builder.Build();
// Use the cluster to connect a session to the appropriate keyspace
ISession session;
try
{
session = cluster.Connect(Keyspace);
}
catch (Exception e)
{
Logger.Error(string.Format("Exception while connecting to keyspace '{0}' using hosts '{1}'", Keyspace, clusterLocation), e);
throw;
}
return session;
}
public void SetUp()
{
kernel = new DefaultKernel();
kernel.AddFacility<StartableFacility>();
kernel.Register(
Component.For<StartableDisposableAndInitializableComponent>()
.LifeStyle.Transient
);
component = kernel.Resolve<StartableDisposableAndInitializableComponent>();
component.DoSomething();
kernel.ReleaseComponent(component);
calledMethods = component.calledMethods;
}
public override void ReleaseController(IController controller)
{
_kernel.ReleaseComponent(controller);
}
public void ReleaseJob(object job)
{
_kernel.ReleaseComponent(job);
}
/// <summary>
/// Releases a component instance
/// </summary>
/// <param name = "instance"></param>
public virtual void Release(object instance)
{
kernel.ReleaseComponent(instance);
}
public void Release(Type type, ISparkView view)
{
kernel.ReleaseComponent(view);
}
public void ReleaseController(IController controller)
{
kernel.ReleaseComponent(controller);
}
public void ReturnJob(IJob job)
{
_kernel.ReleaseComponent((object)job);
}
public bool Transport_OnMessageArrived(CurrentMessageInformation msg)
{
object[] consumers = GatherConsumers(msg);
if (consumers.Length == 0)
{
logger.ErrorFormat("Got message {0}, but had no consumers for it", msg.Message);
return(false);
}
try
{
currentMessage = msg.Message;
foreach (var consumer in consumers)
{
logger.DebugFormat("Invoking consume on {0} for message {1}, from '{2}' to '{3}'",
consumer,
msg.Message,
msg.Source,
msg.Destination);
var sp = Stopwatch.StartNew();
try
{
reflection.InvokeConsume(consumer, msg.Message);
}
catch (Exception e)
{
if (logger.IsDebugEnabled)
{
var message = string.Format("Consumer {0} failed to process message {1}",
consumer,
msg.Message
);
logger.Debug(message, e);
}
throw;
}
finally
{
sp.Stop();
var elapsed = sp.Elapsed;
logger.DebugFormat("Consumer {0} finished processing {1} in {2}", consumer, msg.Message, elapsed);
}
var sagaEntity = consumer as IAccessibleSaga;
if (sagaEntity == null)
{
continue;
}
PersistSagaInstance(sagaEntity);
}
return(true);
}
finally
{
currentMessage = null;
foreach (var consumer in consumers)
{
kernel.ReleaseComponent(consumer);
}
}
}
/// <summary>
/// Called by the <see cref="T:Quartz.IScheduler" /> when a <see cref="T:Quartz.IJobDetail" />
/// was about to be executed (an associated <see cref="T:Quartz.ITrigger" />
/// has occurred), but a <see cref="T:Quartz.ITriggerListener" /> vetoed it's
/// execution.
/// </summary>
/// <param name="context">The context.</param>
/// <param name="token">The token.</param>
/// <returns></returns>
/// <inheritdoc />
/// <seealso cref="M:Quartz.IJobListener.JobToBeExecuted(Quartz.IJobExecutionContext)" />
public virtual async Task JobExecutionVetoed(IJobExecutionContext context, CancellationToken token = default(CancellationToken))
{
await Task.Run(() => _kernel.ReleaseComponent(context.JobInstance), token);
}
public void Release(ControllerContext context, object controller)
{
kernel.ReleaseComponent(controller);
}
public override void ReleaseController(IController controller)
{
(controller as IDisposable)?.Dispose();
kernel.ReleaseComponent(controller);
}
public override void ReleaseController(IController Controller)
{
_Kernel.ReleaseComponent(Controller);
}
public void ReleaseHandler(object handler)
{
_kernel.ReleaseComponent(handler);
}
/// <inheritdoc />
public void ReleaseJob(IJob job)
{
kernel.ReleaseComponent(job);
}
/// <summary>
/// Called when an <see cref="T:System.ServiceModel.InstanceContext"></see> object recycles a service object.
/// </summary>
///
/// <param name="instanceContext">The service's instance context.</param>
/// <param name="instance">The service object to be recycled.</param>
public void ReleaseInstance(InstanceContext instanceContext, object instance)
{
kernel.ReleaseComponent(instance);
}
public void Release(object obj)
{
_kernel.ReleaseComponent(obj);
}
/// <summary>
/// Obtains the interceptors associated with the component.
/// </summary>
/// <param name="kernel">The kernel instance</param>
/// <param name="model">The component model</param>
/// <param name="context">The creation context</param>
/// <returns>interceptors array</returns>
protected IInterceptor[] ObtainInterceptors(IKernel kernel, ComponentModel model, CreationContext context)
{
var interceptors = new List<IInterceptor>();
foreach (var interceptorRef in GetInterceptorsFor(model))
{
var handler = GetInterceptorHandler(interceptorRef, kernel);
if (handler == null)
{
// This should be virtually impossible to happen
// Seriously!
throw new DependencyResolverException(string.Format("The interceptor {0} could not be resolved", interceptorRef));
}
if(handler.IsBeingResolvedInContext(context))
{
throw new DependencyResolverException(
string.Format(
"Cycle detected - interceptor {0} wants to use itself as its interceptor. This usually signifies a bug in custom {1}",
handler.ComponentModel.Name, typeof(IModelInterceptorsSelector).Name));
}
try
{
var contextForInterceptor = RebuildContext(handler.Service, context);
var interceptor = (IInterceptor)handler.Resolve(contextForInterceptor);
interceptors.Add(interceptor);
SetOnBehalfAware(interceptor as IOnBehalfAware, model);
}
catch (Exception e)
{
foreach (var interceptor in interceptors)
{
kernel.ReleaseComponent(interceptor);
}
if(e is InvalidCastException)
{
var message = String.Format(
"An interceptor registered for {0} doesn't implement the {1} interface",
model.Name, typeof(IInterceptor).Name);
throw new DependencyResolverException(message);
}
throw;
}
}
return interceptors.ToArray();
}
public void ReleaseInstance(object instance)
{
_krnl.ReleaseComponent(instance);
}
public void Release(AbstractFilter obj)
{
kernel.ReleaseComponent(obj);
}
/// <summary>
/// Releases the specified dynamic action provider.
/// </summary>
/// <param name="dynamicActionProvider">The dynamic action provider.</param>
public override void Release(IDynamicActionProvider dynamicActionProvider)
{
kernel.ReleaseComponent(dynamicActionProvider);
base.Release(dynamicActionProvider);
}
public override void ReleaseController(IController controller)
{
_kernel.ReleaseComponent(controller); // czyścimy kontroler z worka
}
public void Release <TArguments, TResult>(IHandleQuery <TArguments, TResult> handler)
{
kernel.ReleaseComponent(handler);
}
void ReleaseComponent <T>(T component)
{
_kernel.ReleaseComponent(component);
}
public void Release <TArguments>(IHandleCommand <TArguments> handler) where TArguments : ICommand
{
kernel.ReleaseComponent(handler);
}
public void Release <T>(T obj)
{
_kernel.ReleaseComponent(obj);
}
public void Release(IPresenter presenter)
{
presenterKernel.ReleaseComponent(presenter);
}
public void ReleaseController(IController controller)
{
kernel.ReleaseComponent(controller);
DisposeScopedLifestyleIfRequired();
OnAfterControllerReleased(controller);
}
private static INotificationEndPoint CreateNotificationEndPoint(IKernel kernel)
{
var cloudMediaContext = kernel.Resolve<CloudMediaContext>();
var cloudQueueClient = kernel.Resolve<CloudQueueClient>();
try
{
// ReSharper disable once ReplaceWithSingleCallToFirstOrDefault
INotificationEndPoint endpoint = cloudMediaContext.NotificationEndPoints
.Where(ep => ep.Name == UploadConfig.NotificationQueueName)
.FirstOrDefault();
if (endpoint != null)
return endpoint;
// Make sure the queue exists in Azure Storage
var notificationQueue = cloudQueueClient.GetQueueReference(UploadConfig.NotificationQueueName);
notificationQueue.CreateIfNotExists();
// Create the endpoint
return cloudMediaContext.NotificationEndPoints.Create(UploadConfig.NotificationQueueName, NotificationEndPointType.AzureQueue,
UploadConfig.NotificationQueueName);
}
finally
{
kernel.ReleaseComponent(cloudMediaContext);
kernel.ReleaseComponent(cloudQueueClient);
}
}
public void Release <TArguments, TResult>(IHandleQueryAsync <TArguments, TResult> handler) where TArguments : IQuery
{
kernel.ReleaseComponent(handler);
}
public override void Release(IFilter filter)
{
kernel.ReleaseComponent(filter);
base.Release(filter);
}
public void Release <T>(T obj)
{
_container.ReleaseComponent(obj);
}
public void Release(IMessageHandler messageHandler)
{
kernel.ReleaseComponent(messageHandler);
}
