private void FlushInternal()
{
using (Defer.Call(() => Reset())) // even in the presence of errors
{
try
{
// add current cell if not empty
if (cell.size > 0)
{
if (endChar != 0)
{
// inside escape - terminate it even if incomplete
EndEscape();
}
TerminateCell(false);
}
// format contents of buffer
Format(0, 0, lines.Length);
}
catch (Exception ex)
{
HandlePanic(ex, "Flush");
}
}
}
public ProductType(Defer <IProductReviewRepository> reviewRepository,
IDataLoaderContextAccessor dataLoaderAccessor)
{
_productReviewRepository = reviewRepository;
Field(t => t.Id);
Field(t => t.Name);
Field(t => t.Description);
Field(t => t.IntroducedAt).Description("When the product was first introduced in the catalog");
Field(t => t.PhotoFileName).Description("The file name of the photo so the client can render it");
Field(t => t.Price);
Field(t => t.Rating).Description("The (max 5) star customer rating");
Field(t => t.Stock);
Field <ProductTypeEnumType>("Type", "The type of product");
Field <ListGraphType <ProductReviewType> >(
"reviews",
resolve: context =>
{
//var user = (ClaimsPrincipal) context.UserContext;
var loader =
dataLoaderAccessor.Context.GetOrAddCollectionBatchLoader <int, ProductReview>(
"GetReviewsByProductId", _productReviewRepository.Value.GetForProducts);
return(loader.LoadAsync(context.Source.Id));
});
}
public async Task RunTest()
{
var defer = new Defer();
var number = 0;
async Task AsyncFunc()
{
number++;
await Task.Delay(10);
number++;
if (number == 10)
{
defer.Resolve();
}
}
var worker = new AsyncTaskWorker(3);
await worker.Run(AsyncFunc);
await worker.Run(AsyncFunc);
await worker.Run(AsyncFunc);
await worker.Run(AsyncFunc);
await worker.Run(AsyncFunc);
await defer.Wait();
Assert.AreEqual(number, 10);
}
/// <summary>
/// Return a iterator block that executes the monad. See <see cref="IMonad{T}.Do"/>.
/// </summary>
public IEnumerator Do()
{
using (var defer = new Defer())
{
var thread = new System.Threading.Thread(() =>
{
try
{
Result = _func();
}
catch (Exception e)
{
Error = e;
}
});
thread.Start();
defer.Add(() =>
{
if (thread.IsAlive)
{
thread.Abort();
}
});
while (thread.IsAlive)
{
yield return(null);
}
}
}
private int DeferredReturn(int n)
{
using (Defer.Call(() => n++))
{
// We cannot place the return here as its arguments would
// get evaluated BEFORE the deferred actions are run
}
return(n);
}
public void TestDeferArgEval()
{
var i = 0;
using (Defer.Call(i, (x) => Assert.AreEqual(0, x)))
{
i++;
return;
}
}
public CarvedRockSubscription(Defer <ReviewMessageService> messageService)
{
Name = "Subscription";
AddField(new EventStreamFieldType
{
Name = "reviewAdded",
Type = typeof(ReviewAddedMessageType),
Resolver = new FuncFieldResolver <ReviewAddedMessage>(c => c.Source as ReviewAddedMessage),
Subscriber = new EventStreamResolver <ReviewAddedMessage>(c => messageService.Value.GetMessages())
});
}
public async Task DeferTest()
{
var defer = new Defer();
Assert.AreEqual(false, defer.IsCompleted);
defer.Resolve();
await defer.Wait();
Assert.AreEqual(true, defer.IsCompleted);
}
public EntryPoint(
// Error while validating the service descriptor 'ServiceType: Example.IEntryPoint Lifetime: Singleton ImplementationType: Example.EntryPoint':
// Cannot consume scoped service 'Example.IRepository' from singleton 'Example.IEntryPoint'.
//IRepository repository
Defer <IRepository> repository1,
Func <IRepository> repository2,
IRepositoryFactory repoFactory)
{
_repository1 = repository1;
_repository2 = repository2;
_repoFactory = repoFactory;
}
public void TestSimpleDefer()
{
var x = 100;
Assert.AreEqual(100, x);
using (Defer.Call(() => x--))
{
Assert.AreEqual(100, x);
}
Assert.AreEqual(99, x);
}
public void TestDeferLIFO()
{
var s = "";
using (var d = Defer.Call())
{
for (int i = 0; i < 4; i++)
{
d.Add(i, (x) => s += x);
}
}
Assert.AreEqual("3210", s);
}
/// <summary>Assigns all needed attributes to the tag</summary>
/// <returns>This instance downcasted to base class</returns>
public virtual IndexedTag attr(
Charset charset = null,
MimeType type = null,
string src = null,
Defer? defer = null,
string xmlspace = null
)
{
Charset = charset;
Type = type;
Src = src;
Defer = defer;
XmlSpace = xmlspace;
return this;
}
public CustomerQuery(Defer <IStore> store, Defer <ApplicationDbContext> appDb)
{
var again = appDb.Value.Customers.ToList();
using var session = store.Value.CreateSession();
var test = session.Query <Customer>().ListAsync().Result.ToList();
Name = "Query";
Field <ListGraphType <CustomerGraphType> >("customers", "Returns a list of Customer", resolve: context => test);
Field <CustomerGraphType>("customer", "Returns a Single Customer",
new QueryArguments(new QueryArgument <NonNullGraphType <IntGraphType> > {
Name = "id", Description = "Customer Id"
}),
context => test.Single(x => x.Id == context.Arguments["id"].GetPropertyValue <int>()));
}
public async Task DisposeAsyncCreatorTest()
{
var step1defer = new Defer();
var step2defer = new Defer();
using var pool = new ObjectPool <TestObject>(
1,
async() =>
{
await Task.Delay(10);
return(new TestObject());
});
var thrown = false;
var taskA = Task.Run(
async() =>
{
using (await pool.GetRefAsync())
{
step1defer.Resolve();
try
{
using (await pool.GetRefAsync())
{
Assert.Fail("Should not be run.");
}
}
catch (OperationCanceledException)
{
thrown = true;
step2defer.Resolve();
}
}
});
var taskB = Task.Run(
async() =>
{
await step1defer.Wait();
pool.Dispose();
await step2defer.Wait();
Assert.IsTrue(thrown);
});
await Task.WhenAll(taskA, taskB);
}
protected override IDisposable SubscribeCore(IObserver <T> observer, IDisposable cancel)
{
observer = new Defer(observer, cancel);
IObservable <T> source;
try
{
source = observableFactory();
}
catch (Exception ex)
{
source = Observable.Throw <T>(ex);
}
return(source.Subscribe(observer));
}
/// <summary>Executes a function with error handling and contextual logging</summary>
public static async Task <T> Run <T>(this Defer <FuncCtx, ExecutionContext> ctx, ExecutionContext exec, Func <FuncCtx, Task <T> > func)
{
var c = await ctx.GetOrCreate(exec);
c = c.WithLog(c.Log.ForContext("Function", exec.FunctionName));
try {
c.Log.Information("{Function} function - started", exec.FunctionName);
var res = await func(c).WithDuration();
c.Log.Information("{Function} function - completed in {Duration}", exec.FunctionName, res.Duration.HumanizeShort());
return(res.Result);
}
catch (Exception ex) {
c.Log.Error(ex, "{Function} function - unhandled exception: {Message}", exec.FunctionName, ex.Message);
throw;
}
}
public CarvedRockQuery(Defer <ICustomerRepository> customerRepository,
Defer <IProductRepository> productRepository,
Defer <IProductReviewRepository> reviewRepository)
{
_productRepository = productRepository;
_customerRepository = customerRepository;
_reviewRepository = reviewRepository;
ProductGetAll();
ProductById();
ProductReviewByProductId();
CustomerGetAll();
CustomerById();
}
public async Task BlockTest()
{
var step1defer = new Defer();
var step2defer = new Defer();
using var pool = new ObjectPool <TestObject>(3, () => { return(new TestObject()); });
var flag = false;
var taskA = Task.Run(
async() =>
{
using (await pool.GetRefAsync())
using (await pool.GetRefAsync())
{
using (await pool.GetRefAsync())
{
// the pool is empty now
step1defer.Resolve();
await Task.Delay(50);
Assert.IsFalse(flag);
} // relese once
await step2defer.Wait();
Assert.IsTrue(flag);
}
});
var taskB = Task.Run(
async() =>
{
await step1defer.Wait();
// should block here
using (await pool.GetRefAsync())
{
flag = true;
step2defer.Resolve();
}
});
await Task.WhenAll(taskA, taskB);
}
public CarvedRockMutation(Defer <IProductReviewRepository> reviewRepository, Defer <IReviewMessageService> messageService)
{
_reviewRepository = reviewRepository;
_messageService = messageService;
CreateProductReview();
//Field<UserGraphType>(
// "userLogin",
// arguments: new QueryArguments(
// new QueryArgument<NonNullGraphType<LoginInputType>> { Name = "credentials" }
// ),
// resolve: context =>
// {
// using (var session = store.Value.CreateSession())
// {
// //session.Save(customer);
// var test = session.Query<Customer>().FirstOrDefaultAsync().Result;
// }
// return new User { Id = 1, Username = "******" };
// });
}
public Controller(
IScopeFactory scopeFactory,
IMegaFactory factory,
IGenericFactory <IBuilder, INotifier> generic,
Func <ScopedService> scopedFunc,
Func <TransientService> transientFunc,
Defer <ScopedService> scopedDefer,
Defer <TransientService> transientDefer)
{
Factory = factory;
Generic = generic;
ScopedFunc = scopedFunc;
ScopedDefer = scopedDefer;
TransientFunc = transientFunc;
TransientDefer = transientDefer;
Console.WriteLine("Controller created");
using (new Scoped <Controller>(scopeFactory))
{
}
}
/// <summary>
/// Return a iterator block that executes the monad. See <see cref="IMonad{T}.Do"/>.
/// </summary>
public IEnumerator Do()
{
Executor executor = new Executor();
using (var defer = new Defer())
{
defer.Add(() =>
{
foreach (Coroutine c in executor)
{
c.Dispose();
}
executor.Clear();
});
for (int i = 0; i < _ms.Length; ++i)
{
executor.Add(_Do(_ms[i]));
}
executor.Resume(Coroutine.Delta);
while (!executor.Finished)
{
if (Error != null)
{
yield break;
}
yield return(null);
executor.Resume(Coroutine.Delta);
}
if (Error != null)
{
yield break;
}
Result = System.Array.ConvertAll(_ms, m => m.Result);
}
}
public LoginMutation(Defer <IStore> store)
{
Field <UserGraphType>(
"userLogin",
arguments: new QueryArguments(
new QueryArgument <NonNullGraphType <LoginInputType> > {
Name = "credentials"
}
),
resolve: context =>
{
using (var session = store.Value.CreateSession())
{
//session.Save(customer);
var test = session.Query <Customer>().FirstOrDefaultAsync().Result;
}
return(new User {
Id = 1, Username = "******"
});
});
}
public async Task CancelTest()
{
var flag = false;
using var cancellationTokenSource = new CancellationTokenSource();
var cancellationToken = cancellationTokenSource.Token;
var worker = new AsyncTaskWorker(1);
// blocked task
var blockedDefer = new Defer();
await worker.Run(async() =>
{
await blockedDefer.Wait();
});
// Task will be suspended
var suspendedTask = worker.Run(
() =>
{
flag = true;
return(Task.CompletedTask);
},
cancellationToken);
Assert.IsFalse(suspendedTask.IsCompleted);
Assert.IsFalse(flag);
// Cancel pending suspension
cancellationTokenSource.Cancel();
Assert.ThrowsAsync <OperationCanceledException>(() => suspendedTask.AsTask());
Assert.IsTrue(suspendedTask.IsCanceled);
Assert.IsFalse(flag);
blockedDefer.Resolve();
}
public async Task MaxConcurrencyTest()
{
var defer = new Defer();
var endDefer = new Defer();
var worker = new AsyncTaskWorker(3);
// Three blocked tasks
await worker.Run(() => defer.Wait());
await worker.Run(() => defer.Wait());
await worker.Run(() => defer.Wait());
// Task will be suspended
var step4Task = worker.Run(
() =>
{
endDefer.Resolve();
return(Task.CompletedTask);
});
await Task.Delay(100);
Assert.IsFalse(step4Task.IsCompleted);
Assert.IsFalse(endDefer.IsCompleted);
// End the blocked tasks
defer.Resolve();
// Wait for step4 end
await step4Task;
await endDefer.Wait();
Assert.IsTrue(step4Task.IsCompleted);
}
public static TagScript defer(this TagScript tag, Defer value) { tag.Defer = value; return tag; }
/// output prints creates b printable HCL output and returns it.
private slice <byte> Output(object n)
{
var buf = new GoBuffer();
using (var defer = Defer.Call())
{
switch (n)
{
case File t:
// File doesn't trace so we add the tracing here
//defer.Add(() => un(trace(this, "File")));
return(Output(t.Node));
case ObjectList t:
//defer.Add(() => un(trace(p, "ObjectList")));
int index = 0;
for (;;)
{
// Determine the location of the next actual non-comment
// item. If we're at the end, the next item is at "infinity"
Pos nextItem;
if (index != t.Items.Length)
{
nextItem = t.Items[index].Pos();
}
else
{
nextItem = new Pos {
Offset = infinity, Line = infinity
};
}
// Go through the standalone comments in the file and print out
// the comments that we should be for this object item.
foreach (var c in this.standaloneComments)
{
// Go through all the comments in the group. The group
// should be printed together, not separated by double newlines.
var printed = false;
var newlinePrinted = false;
foreach (var comment in c.List)
{
// We only care about comments after the previous item
// we've printed so that comments are printed in the
// correct locations (between two objects for example).
// And before the next item.
if (comment.Pos().After(this.prev) && comment.Pos().Before(nextItem))
{
// if we hit the end add newlines so we can print the comment
// we don't do this if prev is invalid which means the
// beginning of the file since the first comment should
// be at the first line.
if (!newlinePrinted && this.prev.IsValid && index == t.Items.Length)
{
buf.Write(slice.From(newline, newline));
newlinePrinted = true;
}
// Write the actual comment.
buf.WriteString(comment.Text);
buf.WriteByte(newline);
// Set printed to true to note that we printed something
printed = true;
}
}
// If we're not at the last item, write a new line so
// that there is a newline separating this comment from
// the next object.
if (printed && index != t.Items.Length)
{
buf.WriteByte(newline);
}
}
if (index == t.Items.Length)
{
break;
}
buf.Write(this.Output(t.Items[index]));
if (index != t.Items.Length - 1)
{
// Always write a newline to separate us from the next item
buf.WriteByte(newline);
// Need to determine if we're going to separate the next item
// with a blank line. The logic here is simple, though there
// are a few conditions:
//
// 1. The next object is more than one line away anyways,
// so we need an empty line.
//
// 2. The next object is not a "single line" object, so
// we need an empty line.
//
// 3. This current object is not a single line object,
// so we need an empty line.
var current = t.Items[index];
var next = t.Items[index + 1];
if ((next.Pos().Line != t.Items[index].Pos().Line + 1) ||
!this.IsSingleLineObject(next) ||
!this.IsSingleLineObject(current))
{
buf.WriteByte(newline);
}
}
index++;
}
break;
case ObjectKey t:
buf.WriteString(t.Token.Text);
break;
case ObjectItem t:
this.prev = t.Pos();
buf.Write(this.ObjectItem(t));
break;
case LiteralType t:
buf.Write(this.LiteralType(t));
break;
case ListType t:
buf.Write(this.List(t));
break;
case ObjectType t:
buf.Write(this.ObjectType(t));
break;
default:
Console.WriteLine($"unknown type {n}");
break;
}
return(buf.Bytes());
}
}
public Service(Defer <ScopedAsSingleton> scoped)
{
Scoped = scoped;
}
public static async Task Run(this Defer <FuncCtx, ExecutionContext> ctx, ExecutionContext exec, Func <FuncCtx, Task> action) =>
await Run <object>(ctx, exec, async c => {
await action(c);
return(null);
});
public async Task <ProcessChannelResults> ProcessChannels(IReadOnlyCollection <ChannelUpdatePlan> channels,
CollectPart[] parts, ILogger log = null, CancellationToken cancel = default)
{
log ??= Logger.None;
var workSw = Stopwatch.StartNew();
// to save on db costs, get anything we need in advance of collection
var channelChromeVideos = new MultiValueDictionary <string, string>();
var channelDeadVideos = new MultiValueDictionary <string, string>();
if (parts.ShouldRun(VidExtra))
{
using var db = await Sf.OpenConnection(log);
var forChromeUpdate = await channels.Select(c => c.Channel).Batch(1000)
.BlockFunc(c => VideosForChromeUpdate(c, db, log));
channelChromeVideos = forChromeUpdate.SelectMany()
.Randomize().Take(RCfg.ChromeUpdateMax)
.ToMultiValueDictionary(c => c.ChannelId, c => c.VideoId);
channelDeadVideos = (await channels.Select(c => c.Channel).Batch(1000)
.BlockFunc(c => DeadVideosForExtraUpdate(c, db, log)))
.SelectMany().ToMultiValueDictionary(v => v.ChannelId, v => v.VideoId);
}
var channelResults = await channels
.Select((c, i) => (c, i))
.BlockFunc(async item => {
var(plan, i) = item;
var c = plan.Channel;
var sw = Stopwatch.StartNew();
var cLog = log
.ForContext("ChannelId", c.ChannelId)
.ForContext("Channel", c.ChannelTitle);
try {
await using var conn = new Defer <ILoggedConnection <IDbConnection> >(async() => await Sf.OpenConnection(cLog));
await UpdateAllInChannel(plan, parts, channelChromeVideos.TryGet(c.ChannelId), channelDeadVideos.TryGet(c.ChannelId), cLog);
cLog.Information("Collect - {Channel} - Completed videos/recs/captions in {Duration}. Progress: channel {Count}/{BatchTotal}",
c.ChannelTitle, sw.Elapsed.HumanizeShort(), i + 1, channels.Count);
return(c, Success: true);
}
catch (Exception ex) {
ex.ThrowIfUnrecoverable();
cLog.Error(ex, "Collect - Error updating channel {Channel}: {Error}", c.ChannelTitle, ex.Message);
return(c, Success: false);
}
}, RCfg.ParallelChannels, cancel: cancel);
var res = new ProcessChannelResults {
Channels = channelResults.Select(r => new ProcessChannelResult {
ChannelId = r.c.ChannelId, Success = r.Success
}).ToArray(),
Duration = workSw.Elapsed
};
log.Information(
"Collect - {Pipe} complete - {ChannelsComplete} channel videos/captions/recs, {ChannelsFailed} failed {Duration}",
nameof(ProcessChannels), channelResults.Count(c => c.Success), channelResults.Count(c => !c.Success), res.Duration);
return(res);
}
public ApiBackend(Defer <FuncCtx, ExecutionContext> ctx) => Ctx = ctx;
internal DeferredBehavior(Defer <T> deferred)
{
Deferred = deferred;
}
public static TagScript defer(this TagScript tag, Defer value)
{
tag.Defer = value; return(tag);
}
