/// <summary>
/// Bind to a collector.
/// </summary>
/// <typeparam name="TMessage"></typeparam>
/// <param name="buildFromAttribute"></param>
/// <returns></returns>
public void BindToCollector <TMessage>(
IAsyncConverter <TAttribute, IAsyncCollector <TMessage> > buildFromAttribute)
{
var pm = PatternMatcher.New(buildFromAttribute);
BindToCollector <TMessage>(pm);
}
/// <summary>
/// Add a converter for the given Source to Destination conversion.
/// </summary>
/// <typeparam name="TSource">Source type.</typeparam>
/// <typeparam name="TDestination">Destination type.</typeparam>
/// <param name="converterInstance">Instance of an object with convert methods on it.</param>
public TThis AddConverter <TSource, TDestination>(
IAsyncConverter <TSource, TDestination> converterInstance)
{
var patternMatcher = PatternMatcher.New(converterInstance);
return(AddConverterBuilder <TSource, TDestination>(patternMatcher));
}
/// <summary>
/// Bind an attribute to the given input, using the converter manager.
/// </summary>
/// <typeparam name="TType"></typeparam>
/// <param name="builderInstance"></param>
/// <returns></returns>
public void BindToInput <TType>(IAsyncConverter <TAttribute, TType> builderInstance)
{
var bf = _parent.BindingFactory;
var pm = PatternMatcher.New(builderInstance);
var rule = new BindToInputBindingProvider <TAttribute, TType>(bf.NameResolver, bf.ConverterManager, pm);
Bind(rule);
}
async Task <CloudQueue> IAsyncConverter <QueueAttribute, CloudQueue> .ConvertAsync(
QueueAttribute attrResolved,
CancellationToken cancellation)
{
IAsyncConverter <QueueAttribute, IStorageQueue> convert = this;
var queue = await convert.ConvertAsync(attrResolved, cancellation);
return(queue.SdkObject);
}
/// <summary>
/// Bind to a collector.
/// </summary>
/// <typeparam name="TMessage"></typeparam>
/// <param name="buildFromAttribute"></param>
/// <returns></returns>
public void BindToCollector <TMessage>(
IAsyncConverter <TAttribute, IAsyncCollector <TMessage> > buildFromAttribute)
{
var bf = _parent.BindingFactory;
var pm = PatternMatcher.New(buildFromAttribute);
var rule = new AsyncCollectorBindingProvider <TAttribute, TMessage>(bf.NameResolver, bf.ConverterManager, pm);
Bind(rule);
}
public MicrosoftGraphExtensionConfigProvider(IOptions <GraphOptions> options,
ILoggerFactory loggerFactory,
IGraphServiceClientProvider graphClientProvider,
INameResolver appSettings,
IAsyncConverter <TokenBaseAttribute, string> tokenConverter,
IGraphSubscriptionStore subscriptionStore)
{
_options = options.Value;
_options.SetAppSettings(appSettings);
_graphServiceClientManager = new GraphServiceClientManager(_options, tokenConverter, graphClientProvider);
_subscriptionStore = subscriptionStore;
_loggerFactory = loggerFactory;
}
public async Task TestUnsubscribe()
{
var ext = new EventGridExtensionConfig();
var host = TestHelpers.NewHost <MyProg1>(ext);
await host.StartAsync(); // add listener
var request = CreateUnsubscribeRequest("TestEventGrid");
IAsyncConverter <HttpRequestMessage, HttpResponseMessage> handler = ext;
var response = await handler.ConvertAsync(request, CancellationToken.None);
Assert.Equal(HttpStatusCode.Accepted, response.StatusCode);
}
public override FuncAsyncConverter Execute(object instance)
{
IAsyncConverter <TSrc, TDest> converter = (IAsyncConverter <TSrc, TDest>)instance;
FuncAsyncConverter func = async(input, attr, ctx) =>
{
TSrc src = (TSrc)input;
var cts = ctx == null ? CancellationToken.None : ctx.CancellationToken;
TDest result = await converter.ConvertAsync(src, cts);
return(result);
};
return(func);
}
public override Func <object, object> Work(object instance)
{
IAsyncConverter <TSrc, TDest> converter = (IAsyncConverter <TSrc, TDest>)instance;
Func <object, object> func = (input) =>
{
TSrc src = (TSrc)input;
Task <TDest> resultTask = Task.Run(() => converter.ConvertAsync(src, CancellationToken.None));
TDest result = resultTask.GetAwaiter().GetResult();
return(result);
};
return(func);
}
public async Task TestDispatch()
{
var ext = new EventGridExtensionConfig();
var host = TestHelpers.NewHost <MyProg1>(ext);
await host.StartAsync(); // add listener
var request = CreateDispatchRequest("TestEventGrid",
JObject.Parse(@"{'subject':'one','data':{'prop':'alpha'}}"),
JObject.Parse(@"{'subject':'two','data':{'prop':'beta'}}"));
IAsyncConverter <HttpRequestMessage, HttpResponseMessage> handler = ext;
var response = await handler.ConvertAsync(request, CancellationToken.None);
// Verify that the user function was dispatched twice, in order.
// Also verifies each instance gets its own proper binding data (from FakePayload.Prop)
Assert.Equal("[Dispatch:one, alpha][Dispatch:two, beta]", _log.ToString());
// TODO - Verify that we return from webhook before the dispatch is finished
// https://github.com/Azure/azure-functions-eventgrid-extension/issues/10
Assert.Equal(HttpStatusCode.Accepted, response.StatusCode);
}
// T1,T2 may be open types.
public static PatternMatcher New <T1, T2>(IAsyncConverter <T1, T2> instance)
{
return(new CreateFromInstance(instance));
}
public OutputConverter(IAsyncConverter <TInput, ServiceBusEntity> innerConverter)
{
_innerConverter = innerConverter;
}
public BlobOutputConverter(IAsyncConverter <TInput, IStorageBlob> innerConverter)
{
_innerConverter = innerConverter;
}
public BlobOutputConverter(IAsyncConverter <TInput, BlobBaseClient> innerConverter)
{
_innerConverter = innerConverter;
}
public GraphServiceClientManager(GraphOptions options, IAsyncConverter <TokenBaseAttribute, string> tokenProvider, IGraphServiceClientProvider clientProvider)
{
_tokenProvider = tokenProvider;
_clientProvider = clientProvider;
_options = options;
}
public ConverterArgumentBinding(IAsyncConverter <Message, T> converter)
{
_converter = converter;
}
public BlobOutputConverter(IAsyncConverter <TInput, ICloudBlob> innerConverter)
{
_innerConverter = innerConverter;
}
/// <summary>
/// Bind an attribute to a stream. This ensures the stream is flushed after the user function returns.
/// It uses the attribute's Access property to determine direction (Read/Write).
/// It includes rules for additional types of TextReader,string, byte[], and TextWriter,out string, out byte[].
/// </summary>
/// <param name="builderInstance"></param>
/// <param name="fileAccess"></param>
public void BindToStream(IAsyncConverter <TAttribute, Stream> builderInstance, FileAccess fileAccess)
{
var pm = PatternMatcher.New(builderInstance);
BindToStream(pm, fileAccess);
}
/// <summary>
/// Bind an attribute to the given input, using the converter manager.
/// </summary>
/// <typeparam name="TType"></typeparam>
/// <param name="builderInstance"></param>
/// <returns></returns>
public FluentBinder BindToInput <TType>(IAsyncConverter <TAttribute, TType> builderInstance)
{
var pm = PatternMatcher.New(builderInstance);
return(BindToInput <TType>(pm));
}
public ConverterArgumentBindingProvider(IAsyncConverter <BrokeredMessage, T> converter)
{
_converter = converter;
}
