joeviocoe / qubesdashboard

A Graphical Dashboard for the common management of Qubes 4.0

QubesDashboard

A Graphical Dashboard for the common management of Qubes 4.0

Dependencies

Building from source

See package.json

Installing RPM package

sudo qubes-dom0-update libXScrnSaver

rpm -i QubesDashboard-*.x86_64.rpm --nodeps

qubesdashboard's Issues

Consider using qubesadmin instead of qvm-*

You should consider using the Qubes admin API instead of parsing command line output. Its documentation is unfortunately rather poor, but it's not bad once you become familiar with it.

Here are some helpful entry points to trying it out:

• prose overview: https://www.qubes-os.org/news/2017/06/27/qubes-admin-api/
• overview of RPC methods used internally between qubesd and qubesadmin client: https://www.qubes-os.org/doc/admin-api/
• documentation for the qubes python module: https://dev.qubes-os.org/projects/core-admin/en/latest/ (but this is not actually what you should use, rather you should use the similar qubesadmin, which is a consumer of the RPC API and can be run in non-dom0 domains)
• documentation of the qubesadmin module (kinda disorganized, sorry): https://dev.qubes-os.org/projects/core-admin-client/en/latest/qubesadmin.html#submodules

By using it instead of the qvm-* tools, you can avoid a whole class of potential parsing ambiguity, as well as breakage if the qvm-* tools' output (most of which is primarily meant for human consumption) change formats in backwards-incompatible ways again.

The best way to really get a hang of it is to just play around in a python3 repl:

[user@dom0 ~]$ python3 -ic ''
>>> import qubesadmin
>>> app = qubesadmin.Qubes()
>>> app. <tab>
app.__class__(               app._method_prefix
app.__delattr__(             app._parse_qubesd_response(
app.__dict__                 app._parse_type_value(
app.__dir__(                 app._pool_drivers
app.__doc__                  app._properties
app.__eq__(                  app._properties_help
app.__format__(              app._refresh_pool_drivers(
app.__ge__(                  app.add_new_vm(
app.__getattr__(             app.add_pool(
app.__getattribute__(        app.app
app.__gt__(                  app.blind_mode
app.__hash__(                app.clone_properties(
app.__init__(                app.clone_vm(
app.__le__(                  app.domains
app.__lt__(                  app.get_label(
app.__module__               app.get_vm_class(
app.__ne__(                  app.labels
app.__new__(                 app.log
app.__reduce__(              app.pool_driver_parameters(
app.__reduce_ex__(           app.pool_drivers
app.__repr__(                app.pools
app.__setattr__(             app.property_get_default(
app.__sizeof__(              app.property_help(
app.__str__(                 app.property_is_default(
app.__subclasshook__(        app.property_list(
app.__weakref__              app.qubesd_call(
app._local_properties(       app.qubesd_connection_type
app._local_properties_set    app.remove_pool(
app._method_dest             app.run_service(
>>> app.domains. <tab>
app.domains.__class__(         app.domains.__module__
app.domains.__contains__(      app.domains.__ne__(
app.domains.__delattr__(       app.domains.__new__(
app.domains.__delitem__(       app.domains.__reduce__(
app.domains.__dict__           app.domains.__reduce_ex__(
app.domains.__dir__(           app.domains.__repr__(
app.domains.__doc__            app.domains.__setattr__(
app.domains.__eq__(            app.domains.__sizeof__(
app.domains.__format__(        app.domains.__str__(
app.domains.__ge__(            app.domains.__subclasshook__(
app.domains.__getattribute__(  app.domains.__weakref__
app.domains.__getitem__(       app.domains._vm_list
app.domains.__gt__(            app.domains._vm_objects
app.domains.__hash__(          app.domains.app
app.domains.__init__(          app.domains.clear_cache(
app.domains.__iter__(          app.domains.keys(
app.domains.__le__(            app.domains.refresh_cache(
app.domains.__lt__(            app.domains.values(
>>> help(app.domains)
Help on VMCollection in module qubesadmin.app object:

class VMCollection(builtins.object)
 |  Collection of VMs objects
 |  
 |  Methods defined here:
 |  
 |  __contains__(self, item)
 |  
 |  __delitem__(self, key)
 |  
 |  __getitem__(self, item)
 |  
 |  __init__(self, app)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |  
 |  __iter__(self)
 |  
 |  clear_cache(self)
 |      Clear cached list of VMs
 |  
 |  keys(self)
 |      Get list of VM names.
 |  
 |  refresh_cache(self, force=False)
 |      Refresh cached list of VMs
 |  
 |  values(self)
 |      Get list of VM objects.
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |  
 |  __dict__
 |      dictionary for instance variables (if defined)
 |  
 |  __weakref__
 |      list of weak references to the object (if defined)
>>> sys_net = app.domains['sys-net']
>>> sys_net. <tab>
sys_net.__class__(                  sys_net._volumes
sys_net.__delattr__(                sys_net.app
sys_net.__dict__                    sys_net.appvms
sys_net.__dir__(                    sys_net.clone_properties(
sys_net.__doc__                     sys_net.connected_vms
sys_net.__eq__(                     sys_net.devices
sys_net.__format__(                 sys_net.features
sys_net.__ge__(                     sys_net.firewall
sys_net.__getattr__(                sys_net.force_shutdown(
sys_net.__getattribute__(           sys_net.get_disk_utilization(
sys_net.__gt__(                     sys_net.get_power_state(
sys_net.__hash__(                   sys_net.is_halted(
sys_net.__init__(                   sys_net.is_networked(
sys_net.__le__(                     sys_net.is_paused(
sys_net.__lt__(                     sys_net.is_running(
sys_net.__module__                  sys_net.kill(
sys_net.__ne__(                     sys_net.klass
sys_net.__new__(                    sys_net.log
sys_net.__reduce__(                 sys_net.name
sys_net.__reduce_ex__(              sys_net.pause(
sys_net.__repr__(                   sys_net.prepare_input_for_vmshell(
sys_net.__setattr__(                sys_net.property_get_default(
sys_net.__sizeof__(                 sys_net.property_help(
sys_net.__str__(                    sys_net.property_is_default(
sys_net.__subclasshook__(           sys_net.property_list(
sys_net.__weakref__                 sys_net.qubesd_call(
sys_net._klass                      sys_net.run(
sys_net._local_properties(          sys_net.run_service(
sys_net._local_properties_set       sys_net.run_service_for_stdio(
sys_net._method_dest                sys_net.shutdown(
sys_net._method_prefix              sys_net.start(
sys_net._parse_qubesd_response(     sys_net.tags
sys_net._parse_type_value(          sys_net.unpause(
sys_net._properties                 sys_net.volumes
sys_net._properties_help            

Please provide the AppImage for download on GitHub Releases

QubesDashboard/package.json

Line 44 in 5077f16

"AppImage",

Please provide the AppImage for download on GitHub Releases.

Providing an AppImage would have, among others, these advantages:

• Applications packaged as an AppImage can run on many distributions (including Ubuntu, Fedora, openSUSE, CentOS, elementaryOS, Linux Mint, and others)
• One app = one file = super simple for users: just download one AppImage file, make it executable, and run
• No unpacking or installation necessary
• No root needed
• No system libraries changed
• Works out of the box, no installation of runtimes needed
• Optional desktop integration with appimaged
• Optional binary delta updates, e.g., for continuous builds (only download the binary diff) using AppImageUpdate
• Can optionally GPG2-sign your AppImages (inside the file)
• Works on Live ISOs
• Can use the same AppImages when dual-booting multiple distributions
• Can be listed in the AppImageHub central directory of available AppImages
• Can double as a self-extracting compressed archive with the --appimage-extract parameter

Here is an overview of projects that are already distributing upstream-provided, official AppImages.

If you have questions, AppImage developers are on #AppImage on irc.freenode.net.