x11_cairo: minimize x11 server side memory consumption

This minimizes x11 server side memory consumption when using cairo (you can examine it with xrestop). I didn't notice a performace decrease for example using test/pugl_cairo_test.c with options -a -c -r.

I did a quick test by disabling the text rendering in pugl_cairo_test (which is a huge bottleneck) and this change drops the FPS by about 150, which isn't too surprising since it adds allocating surfaces to every frame.
Caching the context like master does currently is probably mostly pointless (it's designed to be fast to create and save/restore is mostly the same thing anyway), but I don't see a reason to constantly allocate entire buffers.

I measured on two machines: master without text rendering is slightly faster on the second machine. For the others: the new rendering with minimized memory seems to be even faster sometimes. But I think this is not a clear result. So it seems to me that in average minimizing the server memory does not have a relevant performance drawback.
Machine 1, master, with text rendering,
7836 frames in 5 seconds = 1567.105 FPS
7580 frames in 5 seconds = 1515.977 FPS
7670 frames in 5 seconds = 1533.966 FPS
7848 frames in 5 seconds = 1569.470 FPS
7809 frames in 5 seconds = 1561.591 FPS
7682 frames in 5 seconds = 1536.391 FPS

Machine 1, min-mem, with text rendering
5993 frames in 5 seconds = 1198.497 FPS
7875 frames in 5 seconds = 1574.821 FPS
8198 frames in 5 seconds = 1639.514 FPS
8116 frames in 5 seconds = 1623.113 FPS
8203 frames in 5 seconds = 1640.505 FPS
8109 frames in 5 seconds = 1621.767 FPS

Machine 1, master, without text rendering
10588 frames in 5 seconds = 2117.495 FPS
10579 frames in 5 seconds = 2115.742 FPS
10659 frames in 5 seconds = 2131.619 FPS
10506 frames in 5 seconds = 2101.129 FPS

Machine 1, min-mem, without text rendering
10511 frames in 5 seconds = 2102.109 FPS
10581 frames in 5 seconds = 2116.173 FPS
10658 frames in 5 seconds = 2131.382 FPS
10550 frames in 5 seconds = 2109.859 FPS

Machine 2, master, with text rendering
3425 frames in 5 seconds = 684.887 FPS
3350 frames in 5 seconds = 669.988 FPS
3696 frames in 5 seconds = 739.131 FPS
3433 frames in 5 seconds = 686.589 FPS
3533 frames in 5 seconds = 706.578 FPS

Machine 2, min-mem, with text rendering
3842 frames in 5 seconds = 768.333 FPS
3678 frames in 5 seconds = 735.430 FPS
3607 frames in 5 seconds = 721.216 FPS
3609 frames in 5 seconds = 721.658 FPS
3734 frames in 5 seconds = 746.759 FPS

Machine 2, master, without text rendering
6274 frames in 5 seconds = 1254.719 FPS
6118 frames in 5 seconds = 1223.462 FPS
6118 frames in 5 seconds = 1223.447 FPS
6237 frames in 5 seconds = 1247.338 FPS
6330 frames in 5 seconds = 1265.970 FPS

Machine 2, min-mem without text rendering
5637 frames in 5 seconds = 1127.273 FPS
5684 frames in 5 seconds = 1136.789 FPS
5848 frames in 5 seconds = 1169.582 FPS
5760 frames in 5 seconds = 1151.833 FPS
5838 frames in 5 seconds = 1167.594 FPS

So do think that minimizing the x11 server side memory is a good idea or not?
If there is not a permanent animation on the whole window the server side memory usage is zero and the performance seems to be even slightly better in the worst case for permanent full window redrawing, so IMHO this PR does overall improve things.

I see no point at all in "minimizing" server side memory sometimes, when two buffers are going to exist at the same time anyway.
Which means the fastest things wins, which seems is the current master.  I find your results with text rendering being faster... odd.  Why would that be the case?  I get the opposite, master is always faster, which makes sense because it's doing much less.

I see no point at all in "minimizing" server side memory sometimes, when two buffers are going to exist at the same time anyway.

My impression is, that x11 server and cairo are optimized to handle these things themselfs and there is no need for the client to permanently reserve buffers only for temporary usage.
If you have multiple pugl windows in current master each one will allocate server side memory permanently. With the minimized memory patch the overall memory usage will be much lower because memory will be reused for different windows.
Look at xrestop with a maximized Pugl window on current master: this will permanently allocate more memory than most gtk applications with the same window size are using. If one application has more Pugl windows this memory will linearly increase whereas in most gtk applications the memory does not increase lineary for more windows. So I'm pretty shure that gtk itself does not allocate permanent buffers for each window.
One could improve Pugl by only allocating the buffer in PuglWorld and share it between PuglViews. But I don't see an advantage here because the performace gain for permanently allocating buffers seems to be minimal for typical applications, and on my machines it is even faster without permanent buffers.  What frame rates did you measure? You mentioned only a drop of 150.

I find your results with text rendering being faster... odd. Why would that be the case?

I assume cairo could do better optimization for this by reusing memory and/or graphic card resources that are already used by other applications. With permanently allocated buffers the x server perhaps must do more switches to use the special reserverd resources. What version of cairo and x server do you have? I have cairo 1.17.2 and x server 1.20.5.

Cairo 1.17.3 Xorg 1.20.5
Sorry, I would need to see some positive results myself to consider this.  I don't care what xrestop says, to be honest.  As far as I can tell it just makes everything slower (and Pugl is not intended for apps that create a ton of windows anyway).  What I see - that doing more work by allocating buffers every frame makes things slower - is intuitive and makes sense.

What I see - that doing more work by allocating buffers every frame makes things slower - is intuitive and makes sense.

my intuition says different: it's often better to have small memory and resource usage for better performance.

This does not reduce resource consumption in the case of drawing...

To get a better understanding I did some more measurements:

one app pugl_cairo_test with -a -c -r and different sizes (512x512 and maximized to screen 1920x1080):

master 512x512:    1456 FPS
master maximized:   390 FPS

minmem 512x512:    1563 FPS
minmem maximized:   317 FPS

four simultanously running apps pugl_cairo_test (original size 512x512) with -a -c -r:

master: 273 FPS per app
minmem: 319 FPS per app

These numbers indicate that on this machine smaller windows seems to be rendered from the x server in some kind of (hardware?) accelerated context that is shared between apps whereas bigger windows are not running in the accelerated context and for minmem then there is some overhead for always creating a new buffer.
So IMHO from this there is still no clear indication if minmem is general a good idea or not, but it shows that in the minmem case the x server could do (hardware?) acceleration, if the buffer is not too large, wheres in the case with fixed buffers there is no acceleration. I would guess that the above results also depend on the graphics card (on this machine it was: "Intel Xeon E3-1200 v3/4th Gen Core Processor Integrated Graphics Controller").

After entirely too much time, I finally figured out why the alpha kludge is required to make this work.  You're right that Gtk does it this way, but there is no alpha there, and they even use CAIRO_OPERATOR_SOURCE in addition.  Doing that in Pugl makes everything horrible though, especially in partial expose scenarios highlighted by pugl_cairo_test.
The "why" is obvious in retrospect: there's no clipping.  Even ignoring the double buffering strategy part, the current X11 Cairo backend is totally wrong for partial exposures.
I'm working on fixes for this and a rework of this change on top of it.  This will change the performance situation a bit, but it seems to work well for me.  Still slower, but it will be interesting to see what the effect is on that strange machine of yours...

Try https://github.com/lv2/pugl/tree/partial-draw

OK, I tested on three machines: Machines 1 & 2 are Thinkpads (ca. >= 6 years old), 3 is a normal PC (also ca. >= 6 years old).

Test A: current Master
Test B: current Master with my alternative x11 cairo backend (see https://github.com/osch/pugl/blob/test-x11-cairo/pugl/detail/x11_cairo_01.c)
Test C: your `partial-draw´ branch (https://github.com/lv2/pugl/tree/partial-draw)

Test program is pugl_cairo_test  -a -c -r
Results:

Machine 1

Test A: 2229.772 FPS
Test B: 2474.833 FPS
Test C: 774.261 FPS

Machine 2

Test A: 2907.769 FPS
Test B: 2895.188 FPS
Test C: 1776.110 FPS

Machine 3

Test A: 3098.664 FPS
Test B: 5367.722 FPS
Test C: 1603.596 FPS

Best regards,
Oliver

Sorry, I should have clarified.  The frame rates of this branch are not comparable to the others because it used to be counting exposures which were not merged (4 per frame).

The frame rates of this branch are not comparable to the others

And how did you compare performance?

https://github.com/lv2/pugl/commit/2495d2deb77c8474d7bbe467a0d033909ee3263c is the relevant commit.

I'm sorry but I don't understand your answer. 2495d2d is the partial redraw branch (except that afterwards pugl_cairo_test.c got slight modifications. I tested on this branch. You wrote "It is a bit slower for a single application in most cases". So how did you compare the performance and what did you measure? Did you also measure my approch from https://github.com/osch/pugl/blob/test-x11-cairo/pugl/detail/x11_cairo_01.c ?

Compare which performance?  If you interested in the memory consumption / ephemeral surface thing, then that commit is the one that does that.  Measuring before and after that commit will show the performance with long-lived vs short-lived Cairo surfaces.
The expose model on old master is just wrong, there is no comparison to be made between master (or your original branch on it) and partial-draw.  Your original alpha kludge was a workaround for this deeper problem, but even with that, it resulted in a bunch of visibly sketchy behavior to try to draw more than is actually exposed.
That said, at least for me the "draw as fast as possible" thing that pugl_cairo_test does completely bogs down the X server and stalls other instances of the program when there's lots of events (like mouse movement), so I'm not sure how much benchmarking this program as it is makes sense anyway.  I don't know if, or even how, it's even possible to draw as fast as possible on X11, or at least the event loop API would probably need to be changed to be able to write a reasonable real program that works this way.
Anyway, it's simpler and what Gtk does and not significantly slower (and Cairo is slow regardless) so I don't really care much.

Your original alpha kludge was a workaround for this deeper problem, but even with that, it resulted in a bunch of visibly sketchy behavior to try to draw more than is actually exposed.

Do you have more details on this? I tested it thoroughly and didn't notice any flaws. However I always assumed that the application is setting up a clipping region on the context it is drawing.
Unfortunately the current solution enforces a specific drawing model on the application. I'm experimenting with the possibility that the application handles the list of individual exposure rectangles itself and not only one merged exposure rectangle. Roughly speaking I see two types of drawing models:

simple application that always just redraws the whole view at once: for these applications it is best just to get one merged exposure rectangle. It makes no sense for this type of application to trigger partial redraws.
application that considers redraw rectangles and draws only affected widgets: this type of application would ideally collect all redraw rectangles and make one drawing pass through the widgets considering the whole list of rectangles.

You may have a look at https://github.com/osch/pugl/commit/432196659691ececf1afb66b00187ac17070830c where I implemented an option to have support for both types of drawing models (even for Windows and MacOS < 10.14) by passing the individual exposure rectangles to the application using the count member of the exposure event structure.
There seems to be a use case for drawing model 2. in real-world scenarios, see e.g. https://forum.juce.com/t/juce-coregraphics-render-with-multiple-paint-calls-not-working-on-new-mac-mojave/30905 or https://github.com/steinbergmedia/vstgui/commit/245ba880aa807a17aafac515efaeaa92c13f5093

Do you have more details on this? I tested it thoroughly and didn't notice any flaws. However I always assumed that the application is setting up a clipping region on the context it is drawing.

It doesn't matter if you are clipping in the application if pugl is blitting the entire surface anyway.  Even worse if it's doing so with alpha blending.
You can't immediately dispatch expose events like pugl was before.  It conflicts with the deferred expose model where exposes happen at the end of the loop, and generally causes a bunch of weird problems with all these exposes coming from different places and happening at different times.  Most importantly and especially on X11, it also means that the exposes probably won't happen in this event loop at all, which is a real problem people have had that causes noticeable lag, especially in plugin UIs where things are not driven so quickly.  It means that if you request a redraw of your animating button or whatever, the actual expose might not come back until a whole event loop later.
Not unifying isn't a different model so much (you are always required to draw whatever the library tells you to, no exceptions), it's just an optimization.  If you want to implement that, awesome, but as I say in the commit, for that pugl would have to implement a rect set instead of storing just the one, probably add optimization of it to not send overlapping exposures, etc etc.

Analogous change made in https://github.com/lv2/pugl/commit/2495d2deb77c8474d7bbe467a0d033909ee3263c

It doesn't matter if you are clipping in the application if pugl is blitting the entire surface anyway.

The difference it that if it's clipped in the application the clipped areas will remain alpha = 0.0 even if some widgets are drawing something outside the clipping region. So if there are widgets that draw outside of the drawing region than there should be some clipping. For the end result it doesn't matter if the clipping is done in the application or on the x11 target surface. If the widgets do consider the clipping area than there would be no clipping necessary. If clipping is necessary than it's better to do it on the drawing surface since otherwise things are drawn on the drawing surface that may have been optimized away by cairo's clipping and only afterwards these drawings are discarded if the drawing surface in blitted onto the x11 target surface.

Even worse if it's doing so with alpha blending.

Why do you think it's worse? All the measurements I made on three different machines showed that this is not the case (at least in my cases), i.e. there seems to be optimization for blending larger areas with alpha = 0.0. It's an implementation detail within cairo wether clipping performance is better than areas with alpha = 0.0 and IMHO you can only decide this if you study cairo's source code or do some measurements.

Most importantly and especially on X11, it also means that the exposes probably won't happen in this event loop at all, which is a real problem people have had that causes noticeable lag,

Yes I know  and considered this in my implementation.

If you want to implement that, awesome

I already implemented it, see https://github.com/osch/pugl/commit/432196659691ececf1afb66b00187ac17070830c

for that pugl would have to implement a rect set instead of storing just the one

This would be one possible solution. I chose another way that does better fit into current pugl's architecture by letting the application collect the rectangle list. The application can choose the drawing model 2 by setting puglview->hints[PUGL_DONT_MERGE_RECTS]) and after this the exposure rectangles are not merged but are delivered to the application. With this option set the application should only draw if count == 0 in the exposure event. As I wrote: this does also work under Windows and Mac OS < 10.14.

Analogous change made in 2495d2d
drobilla closed this 1 hour ago

Yes I agree the purpose of this issue has been reached: x11 server side memory is minimized.
If you are interested in further collaboration on supporting drawing model 2 I could open new issue or PR.

I am not interested in discussing this alpha thing anymore.  It was an ugly kludge around drawing being broken, drawing a larger region with alpha blending is obviously worse than drawing a smaller one without it, clipping in the application is a separate thing, and drawing is no longer broken so it isn't needed anyway.

Yes I know and considered this in my implementation.

Apparently not https://github.com/osch/pugl/commit/432196659691ececf1afb66b00187ac17070830c#diff-ee74428ad181f3c9964f8ea87536619bR1051

This would be one possible solution.

That is the only possible solution.

Yes I know and considered this in my implementation.

Apparently not osch@4321966#diff-ee74428ad181f3c9964f8ea87536619bR1051

you are refering to:
https://github.com/osch/pugl/blob/432196659691ececf1afb66b00187ac17070830c/pugl/detail/x11.c#L1046-L1051
		XExposeEvent ev = {Expose, 0, True,
		                   view->impl->display, view->impl->win,
		                   x, y,
		                   w, h,
		                   0};
		XSendEvent(view->impl->display, view->impl->win, False, 0, (XEvent*)&ev);

but this is the else case of the following if: please have a closer look at:
https://github.com/osch/pugl/blob/432196659691ececf1afb66b00187ac17070830c/pugl/detail/x11.c#L1030-L1039
puglPostRedisplayRect(PuglView* view, PuglRect rect)
{
	if (view->world->impl->dispatchingEvents) {
		// Currently dispatching events, add/expand expose for the loop end
		const PuglEventExpose event = {
			PUGL_EXPOSE, 0, rect.x, rect.y, rect.width, rect.height, 0
		};

		addPendingExpose(view, (const PuglEvent*)&event);
	} else if (view->visible) {

so I'dont think that it's apparent that I didn't consider it. Or are you seeing something that I'm missing? Than I would be happy to hear more details.

https://github.com/osch/pugl/blob/432196659691ececf1afb66b00187ac17070830c/pugl/detail/x11.c#L840

You are referring to the invocation of puglDispatchEvent in https://github.com/osch/pugl/blob/432196659691ececf1afb66b00187ac17070830c/pugl/detail/x11.c#L834-L847
addPendingExpose(PuglView* view, const PuglEvent* expose)
{
        if (view->hints[PUGL_DONT_MERGE_RECTS]) {
            if (view->impl->pendingExpose.type) {
                puglEnterContext(view, true);
                view->impl->pendingExpose.expose.count += 1 + expose->expose.count;
                puglDispatchEvent(view, &view->impl->pendingExpose); //<<<<<<
                puglLeaveContext(view, true);
            }
            view->impl->pendingExpose = *expose;
        } else {
            mergeExposeEvents(&view->impl->pendingExpose, expose);
        }
}

This is the part where my given description comes in:

The application can choose the drawing model 2 by setting puglview->hints[PUGL_DONT_MERGE_RECTS]) and after this the exposure rectangles are not merged but are delivered to the application. With this option set the application should only draw if count == 0 in the exposure event.

I cannot see what is wrong here except that the invocation of puglEnterContext(view, true); could be questioned, since the application should only collect the rectangle here and should not draw (because count>0). So perhaps it's better to omit puglEnter/LeaveContext here or to pass false instead of true.
I'm not saying that this is the best thinkable or only solution here but at least it is a working starting point. I'm open also for others solutions/suggestions.

Making the application collect rectangles to draw... at.. some point.. later... (?) is confusing and error-prone at best.  That puts the burden on applications to deal with all of this correctly (which they won't), and I don't even see how it would be possible to do so.  If you don't draw when you get expose events then when do you draw?  Pugl now needs to send some other expose event later?  With what region?  We add some weird PuglReallyExposePendingExposuresNow event?
That's way too complicated, especially if the semantics are different between platforms.  The entire point of a library like Pugl is to abstract away this kind of crap.
(What's the point anyway?  You don't need Pugl to send changed rectangles to yourself, if you really want to draw to an image and update only the parts you know have changed and expose that instead, you can).
This is the Pugl expose API:

The application is required to draw the entire expose region when handling that event.
Any posted redisplays in the event loop produce exposures which are dispatched at the end of the same puglDispatchEvents invocation.

Simple, universal/well-understood, and it's easy to write both applications and backends correctly based on this model.  It won't change.
I'm still not sure if this is guaranteed on Windows or MacOS using the window system facilities.  If not, those backends will have to handle it internally like the X11 one does.  I'd look into this before investing more time into using InvalidateRect and friends.

I'm open also for others solutions/suggestions.

Again, Pugl needs to maintain a rect list to do this, at least on X11.  If there's platform support, like you used on Windows there, and the semantics are right, then that's fine too, but no breaking the drawing model.

That puts the burden on applications to deal with all of this correctly (which they won't),

Drawing model 2 is only for application that want to handle this correctly, i.e. for applications that are dealing with a lot of smaller widgets and decide from the list of exposure rectangles which widget is to be drawn. To make this efficient it is best to collect the list of rectangles and let the applications handle them at once. For Windows and Mac the list of rectangles can be obtained from the operating system when the redraw event occurs.

That's way too complicated, especially if the semantics are different between platforms.

In my implementation the semantics is the same for all platforms: if the application sets PUGL_DONT_MERGE_RECTS then the application must only draw on exposure events with count == 0 and for count > 0 only should add the rectangle to a list. IMHO that's a simple solution for drawing model 2. IF the PUGL_DONT_MERGE_RECTS is not set, then every exposure event will be with count == 0 and the application must draw on every exposure event.

if you really want to draw to an image

I don't want to draw to an image.

Pugl now needs to send some other expose event later?

No, it's an exposure event with count == 0.

To make this efficient it is best to collect the list of rectangles and let the applications handle them at once.

At once when?

Judging by pugl_redisplay_test in https://github.com/lv2/pugl/tree/test, MacOS can't be relied on to dispatch these immediately anyway, so pugl has to handle it there too.
I wouldn't be surprised if the same is true on Window as well but it's just less likely, but I'm not sure.

Which is sent when?

For X11 it is (as it was before) at the end of the function puglDispatchEvents, see  https://github.com/osch/pugl/blob/432196659691ececf1afb66b00187ac17070830c/pugl/detail/x11.c#L992-L994
For Win it is the remaining expose event with the last recangle after all other rectangles have been dispatched, see https://github.com/osch/pugl/blob/432196659691ececf1afb66b00187ac17070830c/pugl/detail/win.c#L855-L865
For Mac it is the last expose event that is dispatched, see https://github.com/osch/pugl/blob/432196659691ececf1afb66b00187ac17070830c/pugl/detail/mac_cairo.m#L66-L68

MacOS can't be relied on to dispatch these immediately anyway

Immediate dispatch of exposure events is for Win and Mac not as necessary as it is for X11 because on Win and Mac this is all happening in the central event queue that is also driven outside the PuGL event loop. On X11 there is no central event queue so if on X11 the plugin does not start its own GUI thread but only handles events in an idle callback than there might be unresponsive behaviour if events are stuck in the event queue and the idle callback is only invoked again after a certain time passed.

Then how do I know whether to draw the entire region that expose specifies, or only the ones that came before?
What happens when the window system sends exposes too?  What if they overlap?
What is the advantage of all this complexity from the point of view of the application developer?

Slightly related, how could application developer inject a custom event from application logic to be handled like any other PUGL_ event?
The idea is to maintain a single event queue and handle most things with events (eg. a custom event "widget xy has requested a partial redraw at xx, yy"). A smart, application-centric event parser could then merge, skip, throttle and do other things with events, also being smart about partial redrawing, keeping pugl smartness at an easy level. Any thoughts?

Then how do I know whether to draw the entire region that expose specifies, or only the ones that came before?

With PUGL_DONT_MERGE_RECTS set the redraw region is the union of all rectangles that was passed in exposure events with count > 0 including the last one that is passed with count == 0.

What happens when the window system sends exposes too?

Everything works, I see no problems here.

What if they overlap?

Normally that doesn't matter: the application just has to draw the area consisting of the union of the passed rectangles. If the application needs to have rectangles that don't overlap than the application can split them but IMHO in most cases an application using drawing model 2 just needs an area and then tests which widgets intersect with the area and redraws only those widgets, thus an application using this mode is drawing widget oriented and not rectangle orientated, the rectangles are only for setting up a clipping region and for testing which widget has to be drawn.

What is the advantage of all this complexity from the point of view of the application developer?

The advantage is that for applications with a lot widgets drawing performance is improved:

The advantage of having separate rectangles and not a unified rectangle is that lesser widgets are to be redrawn.
The advantage of drawing the rectangles all at once and not each seperately is that some drawing operations (e.g. background widgets that are intersecting with more than one rectangle) have only to be done once for the whole list.

No, I mean the advantage of this convoluted expose model you are proposing, not having fine grained exposures at all.  Why would I want this? Why wouldn't I just want the library to tell me exactly what to draw at the right time?

Do you mean: why in my implementation the rectangles for the whole redraw area are given separately in different events and not at once as a whole list? There is no advantage in doing this, it was just easier to fit into the existing code base. It could also be easliy implemented to hold the list of rectangles in Pugl and give it at once to the application (at the point when my current implementation passes the event with count == 0)

Well, sort of.  I mean the concept of a deferred expose, then a later non-deferred expose that means you need to actually expose the earlier ones, etc.  They don't need to be provided literally as a list (events are POD anyway).

There is no advantage in doing this, it was just easier to fit into the existing code base.

This is my point, really.  It significantly complicates the API, and adds a bunch of weird consequences (like Pugl having to send two exposes for a simple whole window refresh) for no benefit compared to Pugl doing it properly.
In case it's not blindingly obvious at this point, I'm not merging that kind of thing.  I am specifically working to get Pugl away from its history as a heavily forked collection of half-baked hacks that sometimes worked somewhere.  The quality of master (and the upcoming release) goes only up from here, never down.  I don't think even the current implementation is quite right, especially on MacOS...

It could also be easliy implemented to hold the list of rectangles in Pugl and give it at once to the application.

Possibly.  If it's easy enough to do, then Pugl can do it.  If it's not, then it's not reasonable to expect applications to do it.  We'll have to see...

 This is not the case: for a simple window refresh there is only one expose event. Your answer gives me the impression that it could be that my previous explanations were misleading :-(

I'm not merging that kind of thing

Yes I already assumed this, therefore I just made the implementation  minimal such that there are only very minimal changes to original Pugl as possible. Therefore I didn't introduce a rectangle list that is given to the application I reused the existing count variable in the expose event.

don't think even the current implementation is quite right, especially on MacOS

Why do you think so? I tested it thoroughly under Mac OS 10.13, 10.14 and 10.15 and if you have any hints that there could be some flaws it would be nice to give more details.

This is not the case: for a simple window refresh there is only one expose event.

How is this expose any different from the one that comes after a bunch of deferred exposes then?

don't think even the current implementation is quite right, especially on MacOS

See the tests branch.  I managed to get this to work there, but MacOS is weird because events are dispatched in puglPollEvents().  That's not how things are supposed to work, and it makes it impossible to control when events are dispatched in applications.  I'm not sure if it's actually possible to have separate wait and process functions there.  Maybe this was a mistake, it seems common, but I don't know if/why anyone would really miss it over a unified iterate function, which would also make some of the X11 cases a lot easier to deal with...

How is this expose any different from the one that comes after a bunch of deferred exposes then?

Why should it be different? A simple window refresh will lead to just one expose event in the application with count == 0 and full width and height at the end of the dispatch loop just as in normal Pugl. If there are more than one expose events while running the event loop (it doesn't matter if these are from the system or coming directly from the application) these events will be delivered with count > 0 to the application and only the last exposure rectangle in the event loop is delivered with count == 0.

I am not suggesting a rectangle list that is given to the application. I am saying the API doesn't need to change at all. Expose events as they currently are are fine.

This is only fine if the application uses drawing the simple model 1, but not for applications that are drawing widget oriented. If for example an application has two small widgets that are needing a refresh at the top left and bottom right corner of the window the application will get a merged rectangle for the whole window in the current implementation. This is not wanted for drawing model 2. In my implementation there is a much smaller area to be redrawn, since the two small rectangles are delivered as rectangle list to the application. This does work under Win, X11 and Mac < 10.14.

MacOS is weird because events are dispatched in puglPollEvents()
it makes it impossible to control when events are dispatched in applications

Yes, I also observed this when I implemented process timer in my LPugl branch (https://github.com/osch/lua-lpugl/blob/master/doc/README.md#world_setProcessFunc). It's nearly impossible to have full control when events will be dispatched under Windows and Mac OS and I wouldn't even try to do so. I don't see a unsolvable problem here, but I agree that the separate puglPollEvents and puglDispatchEvents are misleading since they only fit exactly to the x11 implementation. However it is also nice to have these functions separate for the x11 case.

Also I suspect the clipping is still wrong there.

Ah sorry, I thought it was obvious: my current implementation requires the clipping-less drawing backend (with alpha layer drawing). As you don't want to have this, the implementation must be extended to provide all rectangles to the backend such that the backend can set up the clipping correctly. Again: my implementation just tries to have only minimal changes to original Pugl, since since I'm assuming that my modifications will not be merged. My current implementation was never meant for directly merging, it is a working and correct implementation and I only showed it to you as a proof of concept and perhaps starting point for improving Pugl to support drawing model 2 applications.

A simple window refresh will lead to just one expose event in the application with count == 0 and full width and height at the end of the dispatch loop just as in normal Pugl.

only the last exposure rectangle in the event loop is delivered with count == 0

So in one case, I get an expose with count 0 and I have to draw the whole thing.
In the other case, I get an expose with count 0 and I do not draw the whole thing.
Again, how do I know the difference?

these events will be delivered with count > 0 to the application and only the last exposure rectangle in the event loop is delivered with count == 0

An old-school, full-rectangle-redraw app would check if count==0 for expose event, is that correct @osch ?

drobilla, what's the problem? wanna block me?

drobilla, why do you delete my comments?

@7890 This thread is bad enough without you running it off the rails.   Please stop.

So in one case, I get an expose with count 0 and I have to draw the whole thing.
In the other case, I get an expose with count 0 and I do not draw the whole thing.
Again, how do I know the difference?

You always have to draw the area that is given by the exposure rectangle(s). If the exposure rectangle(s) cover the whole view than it's a full redraw. But a widget oriented application will not distinguish these cases: it will just consider the widget and redraws all widgets that are intersecting the area, and if the area is the whole view, than it automatically is a full redraw.

There is nothing special about a "full redraw".  The window system can expose part of the window too.  You can't use the area to distinguish these cases.


[GLUTEN-8206][VL] Support collect_set in window

What changes were proposed in this pull request?
Support collect_set in window, after
(Fixes: #8206)
How was this patch tested?
Add new tests

LGTM, thanks.

@zhli1142015


Allow action to terminate if there are no commits in the release

Currently the action will create a release even if there are no relevant commits to create the release for. Many users would probably prefer the action to terminate if it does not find any relevant commits in the commit range specified.

The default behavior has now changed to not releasing empty releases. A new output variable released has been added which indicates whether or not a release was created. This is stringified (by core library) to either true or false.
If anyone is interested it is possible to add an optional input argument to specify whether to allow empty releases. It should default to false and would thus be backwards compatible.


remove the pre and post script extensions if value is empty

Summary by CodeRabbit

New Features

Enhanced script update logic to filter out extension elements based on script type.

Bug Fixes

Improved handling of script updates with conditional logic for falsy values.

Refactor

Restructured and reformatted code for better readability in CustomContextPadProvider and SpiffScriptGroup.

Chores

Adjusted formatting of function parameters for clarity.

dup of #115


setImmediate(fn) instead of setTimeout(fn, 0);

setImmediate() is faster then setTimeout() - uses more CPU, less waiting and blocking.
Here is a good implementation: https://github.com/YuzuJS/setImmediate

Thank you for the pull request, I will however not merge this in until (and IF) it becomes a standard, as if I add this in that means that I should also add tons of feature requests using proprietary  vendor specific APIs.
Best regards,
Ivan


[XLA/tfcompile] Add Env::CreateNewFileWithUniqueName and use it in SaveGraph

Split part of tensorflow::Env::LocalTempFilename into tensorflow::Env::CreateTempFilename so that it can be used in SaveGraph.
This PR is to replace #15335.
I am terrible in creating descriptive function name, better name suggestion for CreateTempFilename is welcomed.
/cc @jlebar.
#15213

Can one of the admins verify this patch?

Jenkins, test this please.
(Am I doing this right?  I don't review too many OSS patches.)

@jlebar I think you need to mention @tensorflow-jenkins
See https://github.com/tensorflow/tensorflow/pull/15491#issuecomment-352861743

Hm, maybe?  I see some people doing it without, e.g. https://github.com/tensorflow/tensorflow/pull/12503#issuecomment-330725991
Anyway, can't hurt.
@tensorflow-jenkins, test this please.

@yifeif Can you help us to trigger CI tests?

@tensorflow-jenkins test this please


Three-way merge feature in fortune.net.sync

Currently, all remote changes override the local instance, but it would be nice to allow this to be customized with a user-supplied merge function to determine whether to keep local or remote.
Also, the sync doesn't get changes to existing records that were made while the client is offline, so this feature may be nice to have as well. (decided no, leaving this up to the client)

Done in commit https://github.com/fortunejs/fortune/commit/a958d6ed65b3048f2ae3ba229a77bcb2b3225520.


⚠ Bofrost.de has degraded performance

In 992b316, Bofrost.de (https://www.bofrost.de) experienced degraded performance:

HTTP code: 200
Response time: 1480 ms

Resolved: Bofrost.de performance has improved in 86c0d13 after 23 minutes.


[T7][F12-B4]

Ready for review.

Will continue updating the user guide over the next week as we morph the project towards the concept of bullet journal!

@bryanleejh @arishuynhvan @zhypaul @WangYu-g
Some comments added. Please ack & close the PR after reading comments.
For some reason, I missed reviewing it earlier. Apologies for that!
Good to see all of you have contributed to this exercise. Please keep up the good job.


Make it clear that it doesn't need

I've noticed some misunderstandings in the community that unplugin-auto-import requires using <script setup> syntax, based on the fact that the code examples are using it exclusively.
It could possibly be helpful to state that it's not necessary and it works just fine without it.

Yes, indeed. I just notice we didn't have many statements to explain what this plugin is trying to do (we actually work in any js/ts files). I am open to PR if anyone what to kickstart it.

I don't think we want it atm. Vitesse could already be a good index / showcases of them


[ci] also test in 3.11 / 3.12

[ci] also test in 3.11 / 3.12
3.12 is the current python stable version, we should probably make sure it works?

It looks like https://github.com/facebook/TestSlide/commit/2a18d5ec77e3e4898e44d0f0afbed6456ec4d58b broke the build a while back @macisamuele (not sure how this was allowed to be merged...).


#216 first draft. generateHTML and htmlSanityCheck works

see #216 for more details

ok. still fighting with travis, just give me some additional time :-)

hhm - Travis build fails: @rdmueller, could you please have a look?

yeah, already working on this...

wow. three different build environments (travis, ps and bash) and three different errors for the target "check"

wow. that was a hard one:

on a windows system there are 4 failing tests in RC2
somehow I had to reference mavencentral and jcenter as repositories for the codenarc plugin to work
the check task also invoked the docToolchain checks which currently fail on a linux system g

please sqash this PR when you accept it!

thanx Ralf - a nice step forward in documentation!


Consider removing deprecated add-ons like "YouHosting product"

Since YouHosting is gone forever, why do we keep making new releases with the YouHosting add-on packed with them?

Since YouHosting is gone forever, why do we keep making new releases with the YouHosting add-on packed with them?

@evrifaessa I am in agreement with you on this. It seems the company is out of business and the domain no longer resolves.
@fordnox  What is your opinion do we remove or not?

remove it

Andrius,
It is on the project board as To Do. I will pick it up tomorrow.
Thank you
Timothy Webb
On Sun, Oct 4, 2020 at 6:28 AM Andrius Putna<EMAIL_ADDRESS>wrote:

remove it
—
You are receiving this because you were assigned.
Reply to this email directly, view it on GitHub
https://github.com/boxbilling/boxbilling/issues/666#issuecomment-703234885,
or unsubscribe
https://github.com/notifications/unsubscribe-auth/AD24K7IFWDYA5NSRMUL3O43SJBE5RANCNFSM4SCB2XOA
.


Trackpad scrolling over left pinned container is intermittent

If I go to the pinning tutorial (http://ui-grid.info/docs/#/tutorial/203_pinning) and use my trackpad to scroll over any but the rightmost container, I get jitter in my scrolling.  Sometimes it scrolls normally, sometimes the whole page scrolls without the grid scrolling at all, sometimes it's in between.
It behaves similarly over the rowHeader on selection, and over the groupHeader in grouping, I suspect that it's all pinned containers that exhibit this behaviour.

Looks like this applies to scrolling over the header as well - scrolling doesn't really work well.

This commit 89461bcbcfdfc527655c398df19555738fa9bd63 broke the ability to disable vertical scrolling.
Last unstable version:
http://plnkr.co/edit/k46LqpiBc1cesOP8xdIM?p=preview
Unstable version v3.0.0-rc.20-d4a784f - 2015-04-21:
http://plnkr.co/edit/35szFnzVSPGinvzJgR8y?p=preview


Dahua VTO breaks the backchannel connection when someone rings it

This issue is a deviation from here:

https://github.com/AlexxIT/go2rtc/issues/1133#issuecomment-2125530796

When someone rings the doorbell, the doorbell closes the RTSP backchannel momentarily.
go2rtc quickly detects that and also drops the sendonly track from the source, and keeps the stream working without the sendonly track.
However, go2rtc never discovers the backchannel again automatically when it's available unless the stream is fully closed on go2rtc side and started again.
Some ideas I have:

If go2rtc detects the backchannel sendonly track was present but was dropped, it can keep retrying in the background to re-discover it (will work once the dorbell stops ringing)
Once some client explictly requests sendonly track (for example, if it has a microphone track attached), it means the user is trying to talk with the doorbell. go2rtc can attempt to re-discover the backchannel every time a client requests it.

Also, I believe this is directly related to what @miguelangel-nubla mentioned at:

https://github.com/AlexxIT/go2rtc/issues/49#issuecomment-1828701415

If you open a stream to MainStream and another one to ExtraStream, the second one will not have the audio backchannel, and you will have to both close the first one and reconnect the second one to switch.
SIP is like a extra connection using MainStream, same quirks apply.

I probably have great news. I am doing some more tests after recent discoveries and it looks like the VTO doesn't break the backchannel connection no more. Or least the sendonly channel never disappears from go2rtc sources.
Also, even when someone rings the bell, if there's a 2-way audio connection in progress, it doesn't stop.
Everything you say in the microphone is apparently muted in the doorbell until it stops ringing, but immediatelly after that I can hear me back normally without ever having to reload the stream.
I will continue testing this for more days.


Update silencer-lib, silencer-plugin to 1.7.15

About this PR
📦 Updates

com.github.ghik:silencer-lib
com.github.ghik:silencer-plugin

from 1.7.14 to 1.7.15
📜 GitHub Release Notes - Version Diff
Usage
✅ Please merge!
I'll automatically update this PR to resolve conflicts as long as you don't change it yourself.
If you'd like to skip this version, you can just close this PR. If you have any feedback, just mention me in the comments below.
Configure Scala Steward for your repository with a .scala-steward.conf file.
Have a fantastic day writing Scala!

⚙ Adjust future updates
Add this to your .scala-steward.conf file to ignore future updates of this dependency:
updates.ignore = [ { groupId = "com.github.ghik" } ]

Or, add this to slow down future updates of this dependency:
dependencyOverrides = [{
  pullRequests = { frequency = "30 days" },
  dependency = { groupId = "com.github.ghik" }
}]

labels: library-update, early-semver-patch, semver-spec-patch, commit-count:1

Superseded by #2066.


@derivedFrom isn't working in all instances

We need to investigate when this doesn't work.

After revisiting the adchain example I was able to get the @derivedFrom directive to work; effectively pulling Challenges into the Application type.  The solution to the difficulties I had getting the two-way relationship working appears to be clear, detailed documentation and a diverse set of example subgraphs to reference.

@fordN Is this not a bug then?

Closing, since we got this to work in the adchain subgraph and it wasn't a bug in the software.


Enums not working properly

Version<EMAIL_ADDRESS>When using enums and querying  it, it throws an error photon[mapping.plural].findOne(...)[graphqlField.name] is not a function
enum PricingType {
  NET
  SELLING
}

model Pricing {
  id    String      @default(cuid()) @id @unique
  type  PricingType
  adult Float
  child Float
}

Also types are probably not generated correctly

I believe this is an error with nexus-prisma. It appears that the fix has been merged in to the next version of @prisma/nexus, but I'm not exactly sure how you'd install it using npm. https://github.com/prisma/nexus-prisma/pull/353

@CaptainChemist Yeah, also just found it. But I was unsuccessful installing it. Probably will need to wait for a release.

Ping @jasonkuhrt for confirmation.

@janpio thanks! Yep, moving this one to nexus-prisma repo 👍
@malekjaroslav 👋 a release will be made this week


Use stdlib logging if structlog is missing

Before I tackle configurability, here's stdlib logging by default if structlog is missing (should never happen but the world is what it is).
Does this look OK to you @estahn?
Ref https://github.com/hynek/stamina/discussions/29
FTR: I've changed the key from slept to idle_for because it's a bit weird. Idle_for is the amount of time that will have been slept once the retry is started. Sadly, there doesn't seem to be a way to get just the current sleep value. I'll try to simulate it once this is merged.

Looks good to me. 🚀

Great thanks! And sorry for breaking your workaround. 🙃


Add ingest_data script

See https://github.com/ASFHyP3/asf-stac/issues/1
Starting at the root node of the STAC data tree (that is, the top-level catalog object), performs a pre-order traversal to add all STAC objects to the STAC API application.
I've tested the script by ingesting our coherence catalog, which consists of 751 JSON files, and confirmed that it makes a POST request for each file. Some initial querying of the API after running the script confirms that all of the STAC objects appear to be present.
TODO:

[x] See TODOs in script
[x] Test the script with a collection as the root object.

@forrestfwilliams I update the docstring / help description to include the assumptions that the script makes, could you tell me if those are reasonable assumptions?

Updating existing items would be easy to implement, see https://github.com/stac-utils/stac-fastapi/blob/master/scripts/ingest_joplin.py#L18 for guidance

@forrestfwilliams I update the docstring / help description to include the assumptions that the script makes, could you tell me if those are reasonable assumptions?

Yep, these all look reasonable to me. I don't think you're missing any.


clickhouse-jdbc is faster than ClickHouse-Native-JDBC

Hi all,
I tested the benchmark between clickhouse-jdbc and ClickHouse-Native-JDBC, ClickHouse-Native-JDBC don't really faster as https://github.com/housepower/ClickHouse-Native-JDBC/blob/master/Benchmark.md
Thanks.

Could you show the results of your tests?

Could you show the results of your tests?
Hi @sundy-li,

make 500 queries on 4000.0000 records and results test:
clickhouse-jdbc make 15 seconds
ClickHouse-Native-JDBC make 234 seconds
my code

//class make connection
public class ClickHouseJDBCUtil {

    public static ClickHouseConnectionImpl getConnectionJDBCHTTP() throws SQLException {
        ClickHouseDataSource dataSource = new ClickHouseDataSource("jdbc:clickhouse://<IP_ADDRESS>:8123/db_test?keepAliveTimeout=300000&socket_timeout=300000&dataTransferTimeout=300000");
        ClickHouseConnectionImpl connection = (ClickHouseConnectionImpl) dataSource.getConnection();
        return connection;
    }

    public static Connection getConnectionJDBCNative() throws SQLException {
        Enumeration<Driver> drivers = DriverManager.getDrivers();
        while (drivers.hasMoreElements()) {
            DriverManager.deregisterDriver(drivers.nextElement());
        }
        DriverManager.registerDriver(new ClickHouseDriver());
        Connection connection = DriverManager.getConnection("jdbc:clickhouse://<IP_ADDRESS>:9000");
        return connection;
    }
}

//class test benchmark
public class TestFetchData {
    public static void main(String[] args) {
        long start = System.currentTimeMillis();
        try {
            List<ThreadTestFetchData> threads = new ArrayList<ThreadTestFetchData>();
            for (int i = 0; i < 10; i++) {
                ThreadTestFetchData t = new ThreadTestFetchData();
                threads.add(t);
                t.start();
            }
            for (ThreadTestFetchData t: threads) {
                t.join();
            }
        } catch (Exception e) {

        }
        long end = System.currentTimeMillis() - start;
        System.out.println("===============> " + end);
    }
}

class ThreadTestFetchData extends Thread {

    public void run() {
        try {
            Connection connection = ClickHouseJDBCUtil.getConnectionJDBCNative();
//            Connection connection = ClickHouseJDBCUtil.getConnectionJDBCHTTP();
            for (int i = 0; i < 10; i++) {
                CertificateData data = CertificateData.random();
                test1(data, connection);
                test2(data, connection);
                test3(data, connection);
                test4(data, connection);
                test5(data, connection);
            }

            System.out.println("done");

        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    public void test1(CertificateData data, Connection c) throws SQLException {
        PreparedStatement p = c.prepareStatement("select * from db_test.certificate WHERE name_certificate_profile = ? AND  effective_date_cert > ? AND effective_date_cert < ? limit 100");
        p.setString(1, data.name_certificate_profile);
        p.setTimestamp(2, new Timestamp(data.effective_date_cert.getTime()));
        p.setTimestamp(3, new Timestamp(data.expire_date_cert.getTime()));
        ResultSet rs = p.executeQuery();
    }

    public void test2(CertificateData data, Connection c) throws SQLException {
        PreparedStatement p = c.prepareStatement("select * from db_test.certificate WHERE timevalidity_cert = ? AND  effective_date_cert > ? AND effective_date_cert < ? limit 100");
        p.setInt(1, data.timevalidity_cert);
        p.setTimestamp(2, new Timestamp(data.effective_date_cert.getTime()));
        p.setTimestamp(3, new Timestamp(data.expire_date_cert.getTime()));
        ResultSet rs = p.executeQuery();
    }

    public void test3(CertificateData data, Connection c) throws SQLException {
        PreparedStatement p = c.prepareStatement("select * from db_test.certificate WHERE id_certificate_profile = ? AND  effective_date_cert > ? AND effective_date_cert < ? limit 100");
        p.setInt(1, data.id_certificate_profile);
        p.setTimestamp(2, new Timestamp(data.effective_date_cert.getTime()));
        p.setTimestamp(3, new Timestamp(data.expire_date_cert.getTime()));
        ResultSet rs = p.executeQuery();
    }

    public void test4(CertificateData data, Connection c) throws SQLException {
        PreparedStatement p = c.prepareStatement("select * from db_test.certificate WHERE postal_code = ? AND  effective_date_cert > ? AND effective_date_cert < ? limit 100");
        p.setString(1, data.postal_code);
        p.setTimestamp(2, new Timestamp(data.effective_date_cert.getTime()));
        p.setTimestamp(3, new Timestamp(data.expire_date_cert.getTime()));
        ResultSet rs = p.executeQuery();
    }

    public void test5(CertificateData data, Connection c) throws SQLException {
        PreparedStatement p = c.prepareStatement("select * from db_test.certificate WHERE type_token = ? AND  effective_date_cert > ? AND effective_date_cert < ? limit 100");
        p.setString(1, data.type_token);
        p.setTimestamp(2, new Timestamp(data.effective_date_cert.getTime()));
        p.setTimestamp(3, new Timestamp(data.expire_date_cert.getTime()));
        ResultSet rs = p.executeQuery();
    }

}

table

ATTACH TABLE certificate
(
    `serial_cert` String,
    `status_cert` Int8,
    `change_status_date_cert` DateTime,
    `change_status_reason_cert` String,
    `expire_date_cert` DateTime,
    `effective_date_cert` DateTime,
    `subject_dn_cert` String,
    `subject_email_cert` String,
    `timevalidity_cert` Int8,
    `email_customer` String,
    `name_customer` String,
    `username_customer` String,
    `phone_customer` String,
    `address_customer` String,
    `name_certificate_profile` String,
    `id_certificate_profile` Int8,
    `serial_token` String,
    `type_token` String,
    `id_request_user` Int8,
    `name_request_user` String,
    `serial_request_user` String,
    `id_approve_user` Int8,
    `name_approve_user` String,
    `serial_approve_user` String,
    `name_department` String,
    `id_department` Int8,
    `postal_code` String
)
ENGINE = MergeTree
PARTITION BY toYYYYMM(effective_date_cert)
ORDER BY (effective_date_cert, serial_cert)
SETTINGS index_granularity = 8192

@thangntt  Thanks for the feedback.
But I can't reproduce it, because I don't have your datasets.
Yet I create a simple test from your code, but it shows the results that native-jdbc performs better than http-jdbc. https://www.onlinegdb.com/BJ32hLM-D
Some advice on benchmark:

I think in the case of jdbc benchmark, concurrent benchmark is the same as the single benchmark.
Results may be different in varying datasets.
OLAP query results are always with fewer columns and rows.

Hi @sundy-li
Thank you for the reply,
I tested the benchmark your code and the results that http-jdbc performs better than navite-jdbc.
I tested open a new connection and the results that http-jdbc performs better than navite-jdbc.
I think native-jdbc must be faster, I don't understand why that is.
file config click-house:
https://onlinegdb.com/H1qBHnG-w

Ok, which ClickHouse version are you using?  I am using 19.18.1 and <IP_ADDRESS>

I am using <IP_ADDRESS>3 and <IP_ADDRESS>
I try on the above version, but result is the same

I find test per by other people
https://groups.google.com/forum/#!msg/clickhouse/dsUTnHihjs4/NOi0y0jxAAAJ

I found the performance test results of others
https://groups.google.com/forum/#!msg/clickhouse/dsUTnHihjs4/NOi0y0jxAAAJ

That's the old version results. Which Native-JDBC and clickhouse-jdbc version are you using ?

I found the performance test results of others
https://groups.google.com/forum/#!msg/clickhouse/dsUTnHihjs4/NOi0y0jxAAAJ

That's the old version results. Which Native-JDBC and clickhouse-jdbc version are you using ?

    <dependency>
        <groupId>ru.yandex.clickhouse</groupId>
        <artifactId>clickhouse-jdbc</artifactId>
        <version>0.2.4</version>
    </dependency>
    <dependency>
        <groupId>com.github.housepower</groupId>
        <artifactId>clickhouse-native-jdbc</artifactId>
        <version>2.1-stable</version>
    </dependency>

@thangntt  I think your configs and machine may lead to the diffs. I create a simple PR  #135 , and you can find the ci bench results.
BTW, I think the select query performance is not as important as the insert query. So most benchmark we just bench the batch insert performance.

Closing this issue, feel free to re-open a closed issue if needed


Removed changes introduced to support JDK8

Signed-off-by: vamsi-amazon<EMAIL_ADDRESS>Description
Removed changes introduced to support JDK8.
Issues Resolved
https://github.com/opensearch-project/sql/issues/466
Check List

[ ] New functionality includes testing.

[ ] All tests pass, including unit test, integration test and doctest

[ ] New functionality has been documented.

[ ] New functionality has javadoc added
[ ] New functionality has user manual doc added

[ ] Commits are signed per the DCO using --signoff

By submitting this pull request, I confirm that my contribution is made under the terms of the Apache 2.0 license.
For more information on following Developer Certificate of Origin and signing off your commits, please check here.

Codecov Report

Merging #513 (adbcb70) into main (6771968) will decrease coverage by 32.33%.
The diff coverage is n/a.

@@              Coverage Diff              @@
##               main     #513       +/-   ##
=============================================
- Coverage     95.24%   62.91%   -32.34%
=============================================
  Files           276       10      -266
  Lines          7410      658     -6752
  Branches        537      118      -419
=============================================
- Hits           7058      414     -6644
+ Misses          298      191      -107
+ Partials         54       53        -1

Flag
Coverage Δ

query-workbench
62.91% <ø> (ø)

sql-engine
?

Flags with carried forward coverage won't be shown. Click here to find out more.

Impacted Files
Coverage Δ

...g/opensearch/sql/expression/text/TextFunction.java

...org/opensearch/sql/expression/ParseExpression.java

...ch/sql/opensearch/response/error/ErrorMessage.java

...in/java/org/opensearch/sql/data/type/ExprType.java

.../org/opensearch/sql/storage/TableScanOperator.java

...a/org/opensearch/sql/data/model/ExprNullValue.java

...sql/expression/aggregation/VarianceAggregator.java

...rg/opensearch/sql/sql/config/SQLServiceConfig.java

...ch/sql/expression/aggregation/NamedAggregator.java

...gation/ExpressionAggregationScriptLeafFactory.java

... and 256 more

Continue to review full report at Codecov.

Legend - Click here to learn more
Δ = absolute <relative> (impact), ø = not affected, ? = missing data
Powered by Codecov. Last update 6771968...adbcb70. Read the comment docs.


how can i detect the border of pdf's table

i need to detect the cell area (position and size) of a pdf table, and auto fill some text into the table cell.
pdf.js can draw the table to canvas, if have some way to detect table's cell area (position and size) by pdf.js's api?
thank.

Given how rendering works in PDFs, using primitive commands, there's not really any concept of e.g. "tables" unfortunately.
Hence there's no way to access such information, and furthermore this issue is also missing lots of details; please actually fill-out https://github.com/mozilla/pdf.js/blob/master/.github/ISSUE_TEMPLATE.md properly when opening an issue.


[DPE-3572] Reenable OpenSearch tests

Reenable OpenSearch tests
Closes https://github.com/canonical/data-integrator/issues/40

Unit tests fail when updating the charm lib, so leaving the current version.


ref(cmd/cli): simplify trafficPolicyCheckCmd output

Description:
Removes dump of TrafficTarget resource from trafficPolicyCheckCmd
output. The inclusion of the resource in the output causes
unnecessary noise due to the managed fields and binary data.
Resolves #3512

Affected area:

Functional Area

New Functionality
[ ]

Documentation
[ ]

Install
[ ]

CLI Tool
[ X ]

Certificate Management
[ ]

Control Plane
[ ]

Ingress
[ ]

Egress
[ ]

Networking
[ ]

Observability
[ ]

SMI Policy
[ ]

Sidecar Injection
[ ]

Security
[ ]

Upgrade
[ ]

Tests
[ ]

CI System
[ ]

Demo
[ ]

Performance
[ ]

Other
[ ]

Please answer the following questions with yes/no.

Does this change contain code from or inspired by another project? No

Did you notify the maintainers and provide attribution?

Is this a breaking change? No

Codecov Report

Merging #3513 (cd0ae95) into main (63b3165) will increase coverage by 0.00%.
The diff coverage is 100.00%.

@@           Coverage Diff           @@
##             main    #3513   +/-   ##
=======================================
  Coverage   66.31%   66.31%
=======================================
  Files         169      169
  Lines        8071     8066    -5
=======================================
- Hits         5352     5349    -3
+ Misses       2689     2687    -2
  Partials       30       30

Flag
Coverage Δ

unittests
66.31% <100.00%> (+<0.01%)
:arrow_up:

Flags with carried forward coverage won't be shown. Click here to find out more.

Impacted Files
Coverage Δ

cmd/cli/trafficpolicy_check.go
43.95% <100.00%> (-1.88%)
:arrow_down:

pkg/endpoint/providers/kube/client.go
79.20% <0.00%> (+0.99%)
:arrow_up:

Continue to review full report at Codecov.

Legend - Click here to learn more
Δ = absolute <relative> (impact), ø = not affected, ? = missing data
Powered by Codecov. Last update 63b3165...cd0ae95. Read the comment docs.


SOLR-13350: multi-threaded search: replace cached with fixed threadpool

https://issues.apache.org/jira/browse/SOLR-13350

Can you recommend a way to benchmark this myself, like if I wanted to tweak it to see how my ideas work out?

Can you recommend a way to benchmark this myself, like if I wanted to tweak it to see how my ideas work out?

I've shared the "just pass an executor" patch onto a Solr 9.5 cloud that I used, in case that's useful.
The benchmarking experiments I ran used Python's threading module and (I think under the hood) pysolr also, measuring QTime/elapsed time/CPU utilisation, for example. My experiments were for dense vector search, I haven't yet looked into if/how other searches might use the passed in executor at the Lucene level. But it would be worth mentioning at this point that the collection was quite multi-sharded i.e. that being independent of the type of search being run.

Along with this maybe we want to change
 public static final int DEFAULT_INDEX_SEARCHER_EXECUTOR_THREADS = 4;

to
public static final int DEFAULT_INDEX_SEARCHER_EXECUTOR_THREADS = Runtime.getRuntime().availableProcessors();

Along with this maybe we want to change
 public static final int DEFAULT_INDEX_SEARCHER_EXECUTOR_THREADS = 4;

to
public static final int DEFAULT_INDEX_SEARCHER_EXECUTOR_THREADS = Runtime.getRuntime().availableProcessors();

Opened #2569 to separate that less controversial (?) change out from the less obvious (?) change here. Also there's some associated doc and config changes needed to go with making the default runtime aware.


Expose faux private field

At github we are trying to extend one of the elements and using it in application code but flow keeps complaining that _date isn't defined on the element since we decided not to ship it with the flow definitions
This PR adds the property back in so we can access it and unblock the PR.
Ref: https://github.com/github/time-elements/pull/106#discussion_r283850992
Ref: https://github.com/github/github/pull/115283#issuecomment-492978635

I'm curious as to why _date is faux private in the first place. What benefit does it have to be faux private? Is it a case that we don't want it to become out of sync with the representation? In that case why not make it a getter/setter?

I'm curious as to why _date is faux private in the first place. What benefit does it have to be faux private? Is it a case that we don't want it to become out of sync with the representation? In that case why not make it a getter/setter?

I think that's a good question and the answer might be that it's due for a refactor. Changing the property to be getter/setter that will update the attributes on the element would probably be the way to go.
In the meantime I'm gonna merge and publish this change to unblock people 💃

Can we disable Flow checks in the few places _date is referenced instead?

Can we disable Flow checks in the few places _date is referenced instead?

Yeah I think that could also work but you then have the drawback of _date being typed as any.


Are there any plans to incorporate Angular Universal?

I'm submitting a ...
[ ] bug report
[ ] feature request
[X] question about the decisions made in the repository

Are there any plans to incorporate Angular Universal? For me (and I assume for many others), this is a coveted feature. Perhaps there's a way to replace the http-server with this express server setup?
If there is no intent to include Universal, then maybe someone (more knowledgable than myself) could write a wiki on it? I'll be making an attempt in the next few weeks. If I happen to figure it out by then, I'll be happy to write one.

well, I got it working.
Using the universal-starter as an offset, I created a seperate webpack config for the server build. Important notes:

Dont use chunks (vendor/polyfills). Build everything as one entry.
In tsconfig.json, remove the "noEmitHelpers" entry, or you will get errors like

__declare is undefined.

merge the dependencies from universal-starter (package.json and typings.json)
Add seperate scripts to the package.json (copy the dev or test targets).

To run, you'd then have two terminals open, one doing "watch" to rebuild, and one running nodemon to run/restart the server
I dont have the expertise to make it one single webpack config.

Would be happy to see that also as I've not been very successful so far to integrate Universal with this starter. Especially, importing "angular2-universal/polyfills" introduces some unexplainable bugs in my project.

My webpack-universal.json, placed in the config directory.
 * @author: @AngularClass
 */

const webpack = require('webpack');
const helpers = require('./helpers');
var path = require('path');

/*
 * Webpack Plugins
 */
// problem with copy-webpack-plugin
var CopyWebpackPlugin = (CopyWebpackPlugin = require('copy-webpack-plugin'), CopyWebpackPlugin.default || CopyWebpackPlugin);
const HtmlWebpackPlugin = require('html-webpack-plugin');
const ForkCheckerPlugin = require('awesome-typescript-loader').ForkCheckerPlugin;

const ENV = process.env.NODE_ENV = process.env.ENV = 'development';

/*
 * Webpack Constants
 */
const METADATA = {
  ENV: ENV,
  title: 'Angular2 Webpack Starter by @gdi2290 from @AngularClass',
  baseUrl: '/'
};

/*
 * Webpack configuration
 *
 * See: http://webpack.github.io/docs/configuration.html#cli
 */
module.exports = {
  target: 'node',
  externals: helpers.checkNodeImport,
  context: helpers.root(''),
   /*
   * Static metadata for index.html
   *
   * See: (custom attribute)
   */
  metadata: METADATA,

  /*
   * Cache generated modules and chunks to improve performance for multiple incremental builds.
   * This is enabled by default in watch mode.
   * You can pass false to disable it.
   *
   * See: http://webpack.github.io/docs/configuration.html#cache
   * cache: false,
   *
   * The entry point for the bundle
   * Our Angular.js app
   *
   * See: http://webpack.github.io/docs/configuration.html#entry
   */
  entry: {

    //'vendor': './src/vendor.ts',
    //'main': './src/main.browser.ts',
    'main': './src/perpendicular/server/server.ts',
  },

  // Options affecting the resolving of modules.

  //
  // See: http://webpack.github.io/docs/configuration.html#resolve
  resolve: {

    /*
     * An array of extensions that should be used to resolve modules.
     *
     * See: http://webpack.github.io/docs/configuration.html#resolve-extensions
     */
    extensions: ['', '.ts', '.js'],

    // Make sure root is src
    root: helpers.root('src'),

    // remove other default values
    modulesDirectories: ['node_modules'],

    alias: {
      'angular2/core': helpers.root('node_modules/@angular/core/index.js'),
      'angular2/testing': helpers.root('node_modules/@angular/core/testing.js'),
      '@angular/testing': helpers.root('node_modules/@angular/core/testing.js'),
      'angular2/platform/browser': helpers.root('node_modules/@angular/platform-browser/index.js'),
      'angular2/router': helpers.root('node_modules/@angular/router-deprecated/index.js'),
      'angular2/http': helpers.root('node_modules/@angular/http/index.js'),
      'angular2/http/testing'<EMAIL_ADDRESS>    },

  },

  /*
   * Options affecting the normal modules.
   *
   * See: http://webpack.github.io/docs/configuration.html#module
   */
  module: {

   noParse: [
      helpers.root('zone.js', 'dist'),
      helpers.root('angular2', 'bundles')
    ],

    /*
     * An array of applied pre and post loaders.
     *
     * See: http://webpack.github.io/docs/configuration.html#module-preloaders-module-postloaders
     */
    preLoaders: [

      /*
       * Tslint loader support for *.ts files
       *
       * See: https://github.com/wbuchwalter/tslint-loader
       */
      // { test: /\.ts$/, loader: 'tslint-loader', exclude: [ helpers.root('node_modules') ] },

      /*
       * Source map loader support for *.js files
       * Extracts SourceMaps for source files that as added as sourceMappingURL comment.
       *
       * See: https://github.com/webpack/source-map-loader
       */
      {
        test: /\.js$/,
        loader: 'source-map-loader',
        exclude: [
          // these packages have problems with their sourcemaps
          helpers.root('node_modules/rxjs'),
          helpers.root('node_modules/contentful'),
          helpers.root('node_modules/@angular2-material'),
          helpers.root('node_modules/@angular'),
        ]
      }

    ],

    /*
     * An array of automatically applied loaders.
     *
     * IMPORTANT: The loaders here are resolved relative to the resource which they are applied to.
     * This means they are not resolved relative to the configuration file.
     *
     * See: http://webpack.github.io/docs/configuration.html#module-loaders
     */
    loaders: [

      /*
       * Typescript loader support for .ts and Angular 2 async routes via .async.ts
       *
       * See: https://github.com/s-panferov/awesome-typescript-loader
       */
      {
        test: /\.ts$/,
        loader: 'awesome-typescript-loader',
        exclude: [/\.(spec|e2e)\.ts$/]
      },

      /*
       * Json loader support for *.json files.
       *
       * See: https://github.com/webpack/json-loader
       */
      {
        test: /\.json$/,
        loader: 'json-loader'
      },

      /*
       * Raw loader support for *.css files
       * Returns file content as string
       *
       * See: https://github.com/webpack/raw-loader
       */
      {
        test: /\.css$/,
        loader: 'raw-loader'
      },

      /* Raw loader support for *.html
       * Returns file content as string
       *
       * See: https://github.com/webpack/raw-loader
       */
      {
        test: /\.html$/,
        loader: 'raw-loader',
        exclude: [helpers.root('src/index.html')]
      },

      // TM customization - SASS / SCSS support
      {
        test: /\.scss$/,
        exclude: /node_modules/,
        loaders: ['raw-loader', 'sass-loader']
      },

     ]

  },

  output: {

    /**
     * The output directory as absolute path (required).
     *
     * See: http://webpack.github.io/docs/configuration.html#output-path
     */
    path: helpers.root('dist/'),

    /**
     * Specifies the name of each output file on disk.
     * IMPORTANT: You must not specify an absolute path here!
     *
     * See: http://webpack.github.io/docs/configuration.html#output-filename
     */
    filename: 'server.js',

    /**
     * The filename of the SourceMaps for the JavaScript files.
     * They are inside the output.path directory.
     *
     * See: http://webpack.github.io/docs/configuration.html#output-sourcemapfilename
     */
    sourceMapFilename: 'server.map',

    /** The filename of non-entry chunks as relative path
     * inside the output.path directory.
     *
     * See: http://webpack.github.io/docs/configuration.html#output-chunkfilename
     */
    chunkFilename: '[id].chunk.js'

  },
  /*
   * Add additional plugins to the compiler.
   *
   * See: http://webpack.github.io/docs/configuration.html#plugins
   */
  plugins: [

    /*
     * Plugin: ForkCheckerPlugin
     * Description: Do type checking in a separate process, so webpack don't need to wait.
     *
     * See: https://github.com/s-panferov/awesome-typescript-loader#forkchecker-boolean-defaultfalse
     */
    new ForkCheckerPlugin(),

    /*
     * Plugin: OccurenceOrderPlugin
     * Description: Varies the distribution of the ids to get the smallest id length
     * for often used ids.
     *
     * See: https://webpack.github.io/docs/list-of-plugins.html#occurrenceorderplugin
     * See: https://github.com/webpack/docs/wiki/optimization#minimize
     */
    new webpack.optimize.OccurenceOrderPlugin(true),

    /*
     * Plugin: CommonsChunkPlugin
     * Description: Shares common code between the pages.
     * It identifies common modules and put them into a commons chunk.
     *
     * See: https://webpack.github.io/docs/list-of-plugins.html#commonschunkplugin
     * See: https://github.com/webpack/docs/wiki/optimization#multi-page-app

    new webpack.optimize.CommonsChunkPlugin({
      name: ['vendor'].reverse()
    }),
*/

  ],

  /*
   * Include polyfills or mocks for various node stuff
   * Description: Node configuration
   *
   * Change process:false to process:true to get access at runtime to process.env.foo
   * See: https://webpack.github.io/docs/configuration.html#node
   */
  node: {
    global: true,
    __dirname: true,
    __filename: true,
    process: true,
    Buffer: true
  }

};

I added the function checkNodeImport to helpers.js
// Helpers
function checkNodeImport(context, request, cb) {
  if (!path.isAbsolute(request) && request.charAt(0) !== '.') {
    cb(null, 'commonjs ' + request); return;
  }
  cb();
}
```

And removed noEmitHelpers:true from tsconfig.json

```
{
  "compilerOptions": {
    "target": "es5",
    "module": "commonjs",
    "emitDecoratorMetadata": true,
    "experimentalDecorators": true,
    "sourceMap": true
  },
  "exclude": [
    "./node_modules",
    "./typings/main.d.ts",
    "./typings/main",
    "parkedAssets",
    ".git"
  ],
  "filesGlob": [
    "./src/app/**/*.ts",
    "./src/platform/**/*.ts",
    "!./node_modules/**",
    "!./parkedAssets/**/*.ts",
    "./src/custom-typings.d.ts",
    "./typings/index.d.ts"
  ],
  "awesomeTypescriptLoaderOptions": {
    "resolveGlobs": true,
    "forkChecker": true
  },
  "compileOnSave": false,
  "buildOnSave": false,
  "atom": { "rewriteTsconfig": false }
}

```

Thanks, there was indeed a glitch in my webpack config. Now I get a new error "No Directive annotation found on App" ("App" being my top class-component quite similar to this). Not sure whether it's because I'm using the new router (not yet supported by Angular Universal) or anything else.

I agree this should be a main feature because the project is so awesome its a shame it doesn't ship with it as its a must have these days. I'm going to add the files @asgerjensen pasted above and see if i can get it to work.

Any updates on this? This is basically the must have feature in modern javascript web apps. It should be included and configured.
@joeLloyd Hi, did you manage to get it to work?

@vadimsg I haven't had the chance. I decided to build the whole thing from scratch without this repo until I understand angular2 better. Then I will revisit this repo

+1

Got this running via @asgerjensen script, however the server throws huge memory errors and crashes if you inline your scss files in the components.  Why is this so hard?  Can't wait for a documented solution.

+1

+1 definetely

@asgerjensen Could you place your project on branch? I am trying to marge universal-starter with this project, but I am doing something wrong... :)

+1

I can certainly try. I'll have to exfiltrate the setup from my app though.
And, full disclosure, it was made back in rc.0 or 1, so I'm not sure it works with the rc4 router; so maybe don't hold your breath.
Sent from my iPhone

On 24. jul. 2016, at 07.08, Denny Lim<EMAIL_ADDRESS>wrote:
+1
—
You are receiving this because you were mentioned.
Reply to this email directly, view it on GitHub, or mute the thread.

+1

+1

+1

+1

+1

+1

I've found this repository that have starter project with Universal on board. This project is very different with current repository but it probably could help to make working config here.

+1

+1

PR added to showcase how it can be done.
https://github.com/AngularClass/angular2-webpack-starter/pull/1165

👎 https://github.com/AngularClass/angular2-webpack-starter/pull/1165

There's another example https://github.com/nglibs/universal-example-app showcasing both Universal and lean Angular on a single project.
This application uses platform-server delivered with Angular 4.0.0, and it could be a good starter project until Angular provides some documentation about the use of platform-server.
Furthermore, it covers most of the features of angular2-webpack-starter by AngularClass such as async/lazy routes, SCSS compilation (both inline and external), dev/prod modes, AoT compilation via @ngtools/webpack, tests, TsLint/Codelyzer, @types and maybe more.
Disclosure: I'm the author too :)

I started using this repo for my project but unfortunately I have to leave this project, just because of unavailability of Angular Universal. How can this be missed?

@satya-jugran Check out my boiler plate: https://github.com/maciejtreder/angular-universal-serverless
It includes server side rendering, PWA support (with pushes), can be deployed on Serverless environment (ie AWS Lambda) and much more!

@satya-jugran you can always do a pull request adding that functionality.


Issue while calling TableServiceClient using DefaultAzureCredentials()

Facing issue while calling TableServiceClient using DefaultAzureCredentials() from local environment
**Used the below code
TokenCredential credential = new DefaultAzureCredential();
             TableServiceClient client = new TableServiceClient(
                   endpoint: new Uri("cosmostableuri"),
                   tokenCredential: credential
              );

             var cosmosTable = client.GetTableClient("tablename");
             var entity = cosmosTable.GetEntity<Entity>("partitionKey", "rowkey");

### Getting an error : Azure.RequestFailedException: 'Authorization header doesn't confirm to the required format. Please verify and try again.
ActivityId: 07e97c33-90c9-4faf-a5b7-b031f4dbf621, documentdb-dotnet-sdk/2.14.0 Host/64-bit MicrosoftWindowsNT/10.0.19041.0
RequestID:07e97c33-90c9-4faf-a5b7-b031f4dbf621
Status: 401 (Unauthorized)
ErrorCode: Unauthorized
Content:
{"odata.error":{"code":"Unauthorized","message":{"lang":"en-us","value":"Authorization header doesn't confirm to the required format. Please verify and try again.\r\nActivityId: 07e97c33-90c9-4faf-a5b7-b031f4dbf621, documentdb-dotnet-sdk/2.14.0 Host/64-bit MicrosoftWindowsNT/10.0.19041.0\nRequestID:07e97c33-90c9-4faf-a5b7-b031f4dbf621\n"}}}
Headers:
Date: Thu, 20 Oct 2022 06:40:54 GMT
Transfer-Encoding: chunked
Content-Type: application/json; odata=minimalmetadata

Document Details
⚠ Do not edit this section. It is required for learn.microsoft.com ➟ GitHub issue linking.

ID: db802a5b-63b6-8bf8-6c3f-9ce2c412b7c8
Version Independent ID: 395c476c-32d6-e3d4-529e-98b8f1b99f33
Content: Get started with Azure Cosmos DB for Table and .NET%5Bhttps://learn.microsoft.com/en-us/azure/cosmos-db/table/how-to-dotnet-get-started?tabs=azure-cli%2Cwindows#connect-using-the-microsoft-identity-platform%5D(https://github.com/MicrosoftDocs/azure-docs/issues/url)
Content Source: articles/cosmos-db/table/how-to-dotnet-get-started.md
Service: cosmos-db
Sub-service: table
GitHub Login: @seesharprun
Microsoft Alias: sidandrews

@jahirul2022
It would be great if you could add a link to the documentation you are following for these steps? This would help us redirect the issue to the appropriate team. Thanks!!

I have followed below documentation :
https://learn.microsoft.com/en-us/azure/cosmos-db/table/how-to-dotnet-get-started?tabs=azure-cli%2Cwindows#connect-using-the-microsoft-identity-platform

Hi @GeethaThatipatri-MSFT / @YashikaTyagi-MSFT  ,  Please provide some update .

@jahirul2022, I'm checking with the server-side team for the API for Table to see why this error code is being displayed. Based on our documentation  and the SDK readme, you should be able to use the DefaultAzureCredential class to create a TableServiceClient or TableClient.
I tried both these blocks of code and got the same error message:
TableServiceClient client = new(
    endpoint: new Uri("https://<account-name>.table.cosmos.azure.com:443/"),
    tokenCredential: new DefaultAzureCredential();
);

TableClient tableClient = new TableClient(
    endpoint: new Uri("https://<account-name>.table.cosmos.azure.com:443/"),
    tableName: "adventureworks",
    tokenCredential: credential
);

I'll report back once I hear from the SDK or the service team. Thanks!

It looks like this may be a bug with either the SDK or the server-side service. I went ahead and opened a bug in the Azure SDK for .NET repository:
https://github.com/Azure/azure-sdk-for-net/issues/32058
Since we don't have an action item right now in the docs, I will close this issue. I will revisit this issue once we get some feedback from the Azure SDK for .NET team or the service team.
#please-close

We just got a response in the Azure SDK for .NET repo that Azure AD is not supported with Azure Cosmos DB for Table. The how-to guide was errant and the errant section is being immediately removed from the guide. Thank you for your patience.


Build docker image

We are building the server docker image

This should be rebased off of https://github.com/elhmn/waking-git/pull/49


Polygon V2 Reserve Factor Updates

Changelog
Add proposal to update reserve factors.
Add tests.

Question: my generated config file doesn't have a configFile property like this one does: https://github.com/bgd-labs/aave-proposals-v3/pull/152/commits/14f9e419bea4d0302fba80c0d92a1d17880f70f6
Is that ok?

Question: my generated config file doesn't have a configFile property like this one does: https://github.com/bgd-labs/aave-proposals-v3/commit/14f9e419bea4d0302fba80c0d92a1d17880f70f6
Is that ok?

Yes this is a bug and only happens when you regenerate the files by running yarn generate -c ./pathToConfig


Database implementation

Implementation of the code for the management of the database and the fetch of the quotes from it

Implementation status:

Connecting to the database fails
Environment variables are not well established

Current implementation status:

Fetching latest quote from client -> server -> database works
Fetching a quote by index out of bounds crashes the server

Every edge case is now handled. Ready for review

LGTM!

Yes, we're going to create a branch for better error handling. Merging.

Huston, db branch merged


[master] sync master branch with upstream opendatahub stable branch

this has been already reviewed and approved few times on its way from opendatahub-io, so let's put it in and check what snyk webui says
if everything goes well, I should be able to close about 20+ security jiras, and get rid of the heaps of useless PRs here

/lgtm


Changed mapping for geo_point to npgsql point datatype (oid 600)

Fixed and extended unit tests
Please verify correct mapping for point.
Before it was double[] and now to Npgsql datatype point

@mfussenegger thx for the fast check. I added it to the change log. Please check if this meets your conventions. If everything is ok i will merge it to dev branch tomorrow.

i move the changes to the unreleased part and updated code to support crate version >= 4.1 and less than 4.1.
I added missing unit test for geo_point array data type too.

@mschwoebel thank you, I've squashed the commits and merged it now.


custom mapping of request path

currently the requestpath is a list of trait name of the api and method name, see https://github.com/cornerman/sloth/blob/master/sloth/shared/src/main/scala/internal/Macros.scala#L56
this should be configurable:

light traffic paths: Int (or maybe keep List[String] contract and have num.toString :: Nil)
string paths like now: "Trait" :: "method" :: Nil
fully qualified string paths: "package" :: "name" :: "Trait" :: "method" :: Nil
annotation-based: @Name("Gorilla") trait Api { @Name("Monkey") def fun: Int }

For now, you can manually change the path of a trait or method by adding a PathName annotation, for example:
import sloth.PathName

@PathName("api")
trait Api {
  @PathName("m")
  def method(i: Int): F[Int]
}

I am going to close this for now. As you can configure the path. I do not plan on revisiting this topic any time soon. If someone feels like this is still missing, please comment.


management command delete_deleted_messages does not work anymore

I guess this happened because django uses argparse instead of optparse since django 1.8. See the box below the first example here: https://docs.djangoproject.com/en/1.8/howto/custom-management-commands/#django.core.management.BaseCommand.add_arguments
I will fix this, but it needs the fix in #121 prior.

should be fixed in version 0.6.0


plotFingerprint fails with too many bam files

With  experiment of 36 samples, plotFingerprint fails. Scaling back plotFingerprint to 3 bam files removed error. Should be more rigorously tested to figure out maximum number of bam files or if one of my bam files was corrupted. Ideally, pipeline would use macs.config file to plotFingerprint in groups or just each sample against its respective input.
 Would be better if an appropriate error message was generated before the rest of the script is executed.
It's not that informative having this many samples plotted for this kind of assessment. Ideally, we would plot all the IPs from the same experimental group along with their corresponding inputs.

Looks like this has been fixed in deepTools pretty recently: https://github.com/deeptools/deepTools/commit/be9eda61d4658be872e14d2a24302a1bc9a747b1
If we update the pipeline to v3.2.0 of deepTools then the error should be resolved.
Phil

Addressed in #71


Source code CDEvents to render as CloudEvent and schema validation

This PR is a continuation of https://github.com/cdevents/sdk-java/pull/35, to implement other Source code version control events

@rjalander - you will need to solve merged conflicts before this can be merged


update cnpmjs.org to 2.5.1 and update config to run

update cnpmjs.org form 1.3 to latest, update config to work on the new version.

Why change to MySQL? SQLite for demo is good enough.


2nd feature

commited now

Left parenthesis of the index function is not on a new line. Rejected.


Setting email / author fails.

./gitomatic -email<EMAIL_ADDRESS>git-o-matic
usage: gitomatic
correct usage:
./gitomatic -author 'John Doe' -email<EMAIL_ADDRESS>folderpath/

These are merely examples in the README. I've updated it to make it clearer that you still need to provide additional arguments. Thank you.


unable to load module with undeclared function reference

The following code may fail :
(module
 (type (func))
 (type (sub (struct (field (ref 0)))))
 (table funcref (elem $closure))
 (func $create (result (ref 1)) (struct.new 1 (ref.func $closure)))
 (func $closure (type 0)))

if converted to wasm with wasm-tools (wasm-tools parse main.wat -o main.wasm) or binaryen (wasm-as main.wat -all -o main.wasm) : iwasm main.wasm will fail with WASM module load failed: undeclared function reference
if converted to wasm with reference implementation : iwasm will load the module without issue

It should be noticed though that the wasm generated by the wasm-tools or binaryen still passes the validation of the reference implemenetation.
iwasm is built with cmake -DWAMR_BUILD_GC=1 .. on Mac with the latest commit b9db23b9

The only difference between the generated codes (apart from the custom sections) is the section 9 (element section)
wasm-tools compiles to: 01 00 41 00 0b 01 01
reference implementation compiles to: 01 06 00 41 00 0b 70 01 d2 01 0b

@peter-jerry-ye thanks for reporting the issue, this is due to that when GC is enabled, the type of table segment can be (ref func) now besides with funcref, while the original code only checks the latter. I submitted PR https://github.com/bytecodealliance/wasm-micro-runtime/pull/3181 to fix it, please try again.

@wenyongh It solves the issue. Thanks.

The root cause is when GC is enabled, the type of table segment can be (ref func) now besides with funcref, while the original code only checks the latter.


Troubleshooting tool link is broken

This link leads to a technet url which no longer works.
https://docs.microsoft.com/en-us/azure/storage/files/storage-troubleshoot-linux-file-connection-problems#solution
https://gallery.technet.microsoft.com/Troubleshooting-tool-for-02184089

Document Details
⚠ Do not edit this section. It is required for docs.microsoft.com ➟ GitHub issue linking.

ID: 5d3c03c3-b99c-445a-026e-442dd40599a1
Version Independent ID: 0a6ff7fb-1702-b50b-50ab-8db7a1832647
Content: Troubleshoot Azure Files problems in Linux
Content Source: articles/storage/files/storage-troubleshoot-linux-file-connection-problems.md
Service: storage
Sub-service: files
GitHub Login: @jeffpatt24
Microsoft Alias: jeffpatt

Assigning to author to see if tool is available elsewhere and URL can be replaced.

Thanks for reporting! I updated the link to: https://github.com/Azure-Samples/azure-files-samples/tree/master/AzFileDiagnostics/Linux. The doc update will be live later today.

#please-close


Add the new packaging step to the nightly builder

This should wait for https://github.com/servo/servo/pull/8288 to land; I'll ping the review then.

r? @metajack @Manishearth @mbrubeck
(anybody, really, now that 8288 landed)

@bors-servo r+

:pushpin: Commit a8b8275 has been approved by Manishearth

:hourglass: Testing commit a8b8275 with merge 07117a9...

:sunny: Test successful - travis


Demo with Dynamically Loaded Children

This should be possible with the current api, but it would be good to write a demo. If anyone has already done this, please post the code here! Thanks.

I have not had a chance to work on this. It is possible to with the existing api though. You'll have to fully control the data and the data handlers.


Show reference counter link for literal const

Actual behiavior

Request Behiavior

We can obviously create a new class instance in memory to get the visual reference counter button.

I like the productivity of the reading flow that this feature offers, but sometimes I also need it in a literary context too.
Do vscode have an option to show this counter link in literal declaration? more specifically for const literal object?
thanks

This feature request has not yet received the 20 community upvotes it takes to make to our backlog. 10 days to go. To learn more about how we handle feature requests, please see our documentation.
Happy Coding!

:slightly_frowning_face: In the last 60 days, this feature request has received less than 20 community upvotes and we closed it. Still a big Thank You to you for taking the time to create this issue! To learn more about how we handle feature requests, please see our documentation.
Happy Coding!


FakeRequestService uses fakeTanDelay for all fake endpoint requests

Describe the bug
In the FakeRequestService I noticed that generateTan, generateRegistrationToken and getTestState all use the fakeTanDelay to schedule a fake response, despite the availability of a fakeTokenDelay and fakeTestDelay
Expected behaviour
The appropriate delays should be implemented for the various fake endpoint requests
Possible Fix
See expected behaviour
Additional context
N/A

@ddewaele Thank you verry much for noticing and analysing this bug. Your attention to this detail was very helpful, we will implement the fix.


Can we make this an addon?

Just curious why this is not an Ember addon, would be nice to be able to ember install ember-droplet

I'm not really much of an Ember aficionado any more.
How would I go about registering it as an Ember addon?

Hi @Wildhoney, you would have to change the whole structure of things. It would probably be best to start from scratch and use Ember CLI to do ember addon ember-droplet which would make a new addon for you. Then you'd need to copy everything over into it.

Looking through the code, it feels like it could take quite awhile. Since you don't really do Ember anymore, if you would be interested in transferring ownership to my org, Ship Shape, I could put in the work to get it working as an addon and add you to the org, and we could collaborate on it there. https://github.com/shipshapecode

@Wildhoney thoughts?

Ping

@Wildhoney whats the word?

@Wildhoney you still around?

Folks – if you want to take this forward, please open PRs and I'll happily merge them in. You're all welcome to contribute, and if anybody wants to be added as a contributor, that's cool too 👍

@Wildhoney if I'm expected to rewrite the whole thing from scratch, by myself, I'd just start from scratch in my own org. Since you said you don't do Ember anymore, I thought you might be interested in transferring it to my org and collaborating on things there.

I'm not really much of an Ember aficionado any more.

I still do Ember.
You're more than happy to fork it to your org and then refactor it. That's open-source. However I'm not expecting you to rewrite EmberDroplet – neither unconditionally or on the condition that I transfer ownership – that's just not very open-sourcey.
If however you would like to open a PR or become a contributor, then that's cool, too.


added quantum university to list of universities

@philipto

@VatsalyaWE Please provide us with:

the school official website URL
the school's full official name, without abbreviations and nicknames
the school street address, including city and country
an URL of a page on the official website where the school offers an IT-related long-term (>1 year) course
a proof, which shows that the school recognizes the domain you are submitting as an official email domain for the students.

@VatsalyaWE You might miss my previous comment. Please react.

https://www.quantumuniversity.edu.in/
Quantum University
22km Mile Stone, Mandawar, Roorkee- Dehradun Highway (NH-73), Roorkee-247667 (Uttarakhand) India
https://www.quantumuniversity.edu.in/engineering

The first 4 items are listed above. I am not sure what to submit as proof of official domain ownership. please suggest


Enable custom domain in development

Currently a know issue is that the url for the importmaps is generated using the following code:
Jekyll.configuration[‘url’]

This takes the url properly from _config.yml. This means that you are unable to use the importmaps during development as it will use the production domain.
For example if your _config.yml looks like this:
url: n-at-han-k.github.io
baseurl: blog

Your importmap will look like this:
{
  “imports”: {
    “application”: “https://n-at-han-k.github.io.com/assets/js/application.js”
  }
}

Temporary fix
Commenting out the url property from _config.yml during development reverts the url to <IP_ADDRESS>:4000.
If you use a different url for development then you must add that as the url property in the _config.yml and remember to change it back when deploying.

I think Jekyll Environments could be used in Jekyll::Importmap::Resolver.host_or_url to avoid having to comment anything out of _config.yml.