public FtpBinding(FtpConfiguration config, ParameterInfo parameter, TraceWriter trace, FtpAttribute ftpAttribute)
{
_config = config;
_parameter = parameter;
_trace = trace;
_ftpAttribute = ftpAttribute;
}
/// <summary>
/// This WebHook declares its route, and is invoked by POST requests
/// to http://localhost:{port}/Sample/HookB.
/// </summary>
public static async Task HookB(
[WebHookTrigger("Sample/HookB")] HttpRequestMessage request,
TraceWriter trace)
{
string body = await request.Content.ReadAsStringAsync();
trace.Info(string.Format("HookB invoked! Body: {0}", body));
}
public CacheReceiver(RedisConfiguration config, string channelOrKey, string lastValueKeyName, TraceWriter trace)
{
_config = config;
_channelOrKey = channelOrKey;
_lastValueKeyName = lastValueKeyName;
_trace = trace;
}
// On Timer, grab items from RSS Feed
public void RSSFeedProcessor(
[TimerTrigger("0 */5 * * * *", RunOnStartup=true)] TimerInfo timer,
[Queue("SaveQuestions")] ICollector<Question> outQ,
TraceWriter log)
{
log.Verbose("RSS Feed Processor started");
Console.WriteLine("RSS Feed Processor started");
foreach (var feeds in mFeedSources)
{
switch(feeds.Key){
case "StackOverflow":
foreach (var feed in feeds.Value) {
try {
using (XmlReader reader = XmlReader.Create(feed.Value)) {
SyndicationFeed rss = SyndicationFeed.Load(reader);
foreach (SyndicationItem item in rss.Items) {
outQ.Add(ProcessStackOverflowEntry(item, feed.Key));
}
}
}
catch (Exception e)
{
log.Error(String.Format("Couldn't read from feed - {0}", feeds.Value), e);
}
}
break;
default:
log.Warning(String.Format("Couldn't recognize feed format: {0}", feeds.Key),"RSSFeedProcessor");
break;
}
}
}
public FSharpCompiler(IFunctionMetadataResolver metadataResolver, OptimizationLevel optimizationLevel, TraceWriter traceWriter)
{
_metadataResolver = metadataResolver;
_optimizationLevel = optimizationLevel;
_traceWriter = traceWriter;
_hashRRegex = new Regex(@"^\s*#r\s+", RegexOptions.Compiled | RegexOptions.IgnoreCase);
}
public static async Task SingletonJob([QueueTrigger("singleton-test")] WorkItem workItem, TraceWriter trace)
{
trace.Info("Singleton method started");
await Task.Delay(10 * 1000);
trace.Info("Singleton method completed");
}
public SingletonManager(IStorageAccountProvider accountProvider, IBackgroundExceptionDispatcher backgroundExceptionDispatcher, SingletonConfiguration config, TraceWriter trace, INameResolver nameResolver = null)
{
_accountProvider = accountProvider;
_nameResolver = nameResolver;
_backgroundExceptionDispatcher = backgroundExceptionDispatcher;
_config = config;
_trace = trace;
}
public WebHookDispatcher(WebHooksConfiguration webHooksConfig, JobHost host, JobHostConfiguration config, TraceWriter trace)
{
_functions = new ConcurrentDictionary<string, ITriggeredFunctionExecutor>();
_trace = trace;
_port = webHooksConfig.Port;
_types = config.TypeLocator.GetTypes().ToArray();
_host = host;
}
public TimerTriggerBinding(ParameterInfo parameter, TimerTriggerAttribute attribute, TimersConfiguration config, TraceWriter trace)
{
_attribute = attribute;
_parameter = parameter;
_config = config;
_trace = trace;
_bindingContract = CreateBindingDataContract();
}
public static async Task WebHookTrigger(HttpRequestMessage request, TraceWriter traceWriter)
{
string body = await request.Content.ReadAsStringAsync();
InvokeData = body;
traceWriter.Info(string.Format("C# WebHookTrigger function received message '{0}'", body));
}
public static void SendSimplePubSubMessage([Redis("simpleMessages", Mode.PubSub)] out string message, TextWriter log, TraceWriter trace)
{
message = "this is a test";
log.WriteLine("sending message: " + message);
trace.Info(string.Format("New message sent: {0}", message));
}
public FunctionAssemblyLoadContext(FunctionMetadata functionMetadata, Assembly functionAssembly, IFunctionMetadataResolver resolver, TraceWriter traceWriter)
{
_metadataResolver = resolver;
_loadedAssemblies = ImmutableArray<Assembly>.Empty;
_traceWriter = traceWriter;
FunctionAssembly = functionAssembly;
Metadata = functionMetadata;
}
public FileTriggerBinding(FilesConfiguration config, ParameterInfo parameter, TraceWriter trace)
{
_config = config;
_parameter = parameter;
_trace = trace;
_attribute = parameter.GetCustomAttribute<FileTriggerAttribute>(inherit: false);
_bindingContract = CreateBindingContract();
}
public SingletonManager(IStorageBlobClient blobClient, IBackgroundExceptionDispatcher backgroundExceptionDispatcher, SingletonConfiguration config, TraceWriter trace)
{
_backgroundExceptionDispatcher = backgroundExceptionDispatcher;
_directory = blobClient.GetContainerReference(HostContainerNames.Hosts)
.GetDirectoryReference(HostDirectoryNames.SingletonLocks);
_config = config;
_trace = trace;
}
public FunctionMetadataResolver(FunctionMetadata metadata, TraceWriter traceWriter)
{
_functionMetadata = metadata;
_traceWriter = traceWriter;
_packageAssemblyResolver = new PackageAssemblyResolver(metadata);
_privateAssembliesPath = GetBinDirectory(metadata);
_scriptResolver = ScriptMetadataResolver.Default.WithSearchPaths(_privateAssembliesPath);
}
/// <summary>
/// Demonstrates binding to a custom POCO Type, including model binding in other
/// binders to values from that POCO.
/// </summary>
public static void HookC(
[WebHookTrigger] Order order,
[File(@"{OrderId}_{CustomerName}.txt", FileAccess.Write)] out string output,
TraceWriter trace)
{
output = "Order Received!";
trace.Info(string.Format("HookC invoked! OrderId: {0}", order.OrderId));
}
/// <summary>
/// GitHub WebHook example, showing integration with the ASP.NET WebHooks SDK.
/// The route uses the format {receiver}/{id} where the receiver "github" corresponds
/// to the <see cref="GitHubWebHookReceiver"/> that was registered on startup via
/// <see cref="WebHooksConfiguration.UseReceiver{T}"/>, and the "issues" Id component
/// corresponds to the "Issues" secret configured in app.config.
/// Incoming requests will be authenticated by <see cref="GitHubWebHookReceiver"/> prior
/// to invoking this job function.
/// </summary>
public static void GitHub(
[WebHookTrigger("github/issues")] string body,
TraceWriter trace)
{
dynamic issueEvent = JObject.Parse(body);
trace.Info(string.Format("GitHub Issues WebHook invoked - Issue: '{0}', Action: '{1}', ",
issueEvent.issue.title, issueEvent.action));
}
public FunctionMetadataResolver(FunctionMetadata metadata, ICollection<ScriptBindingProvider> bindingProviders, TraceWriter traceWriter)
{
_functionMetadata = metadata;
_traceWriter = traceWriter;
_packageAssemblyResolver = new PackageAssemblyResolver(metadata);
_privateAssembliesPath = GetBinDirectory(metadata);
_scriptResolver = ScriptMetadataResolver.Default.WithSearchPaths(_privateAssembliesPath);
_extensionSharedAssemblyProvider = new ExtensionSharedAssemblyProvider(bindingProviders);
}
public FileListener(FilesConfiguration config, FileTriggerAttribute attribute, ITriggeredFunctionExecutor triggerExecutor, TraceWriter trace)
{
_config = config;
_attribute = attribute;
_triggerExecutor = triggerExecutor;
_trace = trace;
_cancellationTokenSource = new CancellationTokenSource();
_watchPath = Path.Combine(_config.RootPath, _attribute.GetNormalizedPath());
}
protected ScriptHost(ScriptHostConfiguration scriptConfig)
: base(scriptConfig.HostConfig)
{
ScriptConfig = scriptConfig;
if (scriptConfig.FileLoggingEnabled)
{
string hostLogFilePath = Path.Combine(scriptConfig.RootLogPath, "Host");
_traceWriter = new FileTraceWriter(hostLogFilePath, TraceLevel.Verbose);
scriptConfig.HostConfig.Tracing.Tracers.Add(_traceWriter);
}
else
{
_traceWriter = NullTraceWriter.Instance;
}
if (scriptConfig.TraceWriter != null)
{
scriptConfig.HostConfig.Tracing.Tracers.Add(scriptConfig.TraceWriter);
}
else
{
scriptConfig.TraceWriter = NullTraceWriter.Instance;
}
if (scriptConfig.FileWatchingEnabled)
{
_fileWatcher = new FileSystemWatcher(scriptConfig.RootScriptPath)
{
IncludeSubdirectories = true,
EnableRaisingEvents = true
};
_fileWatcher.Changed += OnFileChanged;
_fileWatcher.Created += OnFileChanged;
_fileWatcher.Deleted += OnFileChanged;
_fileWatcher.Renamed += OnFileChanged;
}
// If a file change should result in a restart, we debounce the event to
// ensure that only a single restart is triggered within a specific time window.
// This allows us to deal with a large set of file change events that might
// result from a bulk copy/unzip operation. In such cases, we only want to
// restart after ALL the operations are complete and there is a quiet period.
_restart = (e) =>
{
_traceWriter.Verbose(string.Format("File change of type '{0}' detected for '{1}'", e.ChangeType, e.FullPath));
_traceWriter.Verbose("Host configuration has changed. Signaling restart.");
// signal host restart
_restartEvent.Set();
};
_restart = _restart.Debounce(500);
// take a snapshot so we can detect function additions/removals
_directoryCountSnapshot = Directory.EnumerateDirectories(ScriptConfig.RootScriptPath).Count();
}
public RedisTriggerBinding(ParameterInfo parameter, RedisAccount account, string channelOrKey, Mode mode, RedisConfiguration config, TraceWriter trace)
{
_parameter = parameter;
_account = account;
_channelOrKey = channelOrKey;
_mode = mode;
_config = config;
_bindingDataProvider = BindingDataProvider.FromType(parameter.ParameterType);
_trace = trace;
}
public RedisChannelListener(string channelOrKey, ITriggeredFunctionExecutor triggerExecutor, RedisConfiguration config, TraceWriter trace)
: base()
{
_channelOrKey = channelOrKey;
_triggerExecutor = triggerExecutor;
_config = config;
_redisProcessor = CreateProcessor(channelOrKey);
_trace = trace;
}
public RedisProcessor(RedisProcessorContext context, TraceWriter trace)
{
if (context == null)
{
throw new ArgumentNullException("context");
}
ChannelOrKey = context.ChannelOrKey;
_trace = trace;
}
public TimerListener(TimerTriggerAttribute attribute, string timerName, TimersConfiguration config, ITriggeredFunctionExecutor executor, TraceWriter trace)
{
_attribute = attribute;
_timerName = timerName;
_config = config;
_executor = executor;
_trace = trace;
_cancellationTokenSource = new CancellationTokenSource();
_schedule = _attribute.Schedule;
ScheduleMonitor = _attribute.UseMonitor ? _config.ScheduleMonitor : null;
}
public static async Task<BlobLeaseManager> CreateAsync(string accountConnectionString, TimeSpan leaseTimeout, string hostId, string instanceId, TraceWriter traceWriter)
{
if (leaseTimeout.TotalSeconds < 15 || leaseTimeout.TotalSeconds > 60)
{
throw new ArgumentOutOfRangeException(nameof(leaseTimeout), $"The {nameof(leaseTimeout)} should be between 15 and 60 seconds");
}
ICloudBlob blob = await GetLockBlobAsync(accountConnectionString, GetBlobName(hostId));
var manager = new BlobLeaseManager(blob, leaseTimeout, hostId, instanceId, traceWriter);
return manager;
}
public RedisCacheListener(string channelOrKey, ITriggeredFunctionExecutor triggerExecutor,
RedisConfiguration config, TraceWriter trace)
: base()
{
_channelOrKey = channelOrKey;
_triggerExecutor = triggerExecutor;
_config = config;
_lastValueKeyName = _config.LastValueKeyNamePrefix + channelOrKey;
_redisProcessor = CreateProcessor(channelOrKey);
_trace = trace;
}
public TimerTriggerBinding(ParameterInfo parameter, TimerTriggerAttribute attribute, TimersConfiguration config, TraceWriter trace)
{
_attribute = attribute;
_parameter = parameter;
_config = config;
_trace = trace;
_bindingContract = CreateBindingDataContract();
MethodInfo methodInfo = (MethodInfo)parameter.Member;
_timerName = string.Format("{0}.{1}", methodInfo.DeclaringType.FullName, methodInfo.Name);
}
public RedisBinding(string parameterName, IArgumentBinding<RedisEntity> argumentBinding,
RedisAccount account, RedisAttribute attribute, BindingProviderContext context, TraceWriter trace)
{
_parameterName = parameterName;
_argumentBinding = argumentBinding;
_account = account;
_attribute = attribute;
_mode = attribute.Mode;
_channelOrKeyPath = BindingTemplate.FromString(attribute.ChannelOrKey);
_trace = trace;
}
private async Task<bool> SendJSONtoURL(JObject json, string url, TraceWriter trace)
{
var client = new HttpClient();
var response = await client.PostAsJsonAsync(url, json);
if (response.StatusCode != HttpStatusCode.OK) {
trace.Error(String.Format("Status Code: {0} - Content: {1}", response.StatusCode, response.Content));
return false;
}
trace.Info("Finished sending message to Slack");
return true;
}
// This function will be triggered on a schedule determined by the cron expression provided. In this case it will run every minute.
// When this trigger is invoked, it enqueues a Message on the MessageQueue.
// To learn more about TimerTriggers, go to https://github.com/Azure/azure-webjobs-sdk-extensions#timertrigger
public static void TimedQueueMessage(
[TimerTrigger("0 * * * * *", RunOnStartup = true)] TimerInfo timer,
[Queue("MessageQueue")] out Message message,
TraceWriter log
)
{
// Create a new message
message = new Message()
{
message = timer.FormatNextOccurrences(1)
};
log.Verbose("New message enqueued");
}
static void Main(string[] args)
{
// var loggerEnvironment = "AzureFunctions";
var loggerEnvironment = "ConsoleApp";
ILogger logger = null;
if (loggerEnvironment == "AzureFunctions")
{
Microsoft.Azure.WebJobs.Host.TraceWriter azureFunctionLogger = null;
logger = new AzureFunctionLogger(azureFunctionLogger);
}
else if (loggerEnvironment == "ConsoleApp")
{
logger = new TraceLogger();
}
var doStuff = new DoStuff(logger);
Console.ReadKey();
}
public AzureFunctionLogger(Microsoft.Azure.WebJobs.Host.TraceWriter logger)
{
_logger = logger;
}
