Cannot update from GitLab CI about appimageupdater

[antony-jr]

@probonopd I'm currently solving the problem at its root(the library).

[probonopd]

Thanks @antony-jr. In this case, we could check whether a sever supports range requests and if it does not, download the whole thing.

[antony-jr]

@probonopd The library is fully rewritten in C++ and working great , To test out the new library , You can use an example program.

 $ git clone https://github.com/antony-jr/AppImageUpdaterBridge
 $ cd AppImageUpdaterBridge
 $ cd examples/SimpleUpdate
 $ mkdir build
 $ cd build
 $ qmake "CONFIG+=LOGGING_DISABLED" .. # Assuming you have qt installed
 $ make -j$(nproc) 
 $ wget -c "https://gitlab.com/probono/QtQuickApp/-/jobs/73879740/artifacts/raw/QtQuickApp-x86_64.AppImage"
 $ ./SimpleUpdate QtQuickApp-x86_64.AppImage
 $ # Test Out.

I will soon fix this program , Since the hardest work is done , All I have to do is connect some slots and change the UI.

[probonopd]

Similar issue: AppImageCommunity/AppImageUpdate#94

[probonopd]

Ping @antony-jr this is very important for us. Would be great if you could look into it. Thanks!

[antony-jr]

CC: @probonopd

AppImageUpdaterBridge can now use Gitlab as a generic zsync transport method , But the new code is still in the experimental stage but working good so far , Things that are staged in experimental will be available in a week or so after rigorous testing and refactoring. I'm also planning to make this a plugin.

These are the new features which will be available after the experimental code is merged with master,

• Completely rewritten in C++(no legacy but still uses the old hash table so some code is inherited , The hash table is used purely because of the performance , there are future plans to change this completely).
• Non-Blocking Single Threaded API , Everything is cyclic and does not even need mutex.
  ( Optionally the user can use a separate thread for the controllers if he/she wishes ).
• Synced with the Qt Event Loop , i.e non-blocking single threaded API.
• PIMPL (Pointer to IMPLementation)
• Easy to use API.
• Fixed Memory leaks.

EDIT: using zsync algorithm in parallel seems to be a overkill , The amount of resource needed to make it parallel is more and thus consumes more time. Therefore after a lot of trails , I decided that using the zsync algorithm in a single thread is always the fastest and reduces a lot of resource and complications. And also both multi-threaded and single thread versions run in same time.(This is due to the overuse of resource.)

[antony-jr]

Just found out that Gitlab cannot support range requests , Thus even if we can check for updates, Its not possible to do the update , https://gitlab.com/gitlab-com/support-forum/issues/3655 (Hope they fix this soon).