private OneOffSchedule(
[CanBeNull] string name,
DateTime dateTime,
[NotNull] string timeZone,
ScheduleOptions options = ScheduleOptions.None)
{
if (timeZone == null)
{
throw new ArgumentNullException("timeZone");
}
DateTimeZone tz = TimeHelpers.DateTimeZoneProvider[timeZone];
if (tz == null)
{
throw new ArgumentException(
// ReSharper disable once AssignNullToNotNullAttribute
string.Format(Resource.OneOffSchedule_InvalidTimeZone, timeZone),
"timeZone");
}
_name = name;
Instant = tz.AtLeniently(LocalDateTime.FromDateTime(dateTime)).ToInstant();
_options = options;
}
public async Task <EdgeDefinition> RunAsync()
{
var scheduleId = (long)this.Batch.Items.First().Parameters["Batch"];
using (var context = this.dataAccess.GetContext())
{
this.Options = await context.NoTracking <DAL.Entities.Schedule>()
.Where(s => s.Id == scheduleId)
.Select(s => new ScheduleOptions
{
IsDefault = s.IsDefault,
ScheduleId = s.Id,
Type = s.Type,
UpdateIntervalInMinutes = s.UpdateIntervalInMinutes
})
.SingleOrDefaultAsync();
switch (this.Options?.Type)
{
case DAL.Entities.ExecutionType.GetNewResults:
return(this.GetNewResults);
case DAL.Entities.ExecutionType.UpdateOpenResults:
return(this.UpdateOpenResults);
case DAL.Entities.ExecutionType.UpdateOutdatedResults:
return(this.UpdateOutdatedResults);
default:
return(this.ScheduleNotFound);
}
}
}
/// <summary>
/// Initializes a new instance of the <see cref="PeriodicSchedule" /> class.
/// </summary>
/// <param name="name">The name.</param>
/// <param name="month">The month.</param>
/// <param name="week">The week.</param>
/// <param name="day">The day.</param>
/// <param name="weekDay">The week day.</param>
/// <param name="hour">The hour.</param>
/// <param name="minute">The minute.</param>
/// <param name="second">The second.</param>
/// <param name="minimumGap">The minimum gap.</param>
/// <param name="calendar">The calendar.</param>
/// <param name="timeZone">The time zone.</param>
/// <param name="options">The options.</param>
public PeriodicSchedule(
[CanBeNull] string name,
Month month = Month.Every,
Week week = Week.Every,
Day day = Day.Every,
WeekDay weekDay = WeekDay.Every,
Hour hour = Hour.Zeroth,
Minute minute = Minute.Zeroth,
Second second = Second.Zeroth,
Duration minimumGap = default(Duration),
[CanBeNull] CalendarSystem calendar = null,
[CanBeNull] DateTimeZone timeZone = null,
ScheduleOptions options = ScheduleOptions.None)
: this(
month,
week,
day,
weekDay,
hour,
minute,
second,
minimumGap < Duration.Zero ? Duration.Zero : minimumGap,
// ReSharper disable AssignNullToNotNullAttribute
calendar ?? CalendarSystem.Iso,
timeZone ?? DateTimeZone.Utc,
// ReSharper restore AssignNullToNotNullAttribute
options,
name)
{
}
/// <summary>
/// Initializes a new instance of the <see cref="GapSchedule"/> class.
/// </summary>
/// <param name="timeSpan">The time span.</param>
/// <param name="options">The options.</param>
public GapSchedule(TimeSpan timeSpan, ScheduleOptions options = ScheduleOptions.None)
{
Duration duration = Duration.FromTimeSpan(timeSpan);
Duration = duration < Duration.Zero ? Duration.Zero : duration;
_options = options;
}
/// <summary>
/// Initializes a new instance of the <see cref="GapSchedule"/> class.
/// </summary>
/// <param name="name">The name.</param>
/// <param name="timeSpan">The time span.</param>
/// <param name="options">The options.</param>
public GapSchedule([CanBeNull] string name, TimeSpan timeSpan, ScheduleOptions options = ScheduleOptions.None)
{
Duration duration = Duration.FromTimeSpan(timeSpan);
_name = name;
Duration = duration < Duration.Zero ? Duration.Zero : duration;
_options = options;
}
private OneOffSchedule(
[CanBeNull] string name,
DateTimeOffset dateTime,
ScheduleOptions options = ScheduleOptions.None)
{
_name = name;
Instant = Instant.FromDateTimeOffset(dateTime);
_options = options;
}
/// <summary>
/// Initializes a new instance of the <see cref="OneOffSchedule" /> class.
/// </summary>
/// <param name="name">An optional name for the schedule.</param>
/// <param name="zonedDateTime">The date and time.</param>
/// <param name="options">The options.</param>
public OneOffSchedule(
[CanBeNull] string name,
ZonedDateTime zonedDateTime,
ScheduleOptions options = ScheduleOptions.None)
{
_name = name;
Instant = zonedDateTime.ToInstant();
_options = options;
}
/// <summary>
/// Initializes a new instance of the <see cref="FunctionalSchedule" /> class.
/// </summary>
/// <param name="function">The function.</param>
/// <param name="options">The options.</param>
public FunctionalSchedule(
[NotNull] Func <Instant, Instant> function,
ScheduleOptions options = ScheduleOptions.None)
{
if (function == null)
{
throw new ArgumentNullException("function");
}
_function = function;
_options = options;
}
private PeriodicSchedule(
Month month,
Week week,
Day day,
WeekDay weekDay,
Hour hour,
Minute minute,
Second second,
Duration minimumGap,
[NotNull] CalendarSystem calendarSystem,
[NotNull] DateTimeZone dateTimeZone,
ScheduleOptions options,
[CanBeNull] string name)
: base(
name,
CreateFunction(
month,
week,
day,
weekDay,
hour,
minute,
second,
minimumGap,
calendarSystem,
dateTimeZone),
options)
{
if (calendarSystem == null)
{
throw new ArgumentNullException("calendarSystem");
}
if (dateTimeZone == null)
{
throw new ArgumentNullException("dateTimeZone");
}
Month = month;
Week = week;
Day = day;
WeekDay = weekDay;
Hour = hour;
Minute = minute;
Second = second;
MinimumGap = minimumGap;
CalendarSystem = calendarSystem;
DateTimeZone = dateTimeZone;
}
/// <summary>
/// Initializes a new instance of the <see cref="AggregateSchedule" /> class.
/// </summary>
/// <param name="name">An optional name for the schedule.</param>
/// <param name="schedules">A collection of schedules.</param>
/// <exception cref="System.ArgumentException">The specified schedules have differing options.</exception>
public AggregateSchedule([CanBeNull] string name, [NotNull] params ISchedule[] schedules)
{
if (schedules == null)
{
throw new ArgumentNullException("schedules");
}
// Duplicate collection
_schedules = schedules.Where(s => s != null).ToArray();
_name = name;
if (!_schedules.Any())
{
_options = ScheduleOptions.None;
return;
}
unchecked
{
int hashCode = _schedules.Length;
// Calculate options and ensure all are identical.
bool first = true;
foreach (ISchedule schedule in _schedules.OrderBy(s => s.Name))
{
Debug.Assert(schedule != null);
hashCode = (hashCode * 397) ^ schedule.GetHashCode();
if (first)
{
_options = schedule.Options;
first = false;
continue;
}
if (schedule.Options != _options)
{
throw new ArgumentException(Resource.AggregateSchedule_Different_Options, "schedules");
}
}
hashCode = (hashCode * 397) ^ (_name != null ? _name.GetHashCode() : 0);
hashCode = (hashCode * 397) ^ (int)_options;
_hashCode = hashCode;
}
}
/// <summary>
/// Specifies that the configured job will be triggered by an item inserted to the a queue.
/// </summary>
/// <typeparam name="TState">The type of the persisted job state. This is a DTO to share state between every execution</typeparam>
/// <param name="builder">The <see cref="TaskTriggerBuilder"/> used to configure the way that a job is triggered.</param>
/// <param name="cronExpression">Cron expression</param>
/// <param name="configureAction">The delegate used to configure the queue options.</param>
/// <returns>The <see cref="WorkerHostBuilder"/> used to configure the worker host.</returns>
public static WorkerHostBuilder WithScheduleTrigger <TState>(this TaskTriggerBuilder builder, string cronExpression, Action <ScheduleOptions> configureAction = null) where TState : class
{
if (string.IsNullOrWhiteSpace(cronExpression))
{
throw new ArgumentException($"'{nameof(cronExpression)}' cannot be null or whitespace", nameof(cronExpression));
}
var options = new ScheduleOptions(builder.Services)
{
CronExpression = cronExpression
};
configureAction?.Invoke(options);
options.Services.AddTransient(builder.JobHandlerType);
options.Services.AddTransient(typeof(IScheduledTaskStore <TState>), builder.Options.ScheduledTaskStoreType.MakeGenericType(typeof(TState)));
options.Services.AddTransient(typeof(ScheduledJob <,>).MakeGenericType(builder.JobHandlerType, typeof(TState)));
options.Services.AddTransient(serviceProvider => new ScheduledJobSettings(builder.JobHandlerType, typeof(TState), cronExpression, options.Name, options.Group, options.Description));
return(new WorkerHostBuilder(options.Services, builder.Options));
}
public async static Task Run()
{
// =========================================================
// Iron.io Worker
// =========================================================
Console.WriteLine("Be sure to create a 'Test' worker before running this sample");
Console.WriteLine("Press ANY key to continue");
Console.Read();
IronWorkerRestClient workerClient = Client.New();
string taskId = await workerClient.Tasks.Create("Test", new { Key = "Value" });
Console.WriteLine("TaskID: {0}", taskId);
TaskInfoCollection taskInfoCollection = await workerClient.Tasks.List("Test");
foreach (TaskInfo task in taskInfoCollection.Tasks)
{
Console.WriteLine(task.Inspect());
}
ScheduleOptions options = ScheduleBuilder.Build().
Delay(TimeSpan.FromMinutes(1)).
WithFrequency(TimeSpan.FromHours(1)).
RunFor(TimeSpan.FromHours(3)).
WithPriority(TaskPriority.Default);
var payload = new
{
a = "b",
c = new[] { 1, 2, 3 }
};
ScheduleIdCollection schedule = await workerClient.Schedules.Create("Test", payload, options);
Console.WriteLine(schedule.Inspect());
await workerClient.Schedules.Cancel(schedule.Schedules.First().Id);
}
/// <summary>
/// Starts the machinery
/// </summary>
void LoadConfiguration()
{
ScheduleOptions options = null;
// fixed bug with restoring from sleep mode(do not access disk drive)
try
{
options = ScheduleOptionsManager.Load();
ScheduleOptionsManager.Validate(options);
}
catch (FileNotFoundException)
{
// but no config was created
// it's normal situation after installation
// so we're exiting
Environment.Exit(0);
}
catch (ScheduleOptionsInvalidException)
{
seriousBugHelper(_InvalidOptions, true);
}
catch (Exception e)
{
ImproveIt.ProcessUnhandledException(e);
}
// if there's no scheduling
if (!options.EnableScheduling)
{
// we're exiting to free system resources
Environment.Exit(0);
}
else
{
_scheduler.Options = options;
Resume();
}
}
private void EditTaskOptions()
{
if(activeTask != null) {
ScheduledTask task = (ScheduledTask)activeTask.Tag;
ScheduleOptions options = new ScheduleOptions();
options.Options = _options;
options.EditMode = true;
options.Task = task;
if(options.ShowDialog() == DialogResult.OK) {
ListViewItem taskItem = null;
ScheduledTask newTask = options.Task;
for(int i = 0; i < TaskList.Items.Count; i++) {
if((ScheduledTask)TaskList.Items[i].Tag == (ScheduledTask)activeTask.Tag) {
taskItem = TaskList.Items[i];
break;
}
}
TaskManager.SaveTask(SecureDeleteLocations.GetTaskFile(task.TaskId), newTask);
// update the <guid,taskName> mapping
if(_options.SessionNames.ContainsKey(newTask.TaskId)) {
_options.SessionNames[task.TaskId] = newTask.Name;
}
else {
_options.SessionNames.Add(task.TaskId, newTask.Name);
}
// save options
SDOptionsFile.TrySaveOptions(_options);
manager.LoadOptions();
// reschedule
disableRescheduling = true;
if(manager.LoadAndHandleTask(newTask.TaskId) == false) {
Debug.ReportWarning("Failed to handle edited task");
}
else {
// update interface
if(taskItem != null) {
taskItem.Tag = manager.GetTaskById(task.TaskId);
activeTask = taskItem;
}
UpdateTaskItem(activeTask);
}
disableRescheduling = false;
}
}
}
/// <summary>
/// Initializes a new instance of the <see cref="GapSchedule"/> class.
/// </summary>
/// <param name="duration">The duration.</param>
/// <param name="options">The options.</param>
public GapSchedule(Duration duration, ScheduleOptions options = ScheduleOptions.None)
{
Duration = duration < Duration.Zero ? Duration.Zero : duration;
_options = options;
}
/// <summary>
/// Initializes a new instance of the <see cref="GapSchedule"/> class.
/// </summary>
/// <param name="name">The name.</param>
/// <param name="duration">The duration.</param>
/// <param name="options">The options.</param>
public GapSchedule([CanBeNull] string name, Duration duration, ScheduleOptions options = ScheduleOptions.None)
{
_name = name;
Duration = duration < Duration.Zero ? Duration.Zero : duration;
_options = options;
}
/// <summary>
/// Initializes a new instance of the <see cref="OneOffSchedule" /> class.
/// </summary>
/// <param name="name">An optional name for the schedule.</param>
/// <param name="instant">The instant.</param>
/// <param name="options">The options.</param>
public OneOffSchedule([CanBeNull] string name, Instant instant, ScheduleOptions options = ScheduleOptions.None)
{
_name = name;
Instant = instant;
_options = options;
}
/// <summary>
/// Initializes a new instance of the <see cref="OneOffSchedule" /> class.
/// </summary>
/// <param name="instant">The instant.</param>
/// <param name="options">The options.</param>
public OneOffSchedule(Instant instant, ScheduleOptions options = ScheduleOptions.None)
{
Instant = instant;
_options = options;
}
public ScheduleResult[] Schedule(ScheduleOptions Options, string Action, [System.Xml.Serialization.XmlElementAttribute("Schedule")] ScheduleDefinition Schedule1, [System.Xml.Serialization.XmlArrayItemAttribute("Interaction", IsNullable=false)] APIObject[] Interactions, out string OverallStatus, out string OverallStatusMessage, out string RequestID) {
object[] results = this.Invoke("Schedule", new object[] {
Options,
Action,
Schedule1,
Interactions});
OverallStatus = ((string)(results[1]));
OverallStatusMessage = ((string)(results[2]));
RequestID = ((string)(results[3]));
return ((ScheduleResult[])(results[0]));
}
/// <summary>
/// Initializes a new instance of the <see cref="OneOffSchedule" /> class.
/// </summary>
/// <param name="zonedDateTime">The date and time.</param>
/// <param name="options">The options.</param>
public OneOffSchedule(ZonedDateTime zonedDateTime, ScheduleOptions options = ScheduleOptions.None)
{
Instant = zonedDateTime.ToInstant();
_options = options;
}
private void AddTask()
{
WipeSession session = new WipeSession();
session.GenerateGuid();
ScheduledTask task = new ScheduledTask();
task.TaskId = session.SessionId;
task.Schedule = new OneTimeSchedule();
task.Name = "Untitled task";
task.Enabled = true;
// show the dialog
ScheduleOptions options = new ScheduleOptions();
options.Options = _options;
options.EditMode = false;
options.Task = task;
if(options.ShowDialog() == DialogResult.OK) {
task = options.Task;
manager.LoadOptions();
manager.AddTask(task, true);
SessionSaver.SaveSession(session, SecureDeleteLocations.GetSessionFile(task.TaskId));
ListViewItem item = CreateTaskItem(task);
UpdateTaskItem(item);
// add to the <guid,taskName> mapping
_options.SessionNames.Add(task.TaskId, task.Name);
SDOptionsFile.TrySaveOptions(_options);
TaskList.Items[TaskList.Items.Count - 1].Selected = true;
}
_actionManager.StateChanged();
}
private static void Main(string[] args)
{
LogManager.Adapter = new ConsoleOutLoggerFactoryAdapter();
// =========================================================
// Iron.io MQ
// =========================================================
//IronMqRestClient ironMq = IronSharp.IronMQ.Client.New();
// For beta testing
IronMqRestClient ironMq = IronSharp.IronMQ.Client.New(new IronClientConfig {
ProjectId = "53a3b3bd5e8edd1245000005", Token = "O7KrMTwmw997iq0KzL7v", Host = "192.168.1.155", ApiVersion = 3, Port = 8080, Scheme = Uri.UriSchemeHttp
});
// Simple actions
// Post message to a queue
TestPosting(ironMq);
// Post message to a queue and reserve it
TestReservation(ironMq);
// Post message, reserve it and delete
TestDeletingReservedMessage(ironMq);
// Actions on queue
// Update queue info
TestUpdatingTheQueue(ironMq);
// Clear all messages of queue
TestClearingQueue(ironMq);
// Delete queue and its messages
TestDeletingQueue(ironMq);
// Get list of all queus inside project
TestGettingListQueue(ironMq);
// Actions on messages
//TestPosting(ironMq);
//TestReservation(ironMq);
//TestDeletingReservedMessage(ironMq);
// Get message by id without reservation
TestGettingMessageById(ironMq);
// Get message without reserving it
TestPeekingMessage(ironMq);
// Delete unreserved message
TestDeletingMessage(ironMq);
// Touch message to prolongate reservation
TestTouching(ironMq);
// Touch message to prolongate reservation
TestTouchingTwice(ironMq);
// Release reserved message
TestReleasing(ironMq);
// Delete a bunch of messages
TestDeletingMessages(ironMq);
// Get subscriber's URL
TestGettingSubscribersInfo(ironMq);
// =========================================================
// Iron.io Worker
// =========================================================
Console.WriteLine("Be sure to create a 'Test' worker before running this sample");
Console.WriteLine("Press ANY key to continue");
Console.Read();
IronWorkerRestClient workerClient = IronSharp.IronWorker.Client.New();
string taskId = workerClient.Tasks.Create("Test", new { Key = "Value" });
Console.WriteLine("TaskID: {0}", taskId);
TaskInfoCollection taskInfoCollection = workerClient.Tasks.List("Test");
foreach (TaskInfo task in taskInfoCollection.Tasks)
{
Console.WriteLine(task.Inspect());
}
ScheduleOptions options = ScheduleBuilder.Build().
Delay(TimeSpan.FromMinutes(1)).
WithFrequency(TimeSpan.FromHours(1)).
RunFor(TimeSpan.FromHours(3)).
WithPriority(TaskPriority.Default);
var payload = new
{
a = "b",
c = new[] { 1, 2, 3 }
};
ScheduleIdCollection schedule = workerClient.Schedules.Create("Test", payload, options);
Console.WriteLine(schedule.Inspect());
workerClient.Schedules.Cancel(schedule.Schedules.First().Id);
// =========================================================
// Iron.io Cache
// =========================================================
IronCacheRestClient ironCacheClient = IronSharp.IronCache.Client.New();
// Get a Cache object
CacheClient cache = ironCacheClient.Cache("my_cache");
// Put value to cache by key
cache.Put("number_item", 42);
// Get value from cache by key
Console.WriteLine(cache.Get("number_item").Value);
// Get value from cache by key
Console.WriteLine(cache.Get <int>("number_item"));
// Numbers can be incremented
cache.Increment("number_item", 10);
// Immediately delete an item
cache.Delete("number_item");
cache.Put("complex_item", new { greeting = "Hello", target = "world" });
// Get value from cache by key
Console.WriteLine(cache.Get("complex_item").Value);
cache.Delete("complex_item");
Console.WriteLine("============= Done ==============");
Console.Read();
}
/// <summary>
/// Schedule Constructor. Constructed from [options]
/// </summary>
/// <param name="options"></param>
public Schedule(ScheduleOptions options)
: this(options.StartDate, options.Version)
{ /**/
}
/// <summary>
/// Recalculates the next due date.
/// </summary>
/// <param name="due">The instant the schedule was last due to run, or completed.</param>
internal void RecalculateNextDue(Instant due)
{
// Increment recalculate counter, only let first increment continue.
if (Interlocked.Increment(ref _calculatorCount) > 1)
{
return;
}
do
{
try
{
long ndt = Interlocked.Read(ref NextDueTicksInternal);
Instant now = TimeHelpers.Clock.Now;
long nt = now.Ticks;
// If next due is in future, ask schedule when we're next due.
if (ndt > nt)
{
ScheduleOptions options = Schedule.Options;
Instant last;
if (!options.HasFlag(ScheduleOptions.FromDue))
{
Instant lef = LastExecutionFinished;
last = lef > Instant.MinValue
? lef
: TimeHelpers.Clock.Now;
}
else
{
last = due > Instant.MinValue
? due
: TimeHelpers.Clock.Now;
}
ndt = Schedule.Next(last).Ticks;
// If options >= 4 means one of the alignment flags is set.
if ((byte)options >= 4)
{
// Align the ticks as per flags.
if (options.HasFlag(ScheduleOptions.AlignHours))
{
ndt = ((ndt + NodaConstants.TicksPerHour - 1) / NodaConstants.TicksPerHour) *
NodaConstants.TicksPerHour;
}
else if (options.HasFlag(ScheduleOptions.AlignMinutes))
{
ndt = ((ndt + NodaConstants.TicksPerMinute - 1) / NodaConstants.TicksPerMinute) *
NodaConstants.TicksPerMinute;
}
else if (options.HasFlag(ScheduleOptions.AlignSeconds))
{
ndt = ((ndt + NodaConstants.TicksPerSecond - 1) / NodaConstants.TicksPerSecond) *
NodaConstants.TicksPerSecond;
}
}
}
// If it's more than the max clamp to max.
if (ndt > Scheduler.MaxTicks)
{
ndt = Scheduler.MaxTicks;
}
// Update next due
Interlocked.Exchange(ref NextDueTicksInternal, ndt);
}
finally
{
// Mark update as done.
Interlocked.Decrement(ref _calculatorCount);
}
// Keep going if we need to recalculate.
} while (_calculatorCount < 0);
// Notify the scheduler that we've changed our due date.
Scheduler.CheckSchedule();
}
/// <remarks/>
public void ScheduleAsync(ScheduleOptions Options, string Action, ScheduleDefinition Schedule1, APIObject[] Interactions) {
this.ScheduleAsync(Options, Action, Schedule1, Interactions, null);
}
private static void Main(string[] args)
{
LogManager.Adapter = new ConsoleOutLoggerFactoryAdapter();
IronMqRestClient ironMq = IronSharp.IronMQ.Client.New(new IronClientConfig {
ProjectId = "5bf768af967e0f000910fed3", Token = "y7TU7c3D3IUXtwrcJJFH", Host = "mq-aws-eu-west-1-1.iron.io", ApiVersion = 3, Scheme = Uri.UriSchemeHttp
});
QueueClient queueHabitacion = ironMq.Queue("Habitacion");
var codigoHabitacion = "HBT0000007";
string messageId1 = queueHabitacion.Post(codigoHabitacion);
Console.WriteLine("Mensaje enviado: {0}", codigoHabitacion);
QueueClient queueHotel = ironMq.Queue("Hotel");
var codigoHotel = "HT00000002";
string messageId2 = queueHotel.Post(codigoHotel);
Console.WriteLine("Mensaje enviado: {0}", codigoHabitacion);
//QueueMessage messageHabitacion = queueHabitacion.Reserve();
//Console.WriteLine("Respuesta: " + messageHabitacion.Body);
//QueueMessage messageHotel = queueHotel.Reserve();
//Console.WriteLine("Respuesta: " + messageHotel.Body);
//Console.WriteLine(message.ReservationId);
//bool finished = false;
//var hotelIds = new List<string>();
//while (!finished)
//{
// messageHotel = queueHotel.Reserve();
// if (messageHotel != null)
// hotelIds.Add(messageHotel.Body);
// else
// finished = true;
//}
LogManager.Adapter = new ConsoleOutLoggerFactoryAdapter();
// =========================================================
// Iron.io MQ
// =========================================================
//IronMqRestClient ironMq = IronSharp.IronMQ.Client.New();
// For beta testing
//IronMqRestClient ironMq = IronSharp.IronMQ.Client.New(new IronClientConfig { ProjectId = "53a3b3bd5e8edd1245000005", Token = "O7KrMTwmw997iq0KzL7v", Host = "192.168.1.155", ApiVersion = 3, Port = 8080, Scheme = Uri.UriSchemeHttp });
// Simple actions
// Post message to a queue
TestPosting(ironMq);
// Post message to a queue and reserve it
TestReservation(ironMq);
// Post message, reserve it and delete
TestDeletingReservedMessage(ironMq);
// Actions on queue
// Update queue info
TestUpdatingTheQueue(ironMq);
// Clear all messages of queue
TestClearingQueue(ironMq);
// Delete queue and its messages
TestDeletingQueue(ironMq);
// Get list of all queus inside project
TestGettingListQueue(ironMq);
// Actions on messages
//TestPosting(ironMq);
//TestReservation(ironMq);
//TestDeletingReservedMessage(ironMq);
// Get message by id without reservation
TestGettingMessageById(ironMq);
// Get message without reserving it
TestPeekingMessage(ironMq);
// Delete unreserved message
TestDeletingMessage(ironMq);
// Touch message to prolongate reservation
TestTouching(ironMq);
// Touch message to prolongate reservation
TestTouchingTwice(ironMq);
// Release reserved message
TestReleasing(ironMq);
// Delete a bunch of messages
TestDeletingMessages(ironMq);
// Get subscriber's URL
TestGettingSubscribersInfo(ironMq);
// =========================================================
// Iron.io Worker
// =========================================================
Console.WriteLine("Be sure to create a 'Test' worker before running this sample");
Console.WriteLine("Press ANY key to continue");
Console.Read();
IronWorkerRestClient workerClient = IronSharp.IronWorker.Client.New();
string taskId = workerClient.Tasks.Create("Test", new { Key = "Value" });
Console.WriteLine("TaskID: {0}", taskId);
TaskInfoCollection taskInfoCollection = workerClient.Tasks.List("Test");
foreach (TaskInfo task in taskInfoCollection.Tasks)
{
Console.WriteLine(task.Inspect());
}
ScheduleOptions options = ScheduleBuilder.Build().
Delay(TimeSpan.FromMinutes(1)).
WithFrequency(TimeSpan.FromHours(1)).
RunFor(TimeSpan.FromHours(3)).
WithPriority(TaskPriority.Default);
var payload = new
{
a = "b",
c = new[] { 1, 2, 3 }
};
ScheduleIdCollection schedule = workerClient.Schedules.Create("Test", payload, options);
Console.WriteLine(schedule.Inspect());
workerClient.Schedules.Cancel(schedule.Schedules.First().Id);
// =========================================================
// Iron.io Cache
// =========================================================
IronCacheRestClient ironCacheClient = IronSharp.IronCache.Client.New();
// Get a Cache object
CacheClient cache = ironCacheClient.Cache("my_cache");
// Put value to cache by key
cache.Put("number_item", 42);
// Get value from cache by key
Console.WriteLine(cache.Get("number_item").Value);
// Get value from cache by key
Console.WriteLine(cache.Get <int>("number_item"));
// Numbers can be incremented
cache.Increment("number_item", 10);
// Immediately delete an item
cache.Delete("number_item");
cache.Put("complex_item", new { greeting = "Hello", target = "world" });
// Get value from cache by key
Console.WriteLine(cache.Get("complex_item").Value);
cache.Delete("complex_item");
Console.WriteLine("============= Done ==============");
Console.Read();
}
/// <remarks/>
public void ScheduleAsync(ScheduleOptions Options, string Action, ScheduleDefinition Schedule1, APIObject[] Interactions, object userState) {
if ((this.ScheduleOperationCompleted == null)) {
this.ScheduleOperationCompleted = new System.Threading.SendOrPostCallback(this.OnScheduleOperationCompleted);
}
this.InvokeAsync("Schedule", new object[] {
Options,
Action,
Schedule1,
Interactions}, this.ScheduleOperationCompleted, userState);
}
