public void RegisterExtension(Type type, object instance)
{
if (type == null)
{
throw new ArgumentNullException("type");
}
if (instance == null)
{
throw new ArgumentNullException("instance");
}
if (!type.IsAssignableFrom(instance.GetType()))
{
throw new ArgumentOutOfRangeException("instance");
}
if (_tooling != null)
{
IExtensionConfigProvider extension = instance as IExtensionConfigProvider;
if (extension != null)
{
_tooling.AddExtension(extension);
}
}
ConcurrentBag<object> instances = _registry.GetOrAdd(type, (t) => new ConcurrentBag<object>());
instances.Add(instance);
}
public static ExtensionInfo FromInstance(IExtensionConfigProvider extension)
{
if (extension == null)
{
throw new ArgumentNullException(nameof(extension));
}
return(GetExtensionInfo(extension.GetType()));
}
// Helper to create a JobHostConfiguraiton from a set of services.
// Default config, pure-in-memory
// Default is pure-in-memory, good for unit testing.
public static JobHostConfiguration NewConfig(
Type functions,
params object[] services
)
{
JobHostConfiguration config = new JobHostConfiguration()
{
TypeLocator = new FakeTypeLocator(functions),
// Pure in-memory, no storage.
HostId = Guid.NewGuid().ToString("n"),
DashboardConnectionString = null,
StorageConnectionString = null
};
IExtensionRegistry extensions = config.GetService <IExtensionRegistry>();
foreach (var obj in services)
{
IStorageAccount account = obj as IStorageAccount;
if (account != null)
{
IStorageAccountProvider storageAccountProvider = new FakeStorageAccountProvider
{
StorageAccount = account
};
config.ContextFactory = new JobHostContextFactory(storageAccountProvider, new DefaultConsoleProvider(), config);
continue;
}
INameResolver nameResolver = obj as INameResolver;
if (nameResolver != null)
{
config.NameResolver = nameResolver;
continue;
}
IJobActivator jobActivator = obj as IJobActivator;
if (jobActivator != null)
{
config.JobActivator = jobActivator;
continue;
}
IExtensionConfigProvider extension = obj as IExtensionConfigProvider;
if (extension != null)
{
extensions.RegisterExtension <IExtensionConfigProvider>(extension);
continue;
}
throw new InvalidOperationException("Test bug: Unrecognized type: " + obj.GetType().FullName);
}
return(config);
}
// Load a single extension
private void LoadExtension(IExtensionConfigProvider instance, string locationHint = null)
{
JobHostConfiguration config = _config.HostConfig;
var type = instance.GetType();
string name = type.Name;
string msg = $"Loaded custom extension: {name} from '{locationHint}'";
_logger.LogInformation(msg);
config.AddExtension(instance);
}
public static JobHost NewHost <T>(IExtensionConfigProvider ext)
{
JobHostConfiguration config = new JobHostConfiguration();
config.HostId = Guid.NewGuid().ToString("n");
config.StorageConnectionString = null;
config.DashboardConnectionString = null;
config.TypeLocator = new FakeTypeLocator <T>();
config.AddExtension(ext);
var host = new JobHost(config);
return(host);
}
// Glue to initialize a JobHost with the correct config and invoke the Test method.
// Config also has the program on it.
private void TestWorker <TConfig>() where TConfig : IExtensionConfigProvider, ITest <TConfig>, new()
{
var prog = new TConfig();
var jobActivator = new FakeActivator();
jobActivator.Add(prog);
IExtensionConfigProvider ext = prog;
var host = TestHelpers.NewJobHost <TConfig>(jobActivator, ext);
ITest <TConfig> test = prog;
test.Test(host);
}
// Exposed to extensions to get the URL for their http handler.
public Uri GetUrl(IExtensionConfigProvider extension)
{
var extensionType = extension.GetType();
var handler = extension as HttpHandler;
if (handler == null)
{
throw new InvalidOperationException($"Extension must implement IAsyncConverter<HttpRequestMessage, HttpResponseMessage> in order to receive webhooks");
}
string name = extensionType.Name;
_customHttpHandlers[name] = handler;
return(GetExtensionWebHookRoute(name));
}
// Glue to initialize a JobHost with the correct config and invoke the Test method.
// Config also has the program on it.
private void TestWorker <TConfig>() where TConfig : IExtensionConfigProvider, ITest <TConfig>, new()
{
var prog = new TConfig();
var jobActivator = new FakeActivator();
jobActivator.Add(prog);
var appSettings = new FakeNameResolver();
appSettings.Add("y", "123");
IExtensionConfigProvider ext = prog;
var host = TestHelpers.NewJobHost <TConfig>(jobActivator, ext, appSettings);
ITest <TConfig> test = prog;
test.Test(host);
}
private bool LoadIfExtensionType(Type extensionType, string locationHint)
{
if (!typeof(IExtensionConfigProvider).IsAssignableFrom(extensionType))
{
return(false);
}
if (IsExtensionLoaded(extensionType))
{
return(false);
}
IExtensionConfigProvider instance = (IExtensionConfigProvider)Activator.CreateInstance(extensionType);
LoadExtension(instance, locationHint);
return(true);
}
// Exposed to extensions to get the URL for their http handler.
public Uri GetUrl(IExtensionConfigProvider extension)
{
var handler = extension as HttpHandler;
if (handler == null)
{
throw new InvalidOperationException("Extension must implement IAsyncConverter<HttpRequestMessage, HttpResponseMessage> in order to receive webhooks");
}
// use the config section moniker for the extension as the URL name
var extensionType = extension.GetType();
var attrib = extensionType.GetCustomAttribute <ExtensionAttribute>();
string name = (attrib?.ConfigurationSection ?? extensionType.Name).ToLowerInvariant();
_customHttpHandlers[name] = handler;
return(GetExtensionWebHookRoute(name));
}
private void LoadExtension(IExtensionConfigProvider extensionConfigProvider, string locationHint = null)
{
var extensionConfigProviderType = extensionConfigProvider.GetType();
string extensionName = extensionConfigProviderType.Name;
string msg = null;
if (!string.IsNullOrEmpty(locationHint))
{
msg = $"Loaded binding extension '{extensionName}' from '{locationHint}'";
}
else
{
msg = $"Loaded custom extension '{extensionName}'";
}
_traceWriter.Info(msg);
_startupLogger.LogInformation(msg);
_config.HostConfig.AddExtension(extensionConfigProvider);
}
// Glue to initialize a JobHost with the correct config and invoke the Test method.
// Config also has the program on it.
private void TestWorker <TConfig>() where TConfig : IExtensionConfigProvider, ITest <TConfig>, new()
{
var prog = new TConfig();
var jobActivator = new FakeActivator();
jobActivator.Add(prog);
IExtensionConfigProvider ext = prog;
IHost host = new HostBuilder()
.ConfigureDefaultTestHost <TConfig>(b =>
{
b.AddExtension(ext);
}, activator: jobActivator)
.Build();
ITest <TConfig> test = prog;
test.Test(host.GetJobHost <TConfig>());
}
private void LoadExtensions(JobHostConfiguration hostConfig, Assembly assembly, string locationHint)
{
// Traverseing the exported types will cause type loads and possible type-load failures.
foreach (var type in assembly.ExportedTypes)
{
if (type.IsAbstract || !typeof(IExtensionConfigProvider).IsAssignableFrom(type))
{
continue;
}
try
{
IExtensionConfigProvider instance = (IExtensionConfigProvider)Activator.CreateInstance(type);
hostConfig.AddExtension(instance);
}
catch (Exception e)
{
// this.TraceWriter.Error($"Failed to load custom extension {type} from '{locationHint}'", e);
}
}
}
public void LoadBuiltinExtensions(IEnumerable <string> bindingTypes)
{
foreach (var bindingType in bindingTypes)
{
string assemblyQualifiedTypeName;
if (_builtinBindingTypes.TryGetValue(bindingType, out assemblyQualifiedTypeName))
{
Type typeExtension = Type.GetType(assemblyQualifiedTypeName);
if (typeExtension == null)
{
string errorMsg = $"Can't find binding provider '{assemblyQualifiedTypeName}' for '{bindingType}'";
_traceWriter.Error(errorMsg);
_startupLogger?.LogError(errorMsg);
}
else
{
IExtensionConfigProvider extension = (IExtensionConfigProvider)Activator.CreateInstance(typeExtension);
LoadExtension(extension);
}
}
}
}
public static async Task ExecuteFunction <FunctionType, BindingType>(ICognitiveServicesClient client, string functionReference)
{
IExtensionConfigProvider binding = null;
if (typeof(BindingType) == typeof(VisionAnalysisBinding))
{
binding = new VisionAnalysisBinding();
}
if (typeof(BindingType) == typeof(VisionDescribeBinding))
{
binding = new VisionDescribeBinding();
}
if (typeof(BindingType) == typeof(VisionHandwritingBinding))
{
binding = new VisionHandwritingBinding();
}
if (typeof(BindingType) == typeof(VisionOcrBinding))
{
binding = new VisionOcrBinding();
}
if (typeof(BindingType) == typeof(VisionThumbnailBinding))
{
binding = new VisionThumbnailBinding();
}
(binding as IVisionBinding).Client = client;
var jobHost = NewHost <FunctionType>(binding);
var args = new Dictionary <string, object>();
await jobHost.CallAsync(functionReference, args);
}
Uri IWebHookProvider.GetUrl(IExtensionConfigProvider extension)
{
// Called by configuration registration. URI here doesn't matter.
return(new Uri("http://localhost"));
}
public static void AddServices(this JobHostConfiguration config, params object[] services)
{
// Set extensionRegistry first since other services may depend on it.
foreach (var obj in services)
{
IExtensionRegistry extensionRegistry = obj as IExtensionRegistry;
if (extensionRegistry != null)
{
config.AddService <IExtensionRegistry>(extensionRegistry);
break;
}
}
IExtensionRegistry extensions = config.GetService <IExtensionRegistry>();
var types = new Type[] {
typeof(IAsyncCollector <FunctionInstanceLogEntry>),
typeof(IHostInstanceLoggerProvider),
typeof(IFunctionInstanceLoggerProvider),
typeof(IFunctionOutputLoggerProvider),
typeof(IConsoleProvider),
typeof(ITypeLocator),
typeof(IWebJobsExceptionHandler),
typeof(INameResolver),
typeof(IJobActivator),
typeof(IExtensionTypeLocator),
typeof(SingletonManager),
typeof(IHostIdProvider),
typeof(IQueueConfiguration),
typeof(IExtensionRegistry),
typeof(IDistributedLockManager),
typeof(ILoggerFactory),
typeof(IFunctionIndexProvider) // set to unit test indexing.
};
foreach (var obj in services)
{
if (obj == null ||
obj is ILoggerProvider)
{
continue;
}
IStorageAccountProvider storageAccountProvider = obj as IStorageAccountProvider;
IStorageAccount account = obj as IStorageAccount;
if (account != null)
{
storageAccountProvider = new FakeStorageAccountProvider
{
StorageAccount = account
};
}
if (storageAccountProvider != null)
{
config.AddService <IStorageAccountProvider>(storageAccountProvider);
continue;
}
// A new extension
IExtensionConfigProvider extension = obj as IExtensionConfigProvider;
if (extension != null)
{
extensions.RegisterExtension <IExtensionConfigProvider>(extension);
continue;
}
// A function filter
if (obj is IFunctionInvocationFilter)
{
extensions.RegisterExtension <IFunctionInvocationFilter>((IFunctionInvocationFilter)obj);
continue;
}
if (obj is IFunctionExceptionFilter)
{
extensions.RegisterExtension <IFunctionExceptionFilter>((IFunctionExceptionFilter)obj);
continue;
}
// basic pattern.
bool ok = false;
foreach (var type in types)
{
if (type.IsAssignableFrom(obj.GetType()))
{
config.AddService(type, obj);
ok = true;
break;
}
}
if (ok)
{
continue;
}
throw new InvalidOperationException("Test bug: Unrecognized type: " + obj.GetType().FullName);
}
}
public static IWebJobsExtensionBuilder AddExtension(this IWebJobsBuilder builder, IExtensionConfigProvider instance)
{
if (instance == null)
{
throw new ArgumentNullException(nameof(instance));
}
builder.Services.TryAddEnumerable(ServiceDescriptor.Singleton <IExtensionConfigProvider>(instance));
return(new WebJobsExtensionBuilder(builder.Services, ExtensionInfo.FromInstance(instance)));
}
/// <summary>
/// Registers the specified <see cref="IExtensionConfigProvider"/>
/// </summary>
/// <param name="config">The <see cref="JobHostConfiguration"/> to register the extension with.</param>
/// <param name="extension">The extension to register.</param>
public static void RegisterExtensionConfigProvider(this JobHostConfiguration config, IExtensionConfigProvider extension)
{
if (config == null)
{
throw new ArgumentNullException("config");
}
if (extension == null)
{
throw new ArgumentNullException("extension");
}
config.RegisterExtension(extension);
}
// Do extra bookkeeping for a new extension.
public void AddExtension(IExtensionConfigProvider extension)
{
AddAttributesFromAssembly(extension.GetType().Assembly);
AddAssembly(extension.GetType());
}
/// <summary>
/// Add an extension to register new binding attributes and converters.
/// </summary>
/// <param name="extension"></param>
public void AddExtension(IExtensionConfigProvider extension)
{
var exts = this.GetExtensions();
exts.RegisterExtension <IExtensionConfigProvider>(extension);
}
