static void Main(string[] args)
{
var config = new JobHostConfiguration();
config.DashboardConnectionString = null;
// apply config before creating the host.
var cloudToDeviceExtension = new IoTHubExtension.Config.IoTCloudToDeviceExtension();
config.AddExtension(cloudToDeviceExtension);
var directMethodExtension = new IoTHubExtension.Config.IoTDirectMethodExtension();
config.AddExtension(directMethodExtension);
var setDeviceTwinExtension = new IoTHubExtension.Config.IoTSetDeviceTwinExtension();
config.AddExtension(setDeviceTwinExtension);
var getDeviceTwinExtension = new IoTHubExtension.Config.IoTGetDeviceTwinExtension();
config.AddExtension(getDeviceTwinExtension);
// Debug diagnostics!
config.CreateMetadataProvider().DebugDumpGraph(Console.Out);
var host = new JobHost(config);
//var method = typeof(Functions).GetMethod("Dummy");
//Test some invocations.
//var method = typeof(Functions).GetMethod("WriteMessageFromC2D");
//host.Call(method);
var method = typeof(Functions).GetMethod("WriteMessageFromC2DArg");
host.Call(method, new { deviceId = "receiverBob" });
//Test some invocations.
method = typeof(Functions).GetMethod("DirectInvokeMethod");
host.Call(method, new { deviceId = "receiverAlice" });
//// Test some invocations.
method = typeof(Functions).GetMethod("SetDeviceTwin");
host.Call(method, new { deviceId = "receiverBob" });
//// Test some invocations.
method = typeof(Functions).GetMethod("GetDeviceTwinTwinObject");
host.Call(method, new { deviceId = "receiverBob", messageId = "123" });
// host.RunAndBlock();
}
public static JobHost NewHost <T>(EventGridExtensionConfig ext = null)
{
JobHostConfiguration config = new JobHostConfiguration();
config.HostId = Guid.NewGuid().ToString("n");
config.StorageConnectionString = null;
config.DashboardConnectionString = null;
config.TypeLocator = new FakeTypeLocator <T>();
config.AddExtension(ext ?? new EventGridExtensionConfig());
config.AddExtension(new TestExtensionConfig());
var host = new JobHost(config);
return(host);
}
public void Test()
{
MyProg prog = new MyProg();
var activator = new FakeActivator();
activator.Add(prog);
JobHostConfiguration config = TestHelpers.NewConfig <MyProg>(activator);
var ext = new TestExtension();
config.AddExtension(ext);
var host = new TestJobHost <MyProg>(config);
IJobHostMetadataProvider metadataProvider = host.CreateMetadataProvider();
Assert.Equal(1, ext._counter);
// Callable
host.Call("Test");
Assert.Equal(1, ext._counter);
// Fact that we registered a Widget converter is enough to add the assembly
Assembly asm;
bool resolved;
resolved = metadataProvider.TryResolveAssembly(typeof(Widget).Assembly.GetName().Name, out asm);
Assert.True(resolved);
Assert.Same(asm, typeof(Widget).Assembly);
// check with full name
resolved = metadataProvider.TryResolveAssembly(typeof(Widget).Assembly.GetName().FullName, out asm);
Assert.True(resolved);
Assert.Same(asm, typeof(Widget).Assembly);
// This requires the target attribute to be unique within the assembly.
var attrType = metadataProvider.GetAttributeTypeFromName("Test9");
Assert.Equal(typeof(Test9Attribute), attrType);
// JObject --> Attribute
var attr = GetAttr <Test9Attribute>(metadataProvider, new { Flag = "xyz" });
Assert.Equal("xyz", attr.Flag);
// Getting default type.
var defaultType = metadataProvider.GetDefaultType(attr, FileAccess.Read, null);
Assert.Equal(typeof(JObject), defaultType);
// If we have no match for output, we'll try IAsyncCollector<string>
Assert.Equal(typeof(IAsyncCollector <string>), metadataProvider.GetDefaultType(attr, FileAccess.Write, typeof(object)));
}
// 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 void Test()
{
MyProg prog = new MyProg();
var activator = new FakeActivator();
activator.Add(prog);
JobHostConfiguration config = TestHelpers.NewConfig <MyProg>(activator);
var ext = new TestExtension();
config.AddExtension(ext);
IJobHostMetadataProvider tooling = config.CreateMetadataProvider();
Assert.Equal(1, ext._counter);
// Callable
var host = new TestJobHost <MyProg>(config);
host.Call("Test");
Assert.Equal(1, ext._counter);
// Fact that we registered a Widget converter is enough to add the assembly
Assembly asm;
bool resolved;
resolved = tooling.TryResolveAssembly(typeof(Widget).Assembly.GetName().Name, out asm);
Assert.True(resolved);
Assert.Same(asm, typeof(Widget).Assembly);
// check with full name
resolved = tooling.TryResolveAssembly(typeof(Widget).Assembly.GetName().FullName, out asm);
Assert.True(resolved);
Assert.Same(asm, typeof(Widget).Assembly);
var attrType = tooling.GetAttributeTypeFromName("Test");
Assert.Equal(typeof(TestAttribute), attrType);
// JObject --> Attribute
var attr = GetAttr <TestAttribute>(tooling, new { Flag = "xyz" });
Assert.Equal("xyz", attr.Flag);
// Getting default type.
var defaultType = tooling.GetDefaultType(attr, FileAccess.Read, null);
Assert.Equal(typeof(JObject), defaultType);
Assert.Throws <InvalidOperationException>(() => tooling.GetDefaultType(attr, FileAccess.Write, typeof(object)));
}
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);
}
public SendGridScriptBindingProviderTests()
{
JobHostConfiguration config = new JobHostConfiguration();
config.AddExtension(new SendGridConfiguration());
TestTraceWriter traceWriter = new TestTraceWriter(TraceLevel.Verbose);
JObject hostMetadata = new JObject();
var provider = new GeneralScriptBindingProvider(config, hostMetadata, traceWriter);
provider.CompleteInitialization();
_provider = provider;
}
static void Main(string[] args)
{
Console.WriteLine("Hello World!");
var config = new JobHostConfiguration();
config.DashboardConnectionString = null;
config.HostId = "sample";
// Register the dropbox extension
if (args.Length != 2)
{
Console.WriteLine(@"Set arg[0] to the folder name, arg[1] to Dropbox OAuth string");
return;
}
var folderName = args[0];
var oauthToken = args[1];
var ext = new DropboxExtension
{
Connection = oauthToken
};
config.AddExtension(ext);
// Invoke some calls that bind to the extension.
var param = new Dictionary <string, object>
{
{ "folder", folderName },
{ "name", "test" }
};
var host = new JobHost(config);
host.CallAsync(nameof(SimpleClient)).Wait();
host.CallAsync(nameof(SimpleWrite), param).Wait();
host.CallAsync(nameof(SimpleWriteAsReturn), param).Wait();
host.CallAsync(nameof(SimpleRead), param).Wait();
host.CallAsync(nameof(CopyExample), param).Wait();
}
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 TestServices()
{
// Test configuration similar to how ScriptRuntime works.
// - config is created and immediatey passed to a JobHost ctor
// - config is then initialized, including adding extensions
// - extensions may register their own services.
JobHostConfiguration config = new JobHostConfiguration();
var host = new JobHost(config);
var lockManager = config.GetService <IDistributedLockManager>();
Assert.Null(lockManager); // Not initialized yet.
var nameResolver = new FakeNameResolver();
config.AddExtension(new TestExtension()); // this extension will add services.
config.AddService <INameResolver>(nameResolver);
// Now succeeds when called on JobHost instead of Config object.
lockManager = host.Services.GetService <IDistributedLockManager>();
Assert.NotNull(lockManager);
Assert.IsType <TestLockManager>(lockManager); // verify it's our custom type
}
// Static initialization. Returns a service provider with some new services initialized.
// The new services:
// - can retrieve static config like binders and converters; but the listeners haven't yet started.
// - can be flowed into the runtime initialization to get a JobHost spun up and running.
// This is just static initialization and should not need to make any network calls,
// and so this method should not need to be async.
// This can be called multiple times on a config, which is why it returns a new ServiceProviderWrapper
// instead of modifying the config.
public static ServiceProviderWrapper CreateStaticServices(this JobHostConfiguration config)
{
var services = new ServiceProviderWrapper(config);
var consoleProvider = services.GetService <IConsoleProvider>();
var nameResolver = services.GetService <INameResolver>();
IWebJobsExceptionHandler exceptionHandler = services.GetService <IWebJobsExceptionHandler>();
IQueueConfiguration queueConfiguration = services.GetService <IQueueConfiguration>();
var blobsConfiguration = config.Blobs;
IStorageAccountProvider storageAccountProvider = services.GetService <IStorageAccountProvider>();
IBindingProvider bindingProvider = services.GetService <IBindingProvider>();
SingletonManager singletonManager = services.GetService <SingletonManager>();
IHostIdProvider hostIdProvider = services.GetService <IHostIdProvider>();
var hostId = config.HostId;
if (hostId != null)
{
hostIdProvider = new FixedHostIdProvider(hostId);
}
// Need a deferred getter since the IFunctionIndexProvider service isn't created until later.
Func <IFunctionIndexProvider> deferredGetter = () => services.GetService <IFunctionIndexProvider>();
if (hostIdProvider == null)
{
hostIdProvider = new DynamicHostIdProvider(storageAccountProvider, deferredGetter);
}
services.AddService <IHostIdProvider>(hostIdProvider);
AzureStorageDeploymentValidator.Validate();
IExtensionTypeLocator extensionTypeLocator = services.GetService <IExtensionTypeLocator>();
if (extensionTypeLocator == null)
{
extensionTypeLocator = new ExtensionTypeLocator(services.GetService <ITypeLocator>());
services.AddService <IExtensionTypeLocator>(extensionTypeLocator);
}
ContextAccessor <IMessageEnqueuedWatcher> messageEnqueuedWatcherAccessor = new ContextAccessor <IMessageEnqueuedWatcher>();
services.AddService(messageEnqueuedWatcherAccessor);
ContextAccessor <IBlobWrittenWatcher> blobWrittenWatcherAccessor = new ContextAccessor <IBlobWrittenWatcher>();
ISharedContextProvider sharedContextProvider = new SharedContextProvider();
// Create a wrapper TraceWriter that delegates to both the user
// TraceWriters specified via config (if present), as well as to Console
TraceWriter trace = new ConsoleTraceWriter(config.Tracing, consoleProvider.Out);
services.AddService <TraceWriter>(trace);
// Add built-in extensions
var metadataProvider = new JobHostMetadataProvider(deferredGetter);
metadataProvider.AddAttributesFromAssembly(typeof(TableAttribute).Assembly);
var exts = config.GetExtensions();
bool builtinsAdded = exts.GetExtensions <IExtensionConfigProvider>().OfType <TableExtension>().Any();
if (!builtinsAdded)
{
config.AddExtension(new TableExtension());
config.AddExtension(new QueueExtension());
}
ExtensionConfigContext context = new ExtensionConfigContext
{
Config = config,
Trace = trace,
PerHostServices = services
};
InvokeExtensionConfigProviders(context);
// After this point, all user configuration has been set.
if (singletonManager == null)
{
var logger = config.LoggerFactory?.CreateLogger(LogCategories.Singleton);
IDistributedLockManager lockManager = services.GetService <IDistributedLockManager>();
if (lockManager == null)
{
lockManager = new BlobLeaseDistributedLockManager(
storageAccountProvider,
trace,
logger);
services.AddService <IDistributedLockManager>(lockManager);
}
singletonManager = new SingletonManager(
lockManager,
config.Singleton,
trace,
exceptionHandler,
config.LoggerFactory,
hostIdProvider,
services.GetService <INameResolver>());
services.AddService <SingletonManager>(singletonManager);
}
IExtensionRegistry extensions = services.GetExtensions();
ITriggerBindingProvider triggerBindingProvider = DefaultTriggerBindingProvider.Create(nameResolver,
storageAccountProvider, extensionTypeLocator, hostIdProvider, queueConfiguration, blobsConfiguration, exceptionHandler,
messageEnqueuedWatcherAccessor, blobWrittenWatcherAccessor, sharedContextProvider, extensions, singletonManager, trace, config.LoggerFactory);
services.AddService <ITriggerBindingProvider>(triggerBindingProvider);
if (bindingProvider == null)
{
bindingProvider = DefaultBindingProvider.Create(nameResolver, config.LoggerFactory, storageAccountProvider, extensionTypeLocator, blobWrittenWatcherAccessor, extensions);
services.AddService <IBindingProvider>(bindingProvider);
}
var converterManager = (ConverterManager)config.ConverterManager;
metadataProvider.Initialize(bindingProvider, converterManager, exts);
services.AddService <IJobHostMetadataProvider>(metadataProvider);
return(services);
}
static int Main(string[] args)
{
Console.WriteLine("WebJobs BYOB Extension Analyzer v0.1");
var config = new JobHostConfiguration();
config.DashboardConnectionString = null;
if (args.Length == 0)
{
Console.WriteLine("Error: arg0 should be path to a WebJobs extension (either .dll or .csproj)");
return(1);
}
var path = args[0];
var webjobsAsssembly = typeof(JobHostConfiguration).Assembly;
Assembly asm = (path == "builtin") ? webjobsAsssembly : Load(path);
var types = asm.GetTypes();
Console.WriteLine("=============================");
foreach (var type in asm.GetTypes())
{
if (typeof(IExtensionConfigProvider).IsAssignableFrom(type) && !type.IsInterface)
{
Console.WriteLine("Found extension: {0}", type.FullName);
try
{
var obj = Activator.CreateInstance(type);
var extension = (IExtensionConfigProvider)obj;
config.AddExtension(extension);
}
catch (Exception e)
{
Console.WriteLine("ERROR: Failed to instantiate extension: " + e.Message);
}
}
}
Console.WriteLine();
// This will run the extension's Initialize() method and build up the binding graph.
var host = new JobHost(config);
var metadata = (JobHostMetadataProvider)host.Services.GetService(typeof(IJobHostMetadataProvider));
var rules = metadata.GetRules();
// Limit to just this extension
if (asm != webjobsAsssembly)
{
rules = rules.Where(rule => rule.SourceAttribute.Assembly == asm).ToArray();
}
HashSet <Type> attrs = new HashSet <Type>();
foreach (var rule in rules)
{
attrs.Add(rule.SourceAttribute);
}
DumpAttributes(attrs);
Console.WriteLine("--------");
Console.WriteLine("Binding Rules:");
Console.WriteLine();
DumpRule(rules, Console.Out);
return(0);
}
public DispatchQueueEndToEndTests(ITestOutputHelper output)
{
_output = output;
_hostConfiguration = new JobHostConfiguration();
_hostConfiguration.AddExtension(new DispatchQueueTestConfig());
}
