Animate window move/resize/swap/warp

Discussion / Feature request
This is a long shot, and probably far off in the future. This has been previously discussed in https://github.com/koekeishiya/chunkwm/issues/144.
I've dug up some stuff regarding this.

How Chromium resizes and moves windows using CGS* functions  https://github.com/ChromiumWebApps/chromium/blob/c7361d39be8abd1574e6ce8957c8dbddd4c6ccf7/chrome/browser/ui/cocoa/constrained_window/constrained_window_animation.mm
A (very old) blog post explaining how CGSSetWindowWarp works http://kevin.sb.org/2006/07/23/cgssetwindowwarp-explained/
An working example for using CGSSetWindowWarp and CGSSetWindowTranslation for custom animations https://github.com/sailesha/CGSSetWindowWarp-Sample/blob/master/windowAnimation.mm

Obviously all the above examples require access to the NSWindow instance for async animations, which is inaccessible from the Dock process—which is the only process yabai injects code into.
Simply calling SLSSetWindowTransformation with a CGAffineTransform (e..g CGAffineTransformMakeTranslation(100, 100) to move a window 100 right and 100 down) will move the window, but this is not animated. Calling this repeatedly will likely cause lag.
And now here's the long shot that I'd love to see investigated in the future: There are additional functions called SLSTransactionCreate and SLSTransactionCommit, with variants of the transform and warp functions named SLSTransactionWindowTransform and so on. Assuming this works similar to CATransaction on iOS, this could then be used to animate multiple windows with a duration and at the same time.
These SLSTransaction* functions are available (on 10.15 dev beta 4 currently):

nm /System/Library/PrivateFrameworks/SkyLight.framework/SkyLight | grep SLSTransaction
0000000000200d1e T _SLSTransactionAddWindowToSpace
0000000000200f3a T _SLSTransactionAddWindowToSpaceAndRemoveFromSpaces
0000000000201f5c T _SLSTransactionBindSurface
0000000000200129 T _SLSTransactionClearMenuBarSystemOverrideAlphas
00000000001ffce4 T _SLSTransactionClearWindowLockedBounds
00000000001ff834 T _SLSTransactionClearWindowSystemLevel
0000000000202cb6 T _SLSTransactionCommit
0000000000202ee0 T _SLSTransactionCommitCoalescing
00000000001fd88b T _SLSTransactionCreate
0000000000201a22 T _SLSTransactionDeferWindowMoveEvents
00000000002013c1 T _SLSTransactionDestroySpace
00000000001fd788 T _SLSTransactionGetTypeID
000000000031b9d0 b _SLSTransactionGetTypeID.once
000000000031b9d8 b _SLSTransactionGetTypeID.typeID
000000000020109f T _SLSTransactionHideSpace
00000000001ffd7d T _SLSTransactionMoveWindowWithGroup
0000000000201457 T _SLSTransactionMoveWindowsToManagedSpace
000000000020205f T _SLSTransactionOrderSurface
00000000001fe097 T _SLSTransactionOrderWindow
00000000001fe196 T _SLSTransactionOrderWindowGroup
0000000000201c0a T _SLSTransactionOverrideAppSleepNotifications
0000000000201eb2 T _SLSTransactionPostBroadcastNotification
0000000000202dd4 t _SLSTransactionPostCommit
0000000000201d2a T _SLSTransactionPostNotificationToConnection
0000000000200dd1 T _SLSTransactionRemoveWindowFromSpace
0000000000200e84 T _SLSTransactionRemoveWindowFromSpaces
000000000020132b T _SLSTransactionResetSpaceMenuBar
00000000001fff5c T _SLSTransactionResetWindow
00000000001fef10 T _SLSTransactionResetWindowSubLevel
0000000000202922 T _SLSTransactionSetBackdropChameleonContribution
000000000020283c T _SLSTransactionSetChameleonUpdatesEnabled
0000000000201ec6 T _SLSTransactionSetClientAdvisory
0000000000201950 T _SLSTransactionSetEventCapture
0000000000201654 T _SLSTransactionSetManagedDisplayCurrentSpace
0000000000201875 T _SLSTransactionSetManagedDisplayIsAnimating
00000000002001a9 T _SLSTransactionSetMenuBarBounds
00000000001ffff5 T _SLSTransactionSetMenuBarSystemOverrideAlpha
0000000000200a84 T _SLSTransactionSetSpaceAbsoluteLevel
0000000000200bea T _SLSTransactionSetSpaceAlpha
0000000000200b37 T _SLSTransactionSetSpaceOrderingWeight
0000000000200957 T _SLSTransactionSetSpaceShape
000000000020054f T _SLSTransactionSetSpaceTransform
0000000000202175 T _SLSTransactionSetSurfaceBounds
0000000000202563 T _SLSTransactionSetSurfaceOpacity
0000000000202666 T _SLSTransactionSetSurfaceResolution
00000000001fe295 T _SLSTransactionSetWindowAlpha
00000000001fe3c6 T _SLSTransactionSetWindowBrightness
00000000001ff8cd T _SLSTransactionSetWindowGlobalClipShape
00000000001fe4f7 T _SLSTransactionSetWindowLevel
00000000001ff9fd T _SLSTransactionSetWindowLockedBounds
00000000001fe66b T _SLSTransactionSetWindowOpaqueShape
00000000001fe79b T _SLSTransactionSetWindowProperty
00000000001fefa9 T _SLSTransactionSetWindowReleasesBackingOnOrderOut
00000000001feace T _SLSTransactionSetWindowResolution
00000000001fed2a T _SLSTransactionSetWindowShape
00000000001fee5a T _SLSTransactionSetWindowSubLevel
00000000001ff08f T _SLSTransactionSetWindowSystemAlpha
00000000001ff77e T _SLSTransactionSetWindowSystemLevel
00000000001ff1c0 T _SLSTransactionSetWindowTransform
00000000001ff5e9 T _SLSTransactionSetWindowWarp
0000000000201009 T _SLSTransactionShowSpace
000000000020158b T _SLSTransactionSpaceTileMoveToSpaceAtIndex
0000000000201af2 T _SLSTransactionUpdateRegion
000000000020120c T _SLSTransactionWillSwitchSpaces
00000000001fe615 t __SLSTransactionCommitAction
00000000001fdfe4 t __SLSTransactionDecode_CFString
0000000000052ef0 t __SLSTransactionDecode_CGSSpaceIDArray
00000000001fdc6b t __SLSTransactionDecode_packed64
00000000001fdc9e t __SLSTransactionDecode_packed64_tag
0000000000201135 t __SLSTransactionEncode_CFArray
00000000001fdd41 t __SLSTransactionEncode_CFString
00000000002016fd t __SLSTransactionEncode_UUIDString
00000000001fdba3 t __SLSTransactionEncode_packed64
00000000001fd994 t __SLSTransactionEncode_resize
00000000001fd7cd t __SLSTransactionFinalize
00000000001fd925 t __SLSTransactionPopWriteStream
0000000000201d3a t __SLSTransactionPostNotification
0000000000202a53 t __SLSTransactionPushWriteStream
0000000000202bf6 t __SLSTransactionResetWriteStream
000000000031b9e8 b __SLSTransactionWriteStreamKey.key
000000000031b9e0 b __SLSTransactionWriteStreamKey.once
000000000020300f t ___SLSTransactionCommitCoalescing_block_invoke
00000000001fd7b4 t ___SLSTransactionGetTypeID_block_invoke
0000000000201507 t ___SLSTransactionMoveWindowsToManagedSpace_block_invoke
0000000000202ed8 t ___SLSTransactionPerformCommitAction
0000000000202520 t ___SLSTransactionSetSurfaceBounds_block_invoke
0000000000202808 t ___SLSTransactionSetSurfaceResolution_block_invoke
00000000001fe5ef t ___SLSTransactionSetWindowLevel_block_invoke
00000000001feca3 t ___SLSTransactionSetWindowResolution_block_invoke
00000000002012a5 t ___SLSTransactionWillSwitchSpaces_block_invoke
00000000001fdad3 t ____SLSTransactionWriteStreamKey_block_invoke

Why? Look at this example from i3. Looks nice, doesn't it?

If not injected how would you go about doing this?

I'm not particularly interested in doing this, but would not be against a PR where this is optional.

Another animation idea:
it would be really cool to animate the opening of the terminal in a sci-fi style, kinda like edex-ui
.
Of course it would be cool for other windows too but especially for the terminal because it's usually really flexible in terms of size and is the app that feels the most like a sci-fi thing 🤪.
Alacritty, for example, is completely resizable.

In the gif I put an Alacritty window in a floating space, and, after trying to make it as small and centered as possible, I first do yabai -m window --resize left:-20:0 and yabai -m window --resize right:20:0 multiple times until the window horizontally fits the screen, and then the same thing vertically with yabai -m window --resize bottom:0:20 and yabai -m window --resize top:0:-20

Any update on this?

Just saw this on reddit, it looks so smooth
https://www.reddit.com/r/unixporn/comments/vtpwhc/hyprland_dynamic_wallpapers_and_settings_with_a/if9iaoy/?context=3

Just to note that the mentioned SLSTransaction function family does not work in Monterey 12.5.

Did anyone manage to implement it and has a compiled version of it?

im wondering of this too

https://user-images.githubusercontent.com/22680421/189494638-f8a63c68-297b-41d0-9805-c5cf0f02b33a.mp4
I figured it is not a big problem to call SLSSetWindowTransformation frequently to create the intermediate frames. I have hardcoded there to be 100 frames in any resize/move animation.

brilliant.

anim.mp4
I figured it is not a big problem to call SLSSetWindowTransformation frequently to create the intermediate frames. I have hardcoded there to be 100 frames in any resize/move animation.

brilliant.

@FelixKratz
Did you only apply the transform in that POC, or does it also synchronise said transform with the desired window frame change? This is important because macOS itself applies transforms to windows in various context, and that will undo the operation.

@FelixKratz
Did you only apply the transform in that POC, or does it also synchronise said transform with the desired window frame change? This is important because macOS itself applies transforms to windows in various contexts, and that will undo the operation.

It is not polished at all and very hacked together, this is all I did:
https://github.com/FelixKratz/yabai/commit/2ba29b73df0c9e71cd3d34bf0c97ef2e59cfa7bf
I am only setting the transform for as long as I am animating and then I do the actual proper move/resize. These animations block yabai, which is why I have made them so short.

I'll probably take a shot at this for the next release, as I'm working on smoothing out the experience. I have a fairly high bar for what I consider acceptable though, so not sure if it is feasible to ship in the end. A dealbreaker for me is the ability to animate all windows that are modified in the same operation simultaneously, so that they start/end at the same time.

I'll probably take a shot at this for the next release, as I'm working on smoothing out the experience. I have a fairly high bar for what I consider acceptable though, so not sure if it is feasible to ship in the end. A dealbreaker for me is the ability to animate all windows that are modified in the same operation simultaneously, so that they start/end at the same time.

Great to hear! Animating the windows in parallel would be very nice, but quite a bit of restructuring of the code base I believe. It would probably also be much better to animate from the SA directly. I only chose to not do that because then the SA would have to notify yabai when the animation is finished and unlock some kind of mutex that the SA and yabai share and that would go too far for a simple POC. This would probably also benefit greatly from your new ipc approach via shmem + mutex. When those animations are done "proper" (parallel and less flickering) it will feel very nice I am sure.
What I stumbled over while implementing the POC was that once the affine transform is reset to the original transform before moving and resizing the window via AX there would sometimes be a noticeable flickering and I didn't find a way to resize the window through SLS functions, i.e. SLSSetWindowShape does not seem to be respected when set via SA. So I was stuck with the slow resize via AX.

Pushed a proof of concept myself: https://github.com/koekeishiya/yabai/tree/animate https://github.com/koekeishiya/yabai/commit/269d29d2ddbdd22c4024a0151f461a3dd9def616
Add yabai -m config window_animation_duration 0.10 to enable animations; adjust the value as you like.
This does not work with window borders yet, so keep borders disabled. This still only animates a single window at a time.

What I stumbled over while implementing the POC was that once the affine transform is reset to the original transform before moving and resizing the window via AX there would sometimes be a noticeable flickering and I didn't find a way to resize the window through SLS functions, i.e. SLSSetWindowShape does not seem to be respected when set via SA. So I was stuck with the slow resize via AX.

I don't think it is possible to get around this; I have attempted to do so in my version, but no guarantees that it is a universal solution.

Transactional:

The flicker is caused by the issue mentioned above; when resetting the transform at the end of the animation to apply the change in size using the AX API. Hopefully there will be a workaround to that...

Resizing using the AX API is just too  slow. Need to figure out some other way to resize a window.. When resizing a window using the native handle at the edges, the operation appears to be rather snappy. I wonder if we could somehow hook into that.

I had an idea that it would maybe be ok to animate the actual windows as is done, but taking a screen capture of the space as the final frame; displaying this screen capture as a topmost window and destroy it (probably some kind of blurred fade) while removing the transforms and applying the resize animation.
Thanks to your comment now I recorded my screen while doing the enter/exit fullscreen application, and it actually looks like Apple themselves are doing something like this, surprisingly enough.

I tried my idea by misusing the border to temporarily draw the capture of the window. The scripting addition is not needed for the animation at all and it looks very smooth. https://github.com/FelixKratz/yabai/commit/10793056149a14783662e7a7d6b65ce257b5fef7

Are you able to animate the windows simultaneously using that approach though?

Are you able to animate the windows simultaneously using that approach though?
Edit:
I guess you could iterate through all windows, grab a capture of the window, and set the opacity to 0. Set the size and position using the AX API.
Animate all the captures.
Iterate through the list of windows, setting the opacity back to the previous value.

In my current implementation it is single window, but if I pass a window list to the animation function (same as you have done) it will be possible to animate simultaneously. Maybe I will try to rebase to your POC and implement this method there, but I think the digest of this is that we can definitely circumvent the flickering. Maybe it would be good to use the faster SLSHW functions for window capture instead of what I am using currently.

It works pretty well, except that the window order is not the same as it is pre-screenshot, and sometimes the screenshot colours look different from the window itself. e.g Safari is darker than it is in the screenshot.

This is probably as good as it is going to get:

There are some artifacts in the gif due to compression and whatever, it looks much better in reality.
Slight issues with border integration still, but the animation system is pretty much done.

I have rebased onto your POC and played with it for a bit. I have made some slight tweaks that get rid of the border flicker and reduce the overhead if borders are activated: https://github.com/FelixKratz/yabai/commit/23ba5bd7085b18797458eb11d507f9ca38b36371

@FelixKratz
Does that solve the border misalignment when using the mouse to move/resize windows (especially noticable when doing a warp operation using the mouse) ? I haven't looked to closely at the border stuff yet.
Does anyone have a set of functions that look nice for animating various kinds of window movement. Might be nice to allow the ability to select between a variety of function, and possibly select an animation based on which action is happening.

@FelixKratz
Does that solve the border misalignment when using the mouse to move/resize windows (especially noticable when doing a warp operation using the mouse) ? I haven't looked to closely at the border stuff yet.

No, I did not notice it until now since I rarely use my mouse for those actions. But the animation system so far is very nice and helps to indicate direction of movement, especially for other people viewing the screen.

Does anyone have a set of functions that look nice for animating various kinds of window movement. Might be nice to allow the ability to select between a variety of functions, and possibly select an animation based on which action is happening.

$f(x) = x$
$f(x) = x^2$
$f(x) = \sin(x \pi / 2)$
$f(x) = 1 - \cos(x \pi / 2)$
$f(x) = x \exp(x - 1)$
$f(x) = c \tanh(2 \text{artanh}(\frac{1}{2c})(x - 1/2)) + 1/2$, for $c \in (1/2, \infty)$

all of those functions enforce $f(0) = 0$ and $f(1) = 1$.
I am not sure if they are "nice" but they are smooth and infinitely differentiable on the domain. I especially like the last one for $c \sim 0.52$

I don't have anything to add to the discussion, so apologies for the noise, but I just wanted to say thanks to you two for all the effort on this.  It looks amazing and I can't wait.

I think I found a way for this entire thing to work without having to disable SIP.

I wonder if it would be possible to make these animations not block yabai, similar to how I handle animations in SketchyBar:
https://github.com/FelixKratz/SketchyBar/blob/2008f71c2162c8c4d16f007ebc9f798d8457ba15/src/animation.c#L157-L177
The implication of this would be that something like:
yabai -m window --toggle zoom-fullscreen \
&& yabai -m query --windows --window | jq '."has-fullscreen-zoom"'

would need to return true when the animation has begun and not only after it has ended.

It is possible to make them non-blocking, yes. However, then we need to handle the case of the user performing some action on a window that is being animated and correctly cancel the animation for that specific window or something, similar to what I did for the window opacity fading system in #1406
In addition, the queued events will then also be processed while a window is animating, e.g we will receive and process a window resize event for the windows that are animated, while they are being animated, causing their cached properties to update (and it will also trigger a border update).
I'm not sure there is too much to gain by making them run asynchronously.

I'm not sure there is too much to gain by making them run asynchronously.

It could make some things feel a bit better, take for example:
ctrl + lalt - j    : yabai -m window --resize right:-100:0 || yabai -m window --resize left:-100:0
ctrl + lalt - k    : yabai -m window --resize bottom:0:100 || yabai -m window --resize top:0:100
ctrl + lalt - l    : yabai -m window --resize bottom:0:-100 || yabai -m window --resize top:0:-100
ctrl + lalt - 0x29 : yabai -m window --resize right:100:0 || yabai -m window --resize left:100:0

If I hold any of those key combos for a while I am in for a bad time, depending on my key repeat frequency this will create a resize queue several seconds long.

If I hold any of those key combos for a while I am in for a bad time, depending on my key repeat frequency this will create a resize queue several seconds long.

I think both scenarios will look pretty janky. I guess it could look smooth by cancelling the current animation and have the new animation start interpolating from the position of the cancelled animation and not the final position (the AX Position of the frame).

What is the expected behaviour though, cancelling the current animation or simply queue up the next one?

At least for me the animation is a way to indicate the spacial directionality of a state change. The state change
happens as soon as I request it, i.e. the state has already changed when the animation is started.
Thus the expected behavior for me is to cancel the current animation and animate to the new state without stopping at the outdated states, because they have been invalidated by my new request.
Of course this is a matter of taste, the way it is currently the animation needs to finish for the state to change, but this leads to the feeling of not being responsive e.g. in the above scenario.

I agree that makes sense. I think that would require changes to allow the following which I mentioned above:

I guess it could look smooth by cancelling the current animation and have the new animation start interpolating from the position of the cancelled animation.

async animations poc:

can window open and close animations be added?

Why is it so hard to make a decent gif..
I think this looks better maybe. Changed the easing function and removed weird flickering that was present in the previous version:

Wow, it works really well and it is exactly how I would expect an animation system to work! Thank you for making this, very nice work!

Squashed all changes so far into: https://github.com/koekeishiya/yabai/commit/f9e6e8f42aff7a5c1679abed129e7ab3aa20146f

can window open and close animations be added?

It might be possible to create a window opening animation; depends on how much delay there is between the window spawning and yabai getting notified, I guess this would likely be implemented as a fade+scale transition.
Animating on window close is pretty much impossible. The window is already inaccessible from system APIs by the time we are notified that a window has been destroyed.

Window borders will be hidden while windows are animating. Attempting to do otherwise will add a ton of complexity and prone to use-after-free issues.

The EVENT_HANDLER_SLS_WINDOW_RESIZED functions are called several times during an animation, leading to an unnecessary resize of the border and inflicting some lag with large resolution windows. It would probably be best to guard against a border resize during an animation?

The EVENT_HANDLER_SLS_WINDOW_RESIZED functions are called several times during an animation, leading to an unnecessary resize of the border and inflicting some lag with large resolution windows. It would probably be best to guard against a border resize during an animation?

There should only be one call to that event handler for each set_window_frame call that causes a window to change size.
The current system basically does the following:
Figure out which windows are involved in the animation.
Grab a snapshot for each window and prepare inital state.
Hide the real window and its border; show the proxy.
Set the window frame of the real window (this triggers the callback that the border responds to, events are currently queued).
Start the animation in a background thread.
Queued events continue being processed by yabai as normal.
When an animation ends, it hides the proxy and shows the real window, triggering the callback to display the border window again.

I have tested my suspicion from above and it seems to be indeed caused by the disabled update: https://github.com/FelixKratz/yabai/commit/a58ce7a083bbf1d5f3cbc774c44397408a41270d on border resize

I might have an idea to allow borders to animate; will look into it later.

My idea appears to work; borders are animating fine, but needs some cleanup.

Trying to animate the border directly causes flicker during the end of transition, so the best solution would simply be to create proxy for the window border too, and pass them through the same kind of system that we do for the windows themselves.

I think this is getting close to finished now. I squashed all changes into 2 commits on the animate branch. It would be nice if someone else besides me could run this for some time and report unexpected behaviour across the entire feature set of yabai.

I think this is getting close to finished now. I squashed all changes into 2 commits on the animate branch. It would be nice if someone else besides me could run this for some time and report unexpected behaviour across the entire feature set of yabai.

There still was some flickering occasionally, related to the reordering of windows.
With the following changes the flickering is eliminated: https://github.com/FelixKratz/yabai/commit/08d7314b9d4051856846e6033f19dd6e4101c1bd

An unexpected behavior is:

When Screen Capture Permission is not given, borders will frequently be ordered above the window.

Not sure if these are related to whatever that's mentioned here or if I have any configuration issues:

A topmost floating window's animation proxy doesn't seem to be topmost, so the proxy might go underneath windows and be entirely invisible while a move animation is in progress. To reproduce: with yabai -m config window_topmost on and two bsp windows, call yabai -m window --toggle float --grid 8:8:1:1:6:6 on one of them.

It might look better if the animation proxy (for whichever window is in focus after the animation) is on top of the same layer throughout the animation. Example: yabai -m window --focus stack.last --stack east --focus stack.last should have the eastern window stay on top while it animates onto the stack.

Insert feedback borders no longer match the window border properties (like width) specified in config.

On a side note, it'd be nice if we can optionally disable the background blur from the borders if we prefer not to use it or if we aren't making windows transparent.
Thanks for all the work on this!

A topmost floating window's animation proxy doesn't seem to be topmost, so the proxy might go underneath windows and be entirely invisible while a move animation is in progress. To reproduce: with yabai -m config window_topmost on and two bsp windows, call yabai -m window --toggle float --grid 8:8:1:1:6:6 on one of them.

There's (sometimes) a flicker where borders will reappear at the previous location at the end of an animation.

Hiding and unhiding an app that has windows across multiple spaces causes animation proxies for all spaces to be created and be visible even though the spaces themselves aren't visible.

Unhiding an app that has windows may cause it to appear to flicker between spaces with the app's windows (sometimes indefinitely and I'd need to restart yabai to resolve that).

These should all be fixed in the latest commit.

Added the ability to configure border HiDPI mode (on/off) and border blur (on/off). Also updated the docs to specify which command needs SIP to be partially disabled -- should make it easier than having to check the wiki listing.

Going to merge into master and do whatever remaining changes are required there.

Insert feedback borders no longer match the window border properties (like width) specified in config.

Fixed in latest commit. Insert feedback borders now use both width and radius setting properly.

I read that this should be fixed but I'm not sure why I'm still seeing some border flicker here

It also appears that the animations disappear completely for me if i warp a window A towards B in this state (i.e. focus window A, then yabai -m window --warp east):
+-----+-----+
|     |     |
+-----+  B  +
|  A  |     |
+-----+-----+

which leaves a period of time where all windows are invisible.

I'm currently on the latest commit on the master branch.

It also appears that the animations disappear completely for me if i warp a window A towards B in this state (i.e. focus window A, then yabai -m window --warp east):

I can reproduce this with auto_balance on.

I read that this should be fixed but I'm not sure why I'm still seeing some border flicker here

I cannot reproduce this on either of my machines (older Intel x64 running Big Sur and Apple Silicon running Monterey). Not really sure how that would be happening, as resizing happens while the proxy window is showing instead of the window, and then a transactional swap is performed at the end.

I cannot reproduce this on either of my machines (older Intel x64 running Big Sur and Apple Silicon running Monterey). Not really sure how that would be happening, as resizing happens while the proxy window is showing instead of the window, and then a transactional swap is performed at the end.

Update: It seems like the flicker I encountered isn't linked to the end of the animation at all. It also seemed like having yabai signals might be worsening/delaying the effect and makes the overall operation slower.

Right, ,I understand why it is happening. I'll have to rethink parts of the system because it currently messes with window ordering in a way that causes problems when combining commands, e.g having multiple windows of the same application on space 1, and then doing yabai -m window --space 3 && yabai -m space --focus 3, when we restore windows at the end of the animation, that window steals focus (when we tell macOS to make it visible on screen). This only happens if there is a window of the same application on that space.

@wernjie Do you still have this issue on the latest master? I can't reproduce it with the config you posted.

I believe all known reported issues should be resolved now on master. Please let me know if you still encounter issues.

It might look better if the animation proxy (for whichever window is in focus after the animation) is on top of the same layer throughout the animation.

I think it would become very complicated to try and catch a focused window event and have that impact the state of a live animation.

@wernjie Do you still have this issue on the latest master? I can't reproduce it with the config you posted.

It seems like the flicker is much improved on the latest master with that config (~9 out of 10 times it no longer shows up). Though, I can still see a flicker frequently when I have window move/resize signals added to update my status bar.
For now I can make do with the lack of those signals. Do let me know if there's anything else I can provide to help debug the issue.

I was able to catch it in a single frame, at the end of an animation, on my screen.

That makes sense. The latest commit has also fixed the flicker for me. Thanks!

If no new bugs are detected regarding this issue, I plan to do a release within the weekend.

Meh think I'll just gamble; I haven't discovered any bugs so far during my normal usage. If there is a bug, simply setting window_animation_duration will make it work like v4.0.4 so should be fine.

That's an awesome feature! Thanks a lot! ❤
However, I also have problems with SIP enabled: the animations are only playing very rarely when swapping or moving windows. Only about every 7th (or even more) command triggers an animation. Not predictably though.

Found a bug with the animations: With SIP enabled (and thus no scripting addition loaded), and window_animation_duration set to a non-zero value, there sometimes is a very wonky animation happening:

So this is happening if you perform some action that would cancel an in-progress animation for a window and start a new animation towards a new state. If you set the animation duration to 1.0 seconds, and do yabai -m window --swap west followed by yabai -m window --swap east shortly after, you will trigger that behaviour.
What's happening is that the first swap command will trigger the start of an animation, however we need the scripting addition to hide the real window while we animate a proxy; performing a transactional switch so that it isn't actually obvious to the user that this is what's happening.  Because the scripting-addition is not loaded, the swap doesn't occur, and there is no animation showing.
When an animation is cancelled because a new one is started, the proxy is updated and swaps with the old proxy. This swap does not rely on the scripting addition, which is why those windows suddenly become visible.
I do believe I stated that this particular config option requires SIP to be disabled. However, I agree that maybe there should be some limitation in place preventing the value to be changed from 0.0 on systems where SIP is enabled.
There is no way to allow this functionality with SIP enabled, unfortunately.

I do believe I stated that this particular config option requires SIP to be disabled. However, I agree that maybe there should be some limitation in place preventing the value to be changed from 0.0 on systems where SIP is enabled.
There is no way to allow this functionality with SIP enabled, unfortunately.

That makes sense. Think I should have read the docs first - just saw it in the changelog and jumped right into it. 😅 My bad!

Added a guard that only allows animation_duration to be set if the appropriate SIP flags are disabled.

The animation can get fairly stuttery at times. My testing shows that this is connected to disabling the update on border resize and border redraw. Even though animations use a different SLS connection, they seem to affect each other still.
This patch https://github.com/FelixKratz/yabai/commit/a20e36e017e4e3257b9904625a6b0f080d9e1136 makes the animations (especially noticeable on large displays and short animation durations) dramatically smoother for my configuration. It however introduces redraw flickering since the update has not been disabled on redraw.

Is it normal for there to be a delay before the animations play? I'm using the latest version on macOS 12.6 apple silicon.
After using yabai -m window --warp west there's about a 500ms delay before the windows will actually swap.

Is it normal for there to be a delay before the animations play?

This delay is caused by actually setting the change in size/position using the accessibility API, and there is nothing that can be done to speed up that operation. The accessibility API is janky and that's really it - until Apple either improves the API/performance of it, or implements a different system for third-party software to interact with windows/applications.

can window open and close animations be added?

It might be possible to create a window opening animation; depends on how much delay there is between the window spawning and yabai getting notified, I guess this would likely be implemented as a fade+scale transition.
Animating on window close is pretty much impossible. The window is already inaccessible from system APIs by the time we are notified that a window has been destroyed.

What if we let the yabai to send the window closing signal? Say implement a command like yabai -m close_current_window and assign cmd+w to it using shkd

What if we let the yabai to send the window closing signal? Say implement a command like yabai -m close_current_window and assign cmd+w to it using shkd

That would probably work, but I'd prefer something more universal. I often use cmd+q instead of cmd+w if it is the last window of an application, and that would not trigger the animation with this solution.
Not that I am fully opposed to experimenting with something like what you mentioned.

I have pondered a bit further with the animation system and came up with a new POC for a fade between the scaled window and the unscaled window at the end of an animation. I believe this makes animations a lot more smooth https://github.com/FelixKratz/yabai/commit/6de83963a15f5a2a685f4768b6b3e95f7182bfd0:
https://user-images.githubusercontent.com/22680421/209445475-c867beef-551e-48a3-a2b8-c6af33b8db1f.mp4

How does that look when you hit windows that have min/max size constraints?

How does that look when you hit windows that have min/max size constraints?

A bit funny:
https://user-images.githubusercontent.com/22680421/209884625-dedef2b4-9253-40b9-8478-1ef260e5c97e.mp4

I have pondered a bit further with the animation system and came up with a new POC for a fade between the scaled window and the unscaled window at the end of an animation. I believe this makes animations a lot more smooth FelixKratz@de13dbc:

@FelixKratz I'm on the latest release v5.0.2 and enabled animation but noticed a different behavior on my terminal windows.
The text resizes after the window is set to its new location. In your video, the text resizing and window movement animation happen simultaneously. What could be the reason for this? Does your branch still have a different code?
I'm using the kitty terminal. And frame rate is set to 120 in yabai.
https://user-images.githubusercontent.com/44412790/222967164-0023f034-689b-4957-a542-854fe0bffdf2.mp4

I have the option enabled doesn't seem to be working

Is it normal for there to be a delay before the animations play?

. This delay is caused by actually setting the change in size/position using the accessibility API, and there is nothing that can be done to speed up that operation. The accessibility API is janky and that's really it - until Apple either improves the API/performance of it, or implements a different system for third-party software to interact with windows/applications.

This started to annoy me and I got a little bit creative, and found a way to improve the situation.
https://github.com/koekeishiya/yabai/issues/2060

Would love a way to just disable animations for any resize.

`window_animation_duration 0.0´ ?

I mean disable only for resize operations, but not for move operations. So any animations that are compromised by the stretching effect, while keeping the animations that look perfect.

I'm not sure if that level of complexity can be handled reasonably in the animation system. I agree that the abrupt end from final animated state to displaying the actual window is not ideal.

@net
https://github.com/koekeishiya/yabai/issues/2137
Please try the latest master; is it better or worse in your opinion? Make sure to uninstall the scripting addition and reinstall it after compiling.

I think it's better, but still not something I'd leave enabled. The stretching itself is the issue. I just noticed the stretching causes window corners to deform too when their ratio changes.
The only way I can think to do it, given the constraints, in an aesthetically pleasing way—and this way admittedly would take a lot more work—is to apply a strong gaussian blur to the overlay so you can't really see the window content deforming, and mask the corners so they look like standard macOS corners throughout the full animation.
https://github.com/koekeishiya/yabai/assets/6983821/a9720b29-72c7-465b-9ffb-67ee245a822c

Actually, here's another aesthetically pleasing option, this one even more complicated, but perhaps with the best possible effect:

For resizes narrowing a window, do not deform the window image, but rather animate the width down by masking in from the right side.
For resizes shortening a window, do the same as above, but masking up from the bottom.
For resizes widening a window, take the color of a pixel on the rightmost edge of the window image, preferable near the top just before the corner radius of top right corner begins (to increase the chance of capturing the window's UI background color). Use that color as a background fill color to animate a mask out from the right side of the window image, revealing the background fill as it animates.
For resizes lengthening a window, do the same as above, but masking down from the bottom.

A resize may use various combinations of the above options. After the resize, possibly alpha-fade to the window's true UI. The effect of this should be to appear as if the window doesn't relayout its UI until after the animation, but that the window frame itself still cleanly animates.

I think that is too much work for the actual processor to do for this to feel snappy, with the way this has to work. Preparing animation state already takes between 60-130ms depending on a variety of conditions.
I think we looked at how Apple performs transitions a bit further up this thread, and they fade transition between the old and new state. Admittedly their version looks better as they have access to more info than yabai does.

Apple does it by performing the alpha fade during the first two thirds of the animation, with some easing function that performs most of the fade within the first few frames. As you noted, this has the effect that by the time the resize animation is slowing down towards the end, the window has already faded to the new state, and so the warping is much less noticeable. They don't even do any corner masking.
I think using the same timings as Apple is as good as anyone can ask for 😄


Users/desattir/azure rg deploy/bug fixes

Hi @desattir, I'm your friendly neighborhood Microsoft Pull Request Bot (You can call me MSBOT). Thanks for your contribution!

It looks like you're a Microsoft contributor (Deepak Sattiraju). If you're full-time, we DON'T require a Contribution License Agreement. If you are a vendor, please DO sign the electronic Contribution License Agreement. It will take 2 minutes and there's no faxing! https://cla.microsoft.com.

TTYL, MSBOT;


v2ray无法启动

bash <(curl -L -s https://install.direct/go.sh) 一键安装的v2ray，提示
● v2ray.service - V2Ray Service
   Loaded: loaded (/etc/systemd/system/v2ray.service; enabled; vendor preset: disabled)
   Active: failed (Result: start-limit) since Wed 2020-06-10 00:54:40 MSK; 8s ago
     Docs: https://www.v2ray.com/
           https://www.v2fly.org/
  Process: 16585 ExecStart=/usr/bin/v2ray/v2ray -config /etc/v2ray/config.json (code=exited, status=218/CAPABILITIES)
 Main PID: 16585 (code=exited, status=218/CAPABILITIES)

Jun 10 00:54:40 vm195630.u76234.kvm.centos.7.64 systemd[1]: v2ray.service: main process exited, code=exited, status=218/CAPABILITIES
Jun 10 00:54:40 vm195630.u76234.kvm.centos.7.64 systemd[1]: Unit v2ray.service entered failed state.
Jun 10 00:54:40 vm195630.u76234.kvm.centos.7.64 systemd[1]: v2ray.service failed.
Jun 10 00:54:40 vm195630.u76234.kvm.centos.7.64 systemd[1]: v2ray.service holdoff time over, scheduling restart.
Jun 10 00:54:40 vm195630.u76234.kvm.centos.7.64 systemd[1]: Stopped V2Ray Service.
Jun 10 00:54:40 vm195630.u76234.kvm.centos.7.64 systemd[1]: start request repeated too quickly for v2ray.service
Jun 10 00:54:40 vm195630.u76234.kvm.centos.7.64 systemd[1]: Failed to start V2Ray Service.
Jun 10 00:54:40 vm195630.u76234.kvm.centos.7.64 systemd[1]: Unit v2ray.service entered failed state.
Jun 10 00:54:40 vm195630.u76234.kvm.centos.7.64 systemd[1]: v2ray.service failed.

注释掉v2ray.service中的
#CapabilityBoundingSet=CAP_NET_ADMIN CAP_NET_BIND_SERVICE
#AmbientCapabilities=CAP_NET_ADMIN CAP_NET_BIND_SERVICE
成功启动

where is the file v2ray.service ? can't find


How can I edit a Cell directly from the table ?

I want to create an editable table but there is no api call to to it.
I have done a somewhat good implementation, with onCellClick, where the user gets a pop up in the middle of the screen to edit and the enter to save it.
But I feel like a more intuitive way would be to change the text to input to that the user can edit it on the spot.
Is there a way ?

If I understand you correctly, then no, there isn't. The way this library is moving, it will be aligned with react principles regarding "controlled" components, which essentially means that you are responsible for passing in your application state via props, to the table. This approach allows maximum customizability from those implementing the table.
The library provides all the tools you would need to integrate editing into the table however you wish via customBodyRender. You can see the custom-action-columns example for a simple way in which this might be achieved, but you are free to add whatever buttons you wish and display your fields as text fields, etc.

So with customBodyRender  I can make cells <input> , in order to have an onClick function and send the edited text back to the database? thats perfect, can you link me the example custom-action-columns ?
thank you very much !

Thank you very much for the swift answer, I will continue my work. Keep up the great work !

Here you go: https://github.com/gregnb/mui-datatables/blob/master/examples/custom-action-columns/index.js.
Yes, you can do that. What you might want to do is render something that allows you to switch between the states, e.g.
customBodyRender: value => {

{value}

       <input style={{ display: this.state.isInEditingMode ? 'block' : 'none' }} value={value} />

}

You can then have a button which triggers editing mode. Note that this is pseudo code that I have not specifically verified to work, but I know this sort of approach is possible as I've done it in one of my own projects using this library.
Best of luck!

I want to create an editable table but there is no api call to to it.
I have done a somewhat good implementation, with onCellClick, where the user gets a pop up in the middle of the screen to edit and the enter to save it.
But I feel like a more intuitive way would be to change the text to input to that the user can edit it on the spot.
Is there a way ?

Hello, can you show me how to use onCellClick to edit the value?

Here you go: https://github.com/gregnb/mui-datatables/blob/master/examples/custom-action-columns/index.js.
Yes, you can do that. What you might want to do is render something that allows you to switch between the states, e.g.
customBodyRender: value => {

{value}

       <input style={{ display: this.state.isInEditingMode ? 'block' : 'none' }} value={value} />

}

You can then have a button which triggers editing mode. Note that this is pseudo code that I have not specifically verified to work, but I know this sort of approach is possible as I've done it in one of my own projects using this library.
Best of luck!

Hi! I'm trying this technique to toggle between editable fields and data.
I first tried using conditional rendering returning the editable component or else data. It didn't work, even though I'm updating my isInEditMode state.
Then I followed your suggestion using style (whether displaying 'none' or 'block' accordingly for each. But I couldn't make it work either! I can see both elements in the DOM and one of them with display: none but it doesn't change to 'block' even though my state does when I toggle them.
style={{ display: editable[dataIndex] ? 'block' : 'none' }}

In my case editable[] is a boolean array state that specifies which row is in edit mode.
Is there any other alternative for approaching editable fields?
Thank you for this amazing lib! loving it so far.


header-generator fails luminati botcheck

Describe the bug
Multiple header and TLS tests fail when visiting: https://botcheck.luminati.io/
To Reproduce

got-scraping 3.2.13
header-generator 2.1.17
crawlee 3.3.0
ubuntu focal

Headers present on request (when emulating Chrome 110 Windows):
Host: headers.cf
Connection: close
Content-Length: 0
Upgrade-Insecure-Requests: 1
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/<IP_ADDRESS> Safari/537.36
Accept: text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.7
Sec-Fetch-Mode: navigate
Sec-Fetch-Dest: document
Sec-Fetch-Site: same-site
Sec-Fetch-User: ?1
Accept-Encoding: gzip, deflate, br
Accept-Language: en-US,en;q=0.9
Sec-Ch-Ua: "Chromium";v="110", "Not A(Brand";v="24", "Google Chrome";v="110"
Sec-Ch-Ua-Mobile: ?0
Sec-Ch-Ua-Platform: "Windows"

Response from botcheck:
Type navigate
PASS User agent
FAIL Header values: sent headers do not match what is expected
  sec-fetch-site
    + same-site
    - none
PASS Header case
FAIL Header order: header order is incorrect
  :path
    + 1
    - 3
  :authority
    + 2
    - 1
  :scheme
    + 3
    - 2
PASS HTTP version
PASS TLS version
FAIL TLS cipher
  +<PHONE_NUMBER>03c02bc02fc02cc030cca9cca8c013c014009c009d002f003500ff
FAIL Http2 settings
  headerTableSize
    + 4096
    - 65536
  initialWindowSize
    + 33554432
    - 6291456
  maxConcurrentStreams
    +<PHONE_NUMBER>
    - 1000
  maxHeaderListSize
    +<PHONE_NUMBER>
    - 262144
  maxHeaderSize
    +<PHONE_NUMBER>
    - 262144

Headers present on request (when emulating Firefox 110 Windows):
Host: headers.cf
Connection: close
Content-Length: 0
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:109.0) Gecko/20100101 Firefox/110.0
Accept: text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,*/*;q=0.8
Accept-Language: en-US,en;q=0.9
Accept-Encoding: gzip, deflate, br
Upgrade-Insecure-Requests: 1
Sec-Fetch-Mode: navigate
Sec-Fetch-Dest: document
Sec-Fetch-Site: same-site
Sec-Fetch-User: ?1

Response from botcheck:
Type navigate
PASS User agent
PASS Header values
WARN Tricky headers: using these headers incorrectly may impact success rate
  - sec-fetch-site
  - sec-fetch-mode
  - sec-fetch-user
  - sec-fetch-dest
PASS Header case
PASS Header order
PASS HTTP version
PASS TLS version
FAIL TLS cipher
  +<PHONE_NUMBER>02c02bc02fcca9cca8c02cc030c00ac009c013c014009c009d002f003500ff
FAIL Http2 settings
  headerTableSize
    + 4096
    - 65536
  enablePush
    + false
    - true
  initialWindowSize
    + 33554432
    - 131072

Expected behaviour
All tests should pass (which is the case if you visit https://botcheck.luminati.io/ using a real Chrome 110 or Firefox 110 browser on Windows).
System information:

OS: Ubuntu focal
Node.js version: v18.11.0

Additional context
Add any other context about the problem here.

@Equidem could you please take a look at the header orders and incorrect headers present together? That points to some issue in the generation code or the way we process the fingerprints we collect. Since we work with correct fingerprints, we should not get incorrect results.
The TLS is a bit tricky because Node.js does not allow the same level of configuration, but we can try to look again at this as well.

I guess @Equidem won't recognize his own code, I have basically rewritten the whole thing since it was forged in the ancient flames 😄
This is likely related to apify/got-scraping#65 (mentioning the same problems) and will be partially solved by #149, which introduces an automatic way of updating the header orders. As far as I can see, the only incorrect header is sec-fetch-site, which does not identify the user - it says in what context the request was made (think CORS - same-site, cross-site...) Since got-scraping cannot execute client-side JS, the only valid value here is none (user initiated request). This is not a problem with the collected data, but with our methodology - which is easy to fix in got-scraping.

I found some antibot detection based on http header orders.
https://my.f5.com/manage/s/article/K13527565

Edge Chromium don't pass the check also.. 🙄


gatsby-source-strapi vs gatsby-source-graphql, which one to use and why?

Hello,
This is more of a broad question than a error on it self.
Which one of this two plugins should be used and why? What are some diference that can be encountered developing in the long term with each plugin?
Side note: I'm currenlty running gatsby-source-graphql but I can't get to childImageSharp, does it has something to do with this where gatsby-source-strapi helps with the images, or both handle images well and this is a totally different issue?
Thanks!

Would you mind sharing how are you doing it? How is your Collection type built?
It may be related to #98
Provide more information in order to get better guidance

Would you mind sharing how are you doing it? How is your Collection type built?
It may be related to #98
Provide more information in order to get better guidance

Using gatsby-source-strapi did solve the problems with the images, haven't really look further than that.
I personally wanted to use gatsby-source-graphql because the data has less layers and names are better.

I'm using Strapi + Gatsby with the gatsby-source-strapi plugin and am still having issues with sharp extending some of my images in Graphql.


Videos with no sound

while running on phone (IPhone7) the video has no sound to it and getting this error back
[MediaRemote] Error Operation requires a client callback to have been registered. requesting playback queue

however, in the simulator it's working perfectly. I ran the provided example to make sure that it's not caused by my backend, and the sound was also not there while running on Device.
Any help is really appreciated!

Haven't come across this issue. Can you check if your phone is not muted? And post a video which causes this issue?


Missing a policy to override "Try the new look and feel of Microsoft Edge" setting

Hi,
I noticed that Edge has a new setting called "Try the new look and feel of Microsoft Edge". I'm running 119.0.2151.46 (stable) on arm64 (Apple Silicon / macOS).
I cannot seem to find a policy that enables me to disable the new look and feel. It would be nice if there was such a policy.
Thanks!

@zakx I've reached out to the team for this and can follow up if they provide any insight.
The best way to submit feedback and feature requests is through the browser ("..." menu > Help and feedback > Send feedback).  Thanks!

@Y-Kelly Thank you for your help. Sadly, I am unable to use the described way to submit feedback, as the Edge installation I am using has set UserFeedbackAllowed to false. Is there any way to provide feedback for users that have this policy in place?

@zakx If your organization has that policy set, I do not think there is any way around it.  I'll circle back to this issue with any updates from the team.


If user is deleted from streama database doesn't update

If you delete a user in streama the database doesn't update and remove that user, so if you go to create that user again, it say's you can't create the user because they already exist.

yea, that is on purpose for constraint-issues. I just set a deleted-flag currently. I guess what I could do, is rename the username when this happens... The problem with deleting the entire user would be to also recursively delete their chosen favorite genres, their viewing-status etc.. From my work I am just used to never actually deleting records from the database, as this makes things undoable..

Why don't you want to delete all attributes to the user when you chose to delete them?

as I said, I am used to it from work. If the whole deleting-action was a mistake and you want to undo, then you cannot do that if you actually delete all the records. It's a best-practice that I learned. But in the case of the unique username i see the issue. I could add a uuid to the end of the username on deleting..
I actually don't care much either way. I will mull it over and fix it, either by deleting the user and all associated records, or by adding a uuid to the username when deleting.

Okay I understand, well either way works, keeping all the records sounds better actually so in the case of accidental deletion everything is there, just as long as we can re-add the user back. Maybe on deletion you could provide a checkbox that says delete all users data, otherwise we default to just keeping it?

not a bad idea :) will go for that.

I would in case of a non-deleting database have a separate table for mapping a username to an actual user, where this username mapping would be invalidated. Then you can create a new mapping for a second user with the same name, and if you then try to undelete the first you get the conflict. And then you can get creative with fixing it.

I am not sure I understand you correctly. Do you mean that we have one table, called user, containing among other the things the username with the uniqueness constraint, and another table with stores that same username and an id-reference to the user-table? and then once we delete the user, he gets flagged etc, the username is changed, but the original name stays stored in the other table?
My approach would have been to leave the username as is, and to append a uuid, so it would be something like<EMAIL_ADDRESS>before delete, and after it would be<EMAIL_ADDRESS>that way, if you want to "undelete" you can simply rename the username to something that makes sense via for instance phpmyadmin. I mean, undeleting is sort of an edge case, but this way it would be possible.
What would be the benefit of having an extra table like you are suggesting?

A user would then be simply a unique ID that could be bound 1-1 through a
second table to a unique username, deleting a user would be as easy ad
deleting that row in your second table.  Would make handling the historical
user a lot easier, however you lose the username after that point and can't
recreate a user unless that person knows the unique ID associated with the
account.  I like the idea proposed by @dularion personally.
On Fri, Aug 7, 2015 at 12:46 PM Antonia Hulha<EMAIL_ADDRESS>wrote:

I am not sure I understand you correctly. Do you mean that we have one
table, called user, containing among other the things the username with the
uniqueness constraint, and another table with stores that same username and
an id-reference to the user-table? and then once we delete the user, he
gets flagged etc, the username is changed, but the original name stays
stored in the other table?
My approach would have been to leave the username as is, and to append a
uuid, so it would be something like<EMAIL_ADDRESS><EMAIL_ADDRESS>before delete, and after it would be<EMAIL_ADDRESS><EMAIL_ADDRESS>that way, if
you want to "undelete" you can simply rename the username to something that
makes sense via for instance phpmyadmin. I mean, undeleting is sort of an
edge case, but this way it would be possible.
What would be the benefit of having an extra table like you are
suggesting?
—
Reply to this email directly or view it on GitHub
https://github.com/dularion/streama/issues/71#issuecomment-128776128.

So do I @admwx7


feat: add image embedding ML model type

Description
Adds image embedding ML model type to allow registering models for the image embedding task
Issues Resolved
#2621
Check List

[x] New functionality includes testing.

[x] All tests pass

[x] New functionality has been documented.

[x] New functionality has javadoc added

[x] 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.

Rebased the change in #2627 and seems passed the initial stage of linux now.
Thanks.

@IanMenendez This PR open for a long time. Can you address comments ?

I do not have much time in the coming weeks. If anyone else wants to address the comments I'm ok with it. If not I will do it once I have some spare time


[5.0] Add throwing InvalidArgumentException when undefined action passed to UrlGenerator::action()

If undefined action passed In UrlGenerator::action(), it's throw fatal exception

Call to a member function domain() on a non-object

with fully uninformative debug stack
because route, which was returned by $this->routes->getByAction($action) is not checked, before it passes to $this->toRoute(... and can be null instead of Route
	// current version
	public function action($action, $parameters = array(), $absolute = true)
	{
		if ($this->rootNamespace && ! (strpos($action, '\\') === 0))
		{
			$action = $this->rootNamespace.'\\'.$action;
		}
		else
		{
			$action = trim($action, '\\');
		}
		return $this->toRoute($this->routes->getByAction($action), $parameters, $absolute);
	}

so, it seems logical to add some check, as in UrlGenerator::route()
    public function action($action, $parameters = array(), $absolute = true)
    {
        if ($this->rootNamespace && ! (strpos($action, '\\') === 0))
        {
            $action = $this->rootNamespace.'\\'.$action;
        }
        else
        {
            $action = trim($action, '\\');
        }

        if ( !is_null($route = $this->routes->getByAction($action)))
        {
             return $this->toRoute($route, $parameters, $absolute);
        }
        throw new InvalidArgumentException("Action {$action} not defined.");

    }

Please don't create an issue for this. Send a pull if you want a change making.

This would need to go to 5.1 probably.


DOCS-5986: Added example for retrieving secure property using p function

Added an example for retrieving secure property using p function

dhimte has signed the contributors agreement

We will provide an example via a different PR. It will have the same prefix: DOCS-5986-


Implement the ENVELOPE command for enhancing SOUND

BBC Basic provides the ENVELOPE command to compliment SOUND. Looks like there  is a pull request in VDP to provide enhanced sound functionality, so perhaps it can be utilized for this request.  Not sure the same syntax as BBC one can be provided, but it would  make it easier to define the parameters compared to the long-winded VDU statements  described in the pull request.
Note up to 4 ENVELOPEs can be defined in BBC BASIC.
As a site note on SOUND:
BBC Basic uses channel 0 for noise and 1-3 for tunes where as Agon BASIC uses channels 0-2 for tunes.
The volume  parameter can be used for ENVELOPE numbers (1-4)

I've raised a new (alternate) PR on breakintoprogram/agon-vdp#76  which includes explicit commands for setting volume and frequency levels on individual channels.  There are also commands to allow channel 0 to be (re-)assigned to be a noise channel, and to enable channel 3.
The facilities there at the time of writing would allow the ENVELOPE command to be implemented in full, if the envelope is driven by the BASIC implementation (i.e. from the z80).
There is support in there for applying a conventional/simple ADSR volume envelope to a channel.  That however is not compatible with the style of volume envelope the ENVELOPE command describes, since Acorn's version implements a not-entirely-conventional for the volume level to gradually change during the "sustain" phase of a note.  The code is however designed to allow support for other envelope types to be added, so it could be extended to support a volume envelope in the Acorn mould.
The PR also includes a command to set a frequency envelope, but as of right now that's not yet implemented.  My plan is to support an envelope type that should provide the style of frequency adjustment the ENVELOPE command specifies.
It should be noted that these envelopes are applied to a channel as a whole, like a synthesiser, rather than applied to the playback of an individual note.
Additionally the PR provides facilities for indefinite note duration, and getting the status of an audio channel.  That should allow for the BASIC interpreter to fully implement the SOUND command.
(For added fun, the PR supports channel enable/disable commands - you can turn on up to 32 channels - the current BASIC SOUND command implementation is perfectly happy with playing sounds on channel number 31.  If support gets added for the &HSFC version of the channel parameter though that would inevitably restrict the command to accessing a maximum 15 channels.)

FYI all of this functionality is now present and merged into the Agon Console8 VDP firmware, complete with frequency envelope support of a type that can fully emulate Acorn's stepped frequency envelopes.  NB whilst this firmware is being developed for the Console8, it is fully compatible with other Agon Light machines.
The volume envelope style that's supported doesn't quite match Acorn's enhanced ADSR envelopes, so at this time it's not quite possible to fully implement the ENVELOPE command.  As mentioned before, it would be possible to implement such a volume envelope by driving volume changes from the z80 side within the BASIC implementation.
There are also plans to add additional envelope types to the VDP, which would allow for envelopes to be defined that can emulate Acorn's enhanced ADSR style, but I can't give you a timescale on that - it's a lower priority than other areas of functionality at the moment.

Hi Steve,
Thanks a lot for this work. I compiled the code from your PR  (without frequency envelope) and all looks good. It will take some time to get used to the Volume Envelope as the parameters time-based but your additions will enhance the BBC BASIC sound system drastically.
Keep up the good work.

Hey @leventp FYI I raised a PR yesterday after my initial sound enhancements got merged into the VDP that also does the frequency envelope stuff.
There are some further sound system enhancements merged into the Console8 VDP codebase, mostly around improving memory management and reducing the memory footprint.  Those build on some major refactoring work that changes the overall structure of the VDP codebase, so it may be quite some time (if at all) before those improvements get merged in.
Coming very soon to the Console8 VDP codebase is a "buffered commands" enhancement.  AgonConsole8/agon-vdp#30
This is rather handy when using sound samples, as the process of uploading a sample to the VDP takes a long time.  The main issue with using samples from BBC BASIC is how long it takes to read samples from data files and send them over to the VDP - using buffered commands can't fix that, unfortunately, but it can mean that very large commands (like uploading a sound sample) can be split across multiple packets.  Doing that at least means that in-between sending a data packet you can update the screen to show progress.  😀
(You can also potentially do lots more fun things with "buffered commands" - which will get even more fun with a few enhancements I'm planning on adding over the next few days.)
I will aim to raise a PR for the "buffered commands" enhancement against the main agon-vdp codebase too, however that relies on an extensive refactor of how the entire VDU command handling system works (AgonConsole8/agon-vdp#29), and in turn relies on the major restructuring work.


Problems with running on UR5

Hi, I am trying to utilize this version of ur_modern_driver in my project, and I've come across a problem.
When trying to run the ros_control node with velocity based control and default PID controller parameters the robot gets protective stopped in the middle of the first move. When I decrease P values it goes more slowly, but the movement is interrupted by slow jerks and erros occur:
[ WARN] [1529417769.185625993]: Controller /vel_based_pos_traj_controller failed with error code PATH_TOLERANCE_VIOLATED

[ WARN] [1529417769.185846757]: Controller handle /vel_based_pos_traj_controller reports status ABORTED

[ INFO] [1529417769.205158095]: Completed trajectory execution with status ABORTED ...

[ INFO] [1529417769.277249613]: ABORTED: Solution found but controller failed during execution

[ERROR] [1529417769.277592]: Reaching TARGET position failed. Check robot connection.

and sometimes
[ERROR] [1529417729.877805883]:
Invalid Trajectory: start point deviates from current robot state more than 0.01
joint 'shoulder_pan_joint': expected: -0.999794, current: -0.974795

The robot then reaches final position of the first move but runs even more slowly towards the next one.
I guess this may be similar to the other issues related with vibrations here in the modern_ur_drive repositiories, but looking at them I can't figure out what could else be done to fix this..
I'm using Ubuntu 16, ROS Kinetic and UR <IP_ADDRESS>78
While using the default packages the program ran through all the moves without problem, but I've had problems with jerky motions  and thats why I wanted to test this package.
If there is need for any additional info please ask.

Just making sure: you're not using any wireless links between you and the robot?

No, the communication is done via gigabit network card and switch. I have additional two cameras connected to this switch but they operate at 1Hz. Do you suggest it's better to change the UR software version for now?

I'm not necessarily suggesting anything, just doing some expectation management.

Ok, so main problem was with the PID values, I found them to be a lot different than the default values:
shoulder_pan_joint: {p: 18.0,  i: 270.0, d: 0.0001, i_clamp: 20.14}
shoulder_lift_joint: {p: 18.0,  i: 270.0, d: 0.0001, i_clamp: 20.14}
elbow_joint: {p: 18.0,  i: 270.0, d: 0.0001, i_clamp: 20.14}
wrist_1_joint: {p: 18.0,  i: 270.0, d: 0.0001, i_clamp: 20.14}
wrist_2_joint: {p: 18.0,  i: 270.0, d: 0.0001, i_clamp: 20.14}
wrist_3_joint: {p: 18.0,  i: 270.0, d: 0.0001, i_clamp: 20.14}

I also found that the reason for the normal jerky movements is due to switch getting overburdened (velocity control got rid of part of the problem, but while adding one more device to the switch it returned to as it was before)

Thanks for the update.

I also found that the reason for the normal jerky movements is due to switch getting overburdened (velocity control got rid of part of the problem, but while adding one more device to the switch it returned to as it was before)

Control is sensitive to delay and jitter. The more devices on an ethernet network, the higher the chance of collisions.

I had some time to experiment, and it seems that the problem is with network bottleneck at my computer, as you said. It seems that #9 fixed those issues for now (hope it gets accepted eventually).

Closing as OP reports that this appears to be a local issue.


(as an outsider) it is hard to know what my glogalCompanyId is...

Feedback in response to /AdobeDocs/analytics-2.0-apis/blob/master/oauth-postman.md
The doc says to hit :
https://analytics.adobe.io/api/**YOUR_GLOBAL_COMPANY_ID_HERE**/users?limit=10&page=0
but there is no guidance on how to know what value to use for YOUR_GLOBAL_COMPANY_ID_HERE
It would be helpful to instruct users to hit : https://analytics.adobe.io/discovery/me instead as this seems to return the list of imsOrgs which contains globalCompanyId value(s).
I found this by weeding through the curl example (https://github.com/AdobeDocs/analytics-2.0-apis/blob/master/oauth-curl.md)

Thanks for the great feedback. I'll see if I can get the postman documentation updated to make this more clear.
For what its worth, if you're comfortable submitting a PR for the documentation, you could submit the changes and we'll get it merged.


Enable LFX Insights On The VirTEE Project

This issue is to track the request to enable LFX Insights for the VirTEE project. LFX Insights has already been activated for several other CCC projects and we enable this by default for new projects
What Is LFX Insights
Insights provide  projects with more visibility into their community dynamics, particularly around contributors, organizations, issues, and pull request metrics. It does this through an app (similar to the DCO bot) installed at the organization level. This is then enabled for one or more repos under the organization. Insights uses crowd.dev under the hood to gather read-only data about specified public repositories in a GitHub organization.
What Information Is Collected (only public information from Github)

Stars/Un-stars
Forks
Issues
Pull requests
Discussions
Comments on issues/pull requests/discussions
Closing of issues/pull requests/discussions

What I Need From The Project
If folks have any questions or objections, please note this in the issue. If there are none we will enable insights in a week.
How Do We Turn This On
I am already an admin on the project and can install the read only Linux Foundation app.
More Info
You can find Insights documentation here.

In a few days metrics for the project should be visible at the following URL:
https://insights.lfx.linuxfoundation.org/foundation/ccc
As always reach out if you have any questions.


Protocol information

Hi,
I am working on making this software connect with my X-T2 in receive mode.  However, I have found new information on the protocol used to request a picture. In commands.cpp, you provide the following :
// get actual image in full size
//    18:00:00:00: 01:00:1b:10: 30:00:00:00: 01:00:00:00: 00:00:00:00:
//    68:81:08:00 // last one is image id?

I would like to correct this. In fact, the request is :
// get actual image in full size
//    18:00:00:00: 01:00:1b:10: 30:00:00:00: 01:00:00:00:
//    00:00:00:00: // offset from the begining of the picture
//    68:81:08:00 // size of the picture chunk asked

Changing the offset and the size, you can choose to download the picture in multiple parts. The camera will know when the whole picture is sent.

Any further info on this ?
I'd like to be able to send/receive pix to store on my linux server.
Doesn't need anything complicated... just the ability to drop them to a directory.

This seems PTP protocol. 101b is GetPartialObject , id, startoffset, length


Optimize train detection

In case of a coupling event it happens that a train and its rolling stocks get deleted in one EEPMain call and then the rolling stocks get re-created in next EEPMain call.
In case of a decoupling event it could happen
a) that the new train is added before the event is processed (if EEPMain already picks up the new train) or
b) added in one of the next EEPMain calls when one of the trains moves to another track (which could take a while).
This PR improves handling of train detection to speed up the calculations and to avoid remove/recreate-sequences for rolling stocks.
--
In my own project I improve performance even more by keeping a cache about all rolling stocks which even have been seen. This way I avoid to re-read any static data of rolling stocks.

Is not applicable anymore.


Are durable functions orchestrators allowed to use the Stopwatch class?

I would assume not, since it's non-deterministic - either way, since Stopwatch is an often-used API, it would be useful to add a specific call-out about its safety or lack thereof.

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

ID: 7d835903-bb13-1907-aa84-4d67eb1f5850
Version Independent ID: 669a49bd-2a6f-c578-288d-89be1535d077
Content: Durable orchestrator code constraints - Azure Functions
Content Source: articles/azure-functions/durable/durable-functions-code-constraints.md
Service: azure-functions
GitHub Login: @cgillum
Microsoft Alias: azfuncdf

@IanKemp Thank you for your feedback! We will review and update as appropriate.

Stopwatch is indeed non-deterministic, so it's not recommended to use. Instead, it's recommended that you keep track of time using the "CurrentDateTimeUtc" property of the context parameter to keep track of time.
I wouldn't say it's "unsafe" necessarily - it depends on whether you're trying to use it to make scheduling decisions. However, it definitely won't work the way you'd normally expect it to since it will restart itself on each replay.

@cgillum The problem with using CurrentDateTimeUtc in the way you're suggesting:
var start = context.CurrentUtcDateTime;

... do some work...

var end = context.CurrentUtcDateTime;
var elapsed = end - start;

is that the standard .NET guidance, for essentially forever, has been that the above is an anti-pattern and Stopwatch should be used instead because it has higher precision. What options, if any, do orchestrator function users have for high-precision timing, since I assume that IDurableOrchestrationContext.CurrentUtcDateTime is not very precise?

High-precision latency measurements aren't really useful in Durable Functions since operations such as calling activities involve a good amount of network I/O, which you don't have any direct control over. I therefore think the .NET guidance wouldn't really apply here.  This .NET guidance becomes more important when you're dealing with really small measurements (e.g. microseconds) because small measurements like that become less reliable (and could even result in negative measurements in some cases).
What exactly are you trying to measure?

High-precision latency measurements aren't really useful in Durable Functions since operations such as calling activities involve a good amount of network I/O, which you don't have any direct control over. I therefore think the .NET guidance wouldn't really apply here. This .NET guidance becomes more important when you're dealing with really small measurements (e.g. microseconds) because small measurements like that become less reliable (and could even result in negative measurements in some cases).
What exactly are you trying to measure?

We're simply looking to record the duration of orchestrator function execution from beginning to end for our own internal metrics, so that if execution duration exceeds a median value we can be notified to take a look at the func in question to see what's changed. We've been using Stopwatch for that in all our ASP.NET web services and standard Azure functions, but for orchestrations we have to use IDurableOrchestrationContext.CurrentUtcDateTime and do subtraction, which is obviously a different pattern.
I don't have any issues doing that - it's just something we have to establish and ensure is conformed to in code reviews of orchestrators - it's just that most devs are going to be used to using Stopwatch for measuring elapsed time, are therefore probably going to use it in orchestrators without thinking (especially if they don't fully comprehend how orchestrators work WRT suspension/replay), and are thus going to be very surprised when it doesn't work as they expect. I think this is an important point and as such, should explicitly be called out in the docs.
For example, the "Threading APIs" API category in the above docs has the following:

Orchestrator functions should almost never use threading APIs. For example, in .NET, avoid using ConfigureAwait(continueOnCapturedContext: false); this ensures task continuations run on the orchestrator function's original SynchronizationContext. If such APIs are necessary, limit their use to only activity functions.

I would therefore suggest the "Dates and times" API category be amended to something like the following:

Use the CurrentUtcDateTime property in .NET, the currentUtcDateTime API in JavaScript, or the current_utc_datetime API in Python, which are safe for replay. In particular, do not use the System.Diagnostics.Stopwatch class; if you need to measure elapsed time, store the value of CurrentUtcDateTime at the beginning of execution, and subtract that value from CurrentUtcDateTime when execution concludes.

Fair enough. I've opened a PR to add the note about Stopwatch in the "Dates and times" category as you suggested.
Normally, I'd suggest using our Application Insights telemetry for measuring, reporting, and alerting on execution latencies. However, this code-based mechanism works too, and might make it easier to include the delay between activity function completion the orchestration resuming.


TestHarness.psm1

Adding TestHarness to run unit tests at once

This change is

Codecov Report

Merging #234 into dev will not change coverage.
The diff coverage is n/a.

@@         Coverage Diff         @@
##            dev   #234   +/-   ##
===================================
  Coverage    84%    84%
===================================
  Files        16     16
  Lines      1433   1433
  Branches     10     10
===================================
  Hits       1206   1206
  Misses      217    217
  Partials     10     10

@AnthonyKersten Can you explain what your thought is around this? What is the scenario you are trying to solve?

@AnthonyKersten I'm closing this PR as I have not got any response on how this should be used. Please re-open if you think this should still be merged,


Shell class for "Proffer" could not be found

I have a problem with bin/cake proffer
Exception: Shell class for "Proffer" could not be found. in [/Users/vnt/Sites/test/vendor/cakephp/cakephp/src/Console/ShellDispatcher.php, line 324]
How make to resolve?

Then you'll need to load the plugin in your config/bootstrap.php file.
Plugin::load('Proffer');


Enhancing Segment Anything Notebook

I revamped the notebook to make the workflows more streamlined, reduce duplicated code, and instead of drawing points and masks on images, they are now toggle-able labels.
Here is a summary of changes made:

Added FiftyOne to requirements.txt for management, visualization, and control over computer vision datasets
Improved grammar and language in SAM notebook
Removed matplotlib dependence (including show_mask(), show_points(), and show_box() functions), and replaced all visuals with images from a session of the FiftyOne App. This is more flexible, generalizable to entire datasets, and keeps the focus of the notebook on OpenVINO
Turned repeated instances of blocks like:

coord = np.concatenate([input_point, np.array([[0.0, 0.0]])], axis=0)[None, :, :]
label = np.concatenate([input_label, np.array([-1])], axis=0)[None, :].astype(np.float32)
coord = resizer.apply_coords(coord, image.shape[:2]).astype(np.float32)

inputs = {
    "image_embeddings": image_embeddings,
    "point_coords": coord,
    "point_labels": label,
}

results = ov_predictor(inputs)

masks = results[ov_predictor.output(0)]
masks = postprocess_masks(masks, image.shape[:-1])
masks = masks > 0.0

into a function, generate_mask().

Hi @paularamo , thanks for taking a look! It seems like the issue might be that you created the dataset with that name, and then tried to create it again with the same name. It is persistent so this re-run will result in an error unless you pass in overwrite=True.
If you are having trouble with naming, you can just create the dataset without a name and a name will be auto-assigned:
dataset = fo.Dataset(persistent=True)

You can also set the name after creating:
dataset.name = "my-name"

Let me know if this resolves the issue :)

Hi @paularamo , thanks for taking a look! It seems like the issue might be that you created the dataset with that name, and then tried to create it again with the same name. It is persistent so this re-run will result in an error unless you pass in overwrite=True.
If you are having trouble with naming, you can just create the dataset without a name and a name will be auto-assigned:
dataset = fo.Dataset(persistent=True)

You can also set the name after creating:
dataset.name = "my-name"

Let me know if this resolves the issue :)

Thanks @jacobmarks. I already made your suggestions, another error is popping up. "filepath" is not defined.

If I am doing something wrong, let me know, maybe we can also document that in the notebook.
Thanks again :)

Thanks for the fixes :)

Hi @paularamo , thanks for taking a look! It seems like the issue might be that you created the dataset with that name, and then tried to create it again with the same name. It is persistent so this re-run will result in an error unless you pass in overwrite=True.
If you are having trouble with naming, you can just create the dataset without a name and a name will be auto-assigned:
dataset = fo.Dataset(persistent=True)

You can also set the name after creating:
dataset.name = "my-name"

Let me know if this resolves the issue :)

Could you please add overwrite=true to avoid further issues in case users run this cell multiple times? We can have that as default cell in the notebook and show them how they could remove the overwrite part with an example after that cell.

Hi @paularamo , thanks for taking a look! It seems like the issue might be that you created the dataset with that name, and then tried to create it again with the same name. It is persistent so this re-run will result in an error unless you pass in overwrite=True.
If you are having trouble with naming, you can just create the dataset without a name and a name will be auto-assigned:
dataset = fo.Dataset(persistent=True)

You can also set the name after creating:
dataset.name = "my-name"

Let me know if this resolves the issue :)

Could you please add overwrite=true to avoid further issues in case users run this cell multiple times? We can have that as default cell in the notebook and show them how they could remove the overwrite part with an example after that cell.

Gradio is working again in my environment. Are you using MAC?
Regarding "image" definition we need to keep the variable in the notebook. Please add this where we are reading the file.
image = cv2.imread('truck.jpg') image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)
to avoid this issue:

Thanks for your adding my suggestions. @jacobmarks

We cannot upload all these png files to the repos, that's over 40MB.

Hi @adrianboguszewski, thanks for the review. Looks like you may need to run something like the following to set up MongoDB on your computer prior to using FiftyOne (this is a one time thing, and is only necessary on some computers):
DB_DIR=~/db
mkdir -p $DB_DIR
mongod --dbpath $DB_DIR --port 12345

Still unsuccessful. The same cell.

Is MongoDB required to run the notebook? If so, please add a short information with the link to the instructions on installing mongo.

Hi @adrianboguszewski, thanks for the additional review. Sorry you're running into this issue. Are you by any chance on ubuntu?
If so, then one way to circumvent this issue is to install your own version of MongoDB and configure a connection to it. We have documentation here. In fact, import times will be much faster with this setup.
I also wanted to check in about having FiftyOne in the OpenVINO Notebooks requirements.txt file - I think having FiftyOne in the requirements.txt will make future collaboration between FiftyOne and OpenVINO on code, content and community that much easier.

@jacobmarks, we used to have all dependencies in the requirement file, but we had to abandon that approach as we got into dependency hell and had a very long installation time. So now, we keep there dependencies which are required by many notebooks only. If fiftyone becomes that case, we will be happy to add it to the requirements file :)
I'll test mongo solution later.

@adrianboguszewski @paularamo
Updates:

Merged in the latest from main, including the updated segment-anything notebook
Moved fiftyone out of requirements.txt
Added code for installing fiftyone on Ubuntu 22
Changed the name of this notebook to 237-segment-anything-fiftyone.ipynb
Added breadcrumb for this notebook to the repo's main README file
Updated the 237-segment-anything dir's README in accordance with the 2-notebook contents
Refactored the notebook, removing gradio, and focusing more on explanation
Added a section to the end showing how to apply OpenVINO SAM to a full dataset with fiftyone.


Provisioning with RancherOS and open-iscsi service will cause re-creation loop

What kind of request is this (question/bug/enhancement/feature request): BUG
Steps to reproduce (least amount of steps as possible):
Enable auto-provision with vSphere and use node template with RancherOS iso and cloud-init config below:
#cloud-config
rancher:
  services_include:
    open-iscsi: true

Provision a node from Rancher using template above, and the RancherOS VM boots up in vSphere,
then RancherOS will pull and enable open-iscsi service automatically.
Result:
After RancherOS enables open-iscsi service, Rancher will throws error and kills the VM and provision new VM again (and loop...)
Error creating machine: Error running provisioning: ssh command error: command: sudo system-docker stop docker err: exit status 1 output: Error response from daemon: No such container: docker

Logs from Rancher:
2020/07/21 06:37:17 [INFO] Provisioning node cc-worker.monitor-1
2020/07/21 06:37:17 [INFO] [node-controller-rancher-machine] Creating CA: /management-state/node/nodes/cc-worker.monitor-1/certs/ca.pem
2020/07/21 06:37:17 [INFO] [node-controller-rancher-machine] Creating client certificate: /management-state/node/nodes/cc-worker.monitor-1/certs/cert.pem
2020/07/21 06:37:18 [INFO] [node-controller-rancher-machine] Running pre-create checks...
2020/07/21 06:37:18 [INFO] [node-controller-rancher-machine] Creating machine...
2020/07/21 06:37:18 [INFO] [node-controller-rancher-machine] (cc-worker.monitor-1) Generating SSH Keypair...
2020/07/21 06:37:18 [INFO] [node-controller-rancher-machine] (cc-worker.monitor-1) Creating VM...
2020/07/21 06:37:18 [INFO] [node-controller-rancher-machine] (cc-worker.monitor-1) Image cache directory does not exist, creating it at /management-state/node/nodes/cc-worker.monitor-1/cache...
2020/07/21 06:37:19 [INFO] [node-controller-rancher-machine] (cc-worker.monitor-1) Downloading /management-state/node/nodes/cc-worker.monitor-1/cache/boot2docker.iso from https://releases.rancher.com/os/latest/rancheros-vmware.iso...
2020/07/21 06:37:21 [INFO] [node-controller-rancher-machine] (cc-worker.monitor-1) 0%!.(MISSING)..10%!.(MISSING)..20%!.(MISSING)..30%!.(MISSING)..40%!.(MISSING)..50%!.(MISSING)..60%!.(MISSING)..70%!.(MISSING)..80%!.(MISSING)..90%!.(MISSING)..100%!(NOVERB)
2020/07/21 06:37:21 [INFO] [node-controller-rancher-machine] (cc-worker.monitor-1) Finding datastore /CC-Production/datastore/vmdisk-k8s
2020/07/21 06:37:21 [INFO] [node-controller-rancher-machine] (cc-worker.monitor-1) Uploading Boot2docker ISO ...
2020/07/21 06:37:26 [INFO] [node-controller-rancher-machine] (cc-worker.monitor-1) Adding network: /CC-Production/network/2-VDS/v3113_10.1.13_Kubernetes
2020/07/21 06:37:26 [INFO] [node-controller-rancher-machine] (cc-worker.monitor-1) Adding network: /CC-Production/network/2-VDS/v3112_10.1.12_Monitor
2020/07/21 06:37:27 [INFO] [node-controller-rancher-machine] (cc-worker.monitor-1) Setting disk.enableUUID to TRUE
2020/07/21 06:37:27 [INFO] [node-controller-rancher-machine] (cc-worker.monitor-1) Setting guestinfo.interface.0.dhcp to true
2020/07/21 06:37:27 [INFO] [node-controller-rancher-machine] (cc-worker.monitor-1) Setting guestinfo.interface.1.dhcp to false
2020/07/21 06:37:27 [INFO] [node-controller-rancher-machine] (cc-worker.monitor-1) Setting guestinfo.cloud-init.config.data to #cloud-config
2020/07/21 06:37:27 [INFO] [node-controller-rancher-machine] (cc-worker.monitor-1) rancher:
2020/07/21 06:37:27 [INFO] [node-controller-rancher-machine] (cc-worker.monitor-1) services_include:
2020/07/21 06:37:27 [INFO] [node-controller-rancher-machine] (cc-worker.monitor-1) open-iscsi: true
2020/07/21 06:37:27 [INFO] [node-controller-rancher-machine] (cc-worker.monitor-1) Creating cloud-init.iso
2020/07/21 06:37:27 [INFO] [node-controller-rancher-machine] (cc-worker.monitor-1) Uploading cloud-init.iso
2020/07/21 06:37:30 [INFO] [node-controller-rancher-machine] (cc-worker.monitor-1) Waiting for VMware Tools to come online...
2020/07/21 06:39:18 [INFO] [node-controller-rancher-machine] (cc-worker.monitor-1) Provisioning certs and ssh keys...
2020/07/21 06:39:22 [INFO] [node-controller-rancher-machine] Waiting for machine to be running, this may take a few minutes...
2020/07/21 06:39:22 [INFO] [node-controller-rancher-machine] Detecting operating system of created instance...
2020/07/21 06:39:22 [INFO] [node-controller-rancher-machine] Waiting for SSH to be available...
2020/07/21 06:39:23 [INFO] [node-controller-rancher-machine] Detecting the provisioner...
2020/07/21 06:39:23 [INFO] [node-controller-rancher-machine] Provisioning with rancheros...
2020/07/21 06:39:32 [INFO] [node-controller-rancher-machine] Copying certs to the local machine directory...
2020/07/21 06:39:35 [INFO] [node-controller-rancher-machine] The default lines below are for a sh/bash shell, you can specify the shell you're using, with the --shell flag.
2020/07/21 06:39:35 [INFO] [node-controller-rancher-machine]
2020/07/21 06:39:35 [INFO] Generating and uploading node config
2020/07/21 06:39:50 [ERROR] NodeController c-77l29/m-mhklj [node-controller] failed with : Error creating machine: Error running provisioning: ssh command error: command: sudo system-docker stop docker err: exit status 1 output: Error response from daemon: No such container: docker
2020/07/21 06:39:50 [INFO] Removing node cc-worker.monitor-1

Other details that may be helpful:
It seems that enabling open-iscsi service will reboot the docker service, and if I check from console with sudo system-docker ps, the docker service is exists.
Environment information

Rancher version (rancher/rancher/rancher/server image tag or shown bottom left in the UI): v2.3.5
Installation option (single install/HA): HA

Cluster information

Cluster type (Hosted/Infrastructure Provider/Custom/Imported): vSphere
Machine type (cloud/VM/metal) and specifications (CPU/memory): VM
Kubernetes version (use kubectl version): v1.17.4

Client Version: version.Info{Major:"1", Minor:"16", GitVersion:"v1.16.1", GitCommit:"d647ddbd755faf07169599a625faf302ffc34458", GitTreeState:"clean", BuildDate:"2019-10-02T17:01:15Z", GoVersion:"go1.12.10", Compiler:"gc", Platform:"linux/amd64"}
Server Version: version.Info{Major:"1", Minor:"17", GitVersion:"v1.17.4", GitCommit:"8d8aa39598534325ad77120c120a22b3a990b5ea", GitTreeState:"clean", BuildDate:"2020-03-12T20:55:23Z", GoVersion:"go1.13.8", Compiler:"gc", Platform:"linux/amd64"}

Docker version (use docker version): 19.3.11

This issue may related to rancher/os and rancher/machine