Download Sync 3 Version 3.4

Probably just missing a step, but I keep missing it consistently. I have a Traditional versioned dataset in our Portal. The Web Map and layers is configured for sync with a version per user. Creating offline area, editing and syncing all works fine. But when I go to delete the version created for this user I get the error "Operation not allowed on a version with dependent children." I know how to fix this in the SQL Server backend, by manually deleting all the dependent children first. But am I missing a step in a typical offline editing process? thanks!

The sync version should be automatically deleted when the mobile user uses Field Maps to remove the offline area from their device, assuming the mobile device is connected to a network when the remove area option is invoked.

Download 🔥 https://tinurll.com/2y3i4N 🔥

@Sean_Haile I re-read your comment, I do not believe that the sync version would be deleted when the offline area is removed. Deleting the version is done by the manager or user after confirming that any edits are sync'd rec/posted, and the offline area is removed.

Seems like one of your clients is a pre-release version and has upgraded the sync target. You can either update all your clients to the latest pre-release versions (apart from iOS and CLI which do not have packages yet) or clear everything down including your online storage and start again using just release versions.

I have two android phones. Joplin on phone-1 and Joplin on desktop can sync to my Nextcloud webdav. But joplin on phone-2 is unable to sync after I have uninstalled and resinstalled the app. The error message is Network request failed. But I am very sure that my configuration settings is correct. Any ideas what else can I try to solve this problem ? Thanks.

Important: This pre-release will ask you to upgrade your sync target and, once it is done, only the latest clients will be able to sync with this sync target. Currently that includes the desktop app (v1.0.234+) and Android app (v1.0.337+). It means if you are using these two clients you'll be fine. However if you are using the iOS or CLI clients you might want to wait till these clients are updated. Any issue with the sync target upgrade, please post on the forum.

GAPS 32-bit will no longer install on 64-bit systems. Previously, the installation completed without error, but password sync wouldn't work. Now, the two installers can no longer be confused.

I did start making async wrappers for sync tasks using Task.Run() but recently read that it's much better to just have a sync method and let the application determine if it needs to be pushed to another thread by using Task.Run() itself, which makes sense. However, I've also read that the exception to this is for naturally async functions. I'm not sure I fully understand 'naturally async' but as a basic understanding it seems that .NET framework methods that offer async methods are naturally async and WebClient.DownloadFile/DownlodFileAsync is one of those.

So my understanding is as follows. The first method should be left as is, since none of the file operation methods have async versions and are therefore not likely naturally async. It would be up to the caller to determine between just calling MoveStagingToCache() to run sync or calling Task.Run(()=>MoveStagingToCache()) to push it to a background thread.

However, in the second method, the download is naturally async (unless I misunderstand) so it could create a sync and async version. In order to do that I should NOT just wrap the sync method like this:

For DownloadToCache, similar but a little different. I want the user to be able to initiate the download operation, then continue working in the UI until the download is complete. After it's complete I will need to do some simple operations to notify the user that it's ready to go and enable the 'use it' button, etc. In this case, my understanding is that I would create this as an async method that awaits the WebClient download call. This would push it off the UI thread for the actual download, but then would return once download is complete to allow me to do whatever UI updates are needed after the await call.

Tip: "naturally asynchronous" mostly means I/O-based, with a few exceptions. One of those exceptions is some filesystem operations, unfortunately, including moving files, which should be asynchronous, but the APIs don't support asynchrony, so we have to pretend it's synchronous.

If you must (or really want to) support a synchronous API as well, I recommend the boolean argument hack. The semantic is that if you pass in sync:true, then the returned task is already completed. This allows you to keep your logic in a single method and write very small wrappers without the pitfalls normally associated with those wrappers:

You have asked multiple intertwined questions, let me make an attempt to answer most of them, to begin with read articles by Stephen Cleary for much more clarity on the working of Async, especially regarding Naturally Async - There's no thread, this will help in understanding what a naturally Async method means.

IO bound are operations which leave the process boundary to make a call to the external service (database, Web Service, Rest API), for which synchronous calls leads to blocking a thread, waiting idle for the out of process call to return, but in case of Async operations calling thread can be released to process other calls.

When the call returns, any of the worker thread can be assigned to complete the call, which can be indicated using ConfigureAwait(false) on a Task object. By virtue of IO bound Async design, system can achieve very high scalability, since the thread, which is a precious / limited resource per process is not wasted in idle waiting.

A True Async request can serve millions of request, compared to few 100 by synchronous system, underlying technology is called as IO completion ports in windows. It doesn't need a software thread to process the request, it use the hardware based concurrency

On other hand for the CPU bound async use case is in case of WPF or similar thick clients, which can take background processing on a separate thread, using Task.Run, thus free up the Ui thread, keeping system much more responsive, here you don't save a thread, since a worker thread is invoked using Task.Run, its all in same process, but system is much more responsive, which is an important achievement via async processing.

I did start making async wrappers for sync tasks using Task.Run() but but recently read that it's much better to just have a sync method and let the application determine if it needs to be pushed to another thread by using Task.Run()

There's no automatic way for the application to decide, its either your code or the code that you are calling which would create a worker thread. For IO bound Async, you need to call the correct API, which would be internally harnessing the Async pipeline exposed by the Windows (IO completion port) to make it pure Async

I'm not sure I fully understand 'naturally async' but as a basic understanding it seems that .NET framework methods that offer async methods are naturally async and WebClient.DownloadFile/DownlodFileAsync is one of those.

Most of the .Net methods offering Async version would be IO bound call, CPU bound need to be explicitly created using Task.Run and then awaited. For event based Async implementation TaskCompletionSource is a good option, which returns an ongoing awaitable Task, which can be SetResult, SetException for setting the result or error in an event thus asynchronously completing the Task. TaskCompletionSource is also a threadless implementation

Your understanding regarding Method1 is correct, user can decide whether to use a background thread to call it as it free up the main calling thread , which can be a Ui thread. Regarding Method2, as it has been mentioned in the comments, make sure it is Async all the way to the top (entry point), as that's the only way to release the calling thread to be utilized in other operations

Hello,

I am using the Obsidian sync to work on several devices. Yesterday I invested an hour of work adding details to an important note on my iPad while traveling without internet connection. Today, when I opened the note on the same device, this time being connected to the internet, I could briefly see my changes and then all changes were gone. This is from the sync log:

Hi @Muzical I am having a similar issue on a newer version of Brave on a linux install. I perused their FAQ page after a quick google search and found that there was a new sync version released that is incompatible with old sync chains. I will be attempting a new sync chain to resolve the issue but maybe this might be the same problem you are having.

Starting today, Brave desktop users (version 1.12) and Android users (version 1.12) can use our fully redesigned sync functionality to sync data from desktop to desktop, as well as across desktop and Android devices. Support for iOS will follow shortly.

Sync v2 was rebuilt over the last several months to be more directly compatible with the Chromium sync system. Sync v2 supports more sync data types, while still keeping the client side data encrypted, so only users can see their data.

Sync is not currently available for Brave Rewards data, but will be in the future. Meanwhile, Brave users who opt into Brave Rewards can verify their Brave wallets via Uphold and connect up to four of their devices (including Android) to the same Uphold wallet in order to sync their Rewards.

For complete details on how to set up Sync v2 or upgrade to it from the previous sync, users can visit this page. Users who need further assistance or who have questions can reach out to us on our Brave Community site in the Sync section. The Sync v2 FAQ is also available here. ff782bc1db