Ich kann kein geeignetes Dienstprogramm finden, um nur die Dateisystemnutzung (% Speicherplatz frei für Partitionen) auf dem Bedienfeld anzuzeigen.

Und ich freue mich nicht darauf, irgendwelche schlechten Desktop-Management-Tools zu installieren, sondern einen einfachen Indikator.

Ich freue mich über alle Ihre Vorschläge.

BEARBEITEN:

1. NEUE ANTWORT

Während die Antwort unten in dieser verwendet werden kann (siehe [2.]), führt sie zu einer ppa-Version mit zusätzlichen Optionen, die in einem Einstellungsfenster festgelegt werden.

Zu den Optionen gehören:

• Festlegen aller Aliase in einem Fenster

• Festlegen der Themenfarben für das Bedienfeldsymbol:

  

• Schwellenwert für Warnungen einstellen

• Informationen zu neu gemounteten / verbundenen Volumes in einer Benachrichtigung anzeigen:

  

• Beim Start ausführen

Darüber hinaus enthält der Indikator jetzt ein kleineres Symbol (Breite) für andere Distributionen (wie xfce), das je nach Fenstermanager automatisch angewendet wird.

Installieren:

sudo add-apt-repository ppa:vlijm/spaceview
sudo apt-get update
sudo apt-get install spaceview

2. ALTE ANTWORT

Das folgende Skript ist ein Indikator, der Ihre Geräte auflistet und deren Verwendung anzeigt. Die Informationen werden (falls erforderlich) einmal alle zehn Sekunden aktualisiert.

Außerdem

• Während die Anzeige läuft, können Sie ein Gerät auswählen, das im Symbol dargestellt werden soll. Das Gerät wird beim nächsten Ausführen der Anzeige gespeichert:

  

  

  

• Für ein oder mehrere (oder alle) Geräte können Sie einen alternativen Namen ("benutzerdefinierter Name") festlegen, der im Kopf des Skripts festgelegt wird

  Als Beispiel:

  alias = [
      ["sdc1", "stick"],
      ["sdb1", "External"],
      ["sda2", "root"],
      ["sda4", "ntfs1"],
      ["sda5", "ntfs2"],
      ["//192.168.0.104/media", "netwerk media"],
      ["//192.168.0.104/werkmap_documenten", "netwerk docs"],
      ]

  Wird zeigen:

  

• Sie können einen Schwellenwert festlegen . Wenn der freie Speicherplatz eines Ihrer Geräte darunter liegt, erhalten Sie eine Warnung:

  

• Verstopfte / nicht angeschlossene Geräte werden innerhalb von 10 Sekunden zur Menuliste hinzugefügt / daraus entfernt.

Das Skript

#!/usr/bin/env python3
import subprocess
import os
import time
import signal
import gi
gi.require_version('Gtk', '3.0')
gi.require_version('AppIndicator3', '0.1')
from gi.repository import Gtk, AppIndicator3, GObject
from threading import Thread

#--- set alias names below in the format [[device1, alias1], [device2, alias2]]
#--- just set alias = [] to have no custom naming
alias = []
#--- set the threshold to show a warning below 
#--- set to 0 to have no warning
threshold = 17
#---
currpath = os.path.dirname(os.path.realpath(__file__))
prefsfile = os.path.join(currpath, "showpreferred")

class ShowDevs():
    def __init__(self):
        self.default_dev = self.get_showfromfile()
        self.app = 'show_dev'
        iconpath = currpath+"/0.png"
        self.indicator = AppIndicator3.Indicator.new(
            self.app, iconpath,
            AppIndicator3.IndicatorCategory.OTHER)
        self.indicator.set_status(AppIndicator3.IndicatorStatus.ACTIVE)       
        self.indicator.set_menu(self.create_menu())
        self.indicator.set_label("Starting up...", self.app)
        self.update = Thread(target=self.check_changes)
        self.update.setDaemon(True)
        self.update.start()

    def check_changes(self):
        state1 = None
        while True:
            self.state2 = self.read_devices()
            if self.state2 != state1:
                self.update_interface(self.state2)
            state1 = self.state2
            time.sleep(10)

    def update_interface(self, state):
        warning = False; self.newmenu = []
        for dev in state:
            mention = self.create_mention(dev)
            name = mention[0]; deci = mention[2]; n = mention[1]
            if n <= threshold:
                warning = True
            try:
                if self.default_dev in name:
                    newlabel = mention[3]
                    newicon = currpath+"/"+str(10-deci)+".png"
            except TypeError:
                pass
            self.newmenu.append(name+" "+str(n)+"% free")
        if warning:
            newlabel = "Check your disks!"
            newicon = currpath+"/10.png"
        try:
            self.update_indicator(newlabel, newicon)
        except UnboundLocalError:
            labeldata = self.create_mention(state[0])
            newlabel = labeldata[3]
            newicon = currpath+"/"+str(10-labeldata[2])+".png"
            self.update_indicator(newlabel, newicon)
        GObject.idle_add(self.set_new, 
            priority=GObject.PRIORITY_DEFAULT)  

    def update_indicator(self, newlabel, newicon):
        GObject.idle_add(self.indicator.set_label,
            newlabel, self.app,
            priority=GObject.PRIORITY_DEFAULT)   
        GObject.idle_add(self.indicator.set_icon,
            newicon,
            priority=GObject.PRIORITY_DEFAULT)

    def set_new(self):
        for i in self.initmenu.get_children():
            self.initmenu.remove(i)
        for item in self.newmenu:
            add = Gtk.MenuItem(item)
            add.connect('activate', self.change_show)
            self.initmenu.append(add) 
        menu_sep = Gtk.SeparatorMenuItem()
        self.initmenu.append(menu_sep)
        self.item_quit = Gtk.MenuItem('Quit')
        self.item_quit.connect('activate', self.stop)
        self.initmenu.append(self.item_quit)
        self.initmenu.show_all()

    def change_show(self, *args):
        index = self.initmenu.get_children().index(self.initmenu.get_active())
        self.default_dev = self.newmenu[index].split()[0]
        open(prefsfile, "wt").write(self.default_dev)
        self.update_interface(self.read_devices())

    def create_mention(self, dev):
        name = dev[1] if dev[1] else dev[0]
        n = dev[2]; deci = round(dev[2]/10)
        newlabel = name+" "+str(n)+"% free"
        return (name, n, deci, newlabel)        

    def create_menu(self):
        # create initial basic menu
        self.initmenu = Gtk.Menu()
        self.item_quit = Gtk.MenuItem('Quit')
        self.item_quit.connect('activate', self.stop)
        self.initmenu.append(self.item_quit)
        self.initmenu.show_all()
        return self.initmenu

    def read_devices(self):
        # read the devices, look up their alias and the free sapace
        devdata = []
        data = subprocess.check_output(["df", "-h"]).decode("utf-8").splitlines()
        relevant = [l for l in data if all([
                    any([l.startswith("/dev/"), l.startswith("//")]),
                    not "/loop" in l])
                    ]
        for dev in relevant:
            data = dev.split(); name = data[0]; pseudo = None       
            free = 100-int([s.strip("%") for s in data if "%" in s][0])
            for al in alias:
                if al[0] in name:
                    pseudo = al[1]
                    break
            devdata.append((name, pseudo, free)) 
        return devdata

    def get_showfromfile(self):
        # read the preferred default device from file
        try:
            defdev = open(prefsfile).read().strip()
        except FileNotFoundError:
            defdev = None
        return defdev

    def stop(self, source):
        Gtk.main_quit()

ShowDevs()
GObject.threads_init()
signal.signal(signal.SIGINT, signal.SIG_DFL)
Gtk.main()

Die Symbole

0.png

1.png

2.png

3.png

4.png

5.png

6.png

7.png

8.png

9.png

10.png

Einrichten

Das Einrichten ist einfach:

• Kopieren Sie das Skript in eine leere Datei und speichern Sie es unter showusage.py
• Speichern Sie die obigen Symbole, die genau wie in ihrer Bezeichnung benannt sind , in ein und demselben Verzeichnis wie das Skript (Rechtsklick> Speichern unter).

• Setzen Sie im Kopfbereich des Skripts (mögliche) alternative Namen ( aliasses). Unten ein Beispiel:

  alias = [
      ["sda2", "root"],
      ["sdb1", "External"]
      ]

  Wenn Sie die Geräte unverändert anzeigen möchten, verwenden Sie:

  alias = []

  ... und wenn Sie möchten, ändern Sie den Schwellenwert, um eine Warnung anzuzeigen:

  #--- set the threshold to show a warning below (% free, in steps of 10%)
  #--- set to 0 to have no warning
  threshold = 10

  Das ist es

Laufen lassen

Führen Sie den folgenden Befehl aus, um den Indikator zu verwenden:

python3 /path/to/showusage.py

Verwenden Sie den folgenden Befehl, um es zu Startanwendungen hinzuzufügen:

/bin/bash -c "sleep 10 && python3 /path/to/showusage.py"

Wählen Sie Anwendungen: Dash> Anwendungen starten> Hinzufügen, und fügen Sie den obigen Befehl hinzu.

_{Haftungsausschluss: Ich bin Autor dieses Indikators und er wurde für diese spezielle Frage geschrieben}

Update 23. Oktober 2008

Der Indikator unterstützt jetzt das Auflisten von Netzwerkfreigaben . Danke an mihaigalos

Update 29. Oktober 2016

Der Indikator verfügt jetzt über Funktionen zum Aufheben der Bereitstellung, und Aliase wurden eindeutig gemacht, indem auf die UUID jeder Partition verwiesen wurde, anstatt auf den Namen des Blockgeräts, z sda1. Siehe den zugehörigen Fehlerbericht

Update, 8. Oktober 2016

Der Indikator ist jetzt in Version 2.0, hat einige Funktionen hinzugefügt und verfügt über eine eigene PPA.

Führen Sie zur Installation von PPA die folgenden Schritte im Terminal aus:

1. sudo apt-add-repository ppa:udisks-indicator-team/ppa
2. sudo bash -c 'apt-get update && apt-get install udisks-indicator'

Wie in den Versionshinweisen erwähnt, umfassen die Funktionen:

• Symbole für Menüeinträge: An jede Partition / jedes Gerät ist ein entsprechendes Symbol angehängt. Wenn es sich bei dem Gerät um eine USB-Festplatte handelt, wird das Symbol für Wechselmedien verwendet. Wenn es sich um ein ISO-Image handelt, wird das Symbol für die optische Festplatte verwendet, und offensichtlich haben Festplatten- / SSD-Partitionen Laufwerkssymbole.
• Die Verwendung wird jetzt in Prozent und für Menschen lesbaren Werten (Potenzen von 1024) angezeigt.
• Grafische Darstellung der Nutzung über die Nutzungsleiste (ein großes Dankeschön an Mateo Salta für die Idee)
• Dialogfeld "Einstellungen": Benutzer können bestimmte Felder deaktivieren, die sie nicht für jeden Menüeintrag sehen möchten. Auf diese Weise können Sie das Anzeigemenü sauber halten, wenn eine große Anzahl von Partitionen angeschlossen ist. (Dank Zacharees Bitte)
• Textabstand: Mit den Standardschriftarten Ubuntu und Monospace sind die Texteinträge gut verteilt, um ein saubereres Erscheinungsbild zu erzielen und die Lesbarkeit der Informationen zu verbessern.
• Benachrichtigungsblasen für den Fall, dass die Partition nicht bereitgestellt werden kann

Unten ist der Screenshot mit dem Standard-Ubuntu-Symbolthema:

Ubuntu Kylin Symbol Thema

Wenn alle optionalen Felder deaktiviert sind

Designentscheidungen und zusätzliche Gedanken:

Bei der Erstellung dieses Indikators hoffte ich auf ein Dienstprogramm, das sowohl für fortgeschrittene als auch für gelegentliche Benutzer geeignet ist. Ich habe versucht, einige der Probleme zu beheben, die den neuen Benutzern beim Umgang mit Befehlszeilentools aufgefallen sind. Darüber hinaus strebt das Dienstprogramm eine Mehrzweckfunktion an.

Im Dialogfeld "Einstellungen" können Sie den Indikator so komplex und / oder so einfach gestalten, wie es der Benutzer wünscht. Es war auch eine spezielle Designentscheidung, zu vermeiden, dass sich im oberen Bereich ein Etikett befindet, damit nicht zu viel Platz im oberen Bereich des Benutzers beansprucht wird. Darüber hinaus ist dieser Indikator ein Mehrzweckdienstprogramm, mit dem Partitionen gemountet und ihre jeweiligen Verzeichnisse geöffnet werden können. Dies kann nicht nur als Dienstprogramm zur Datenträgernutzung verwendet werden, sondern auch als Navigationsdienstprogramm zum schnellen Öffnen der Verzeichnisse.

Benutzer können auch bequem erkennen, welche Partition sich auf welcher Festplatte befindet, wodurch häufige Verwechslungen mit dem Mounten über Befehlszeilendienstprogramme wie z mount. Stattdessen wird es udisksctlfür diesen Zweck verwendet (sowie das Abrufen der Informationen vom UDisks2Daemon, daher die Benennung). Die einzige Aufgabe, die nicht ausgeführt wird, ist das Aufheben der Bereitstellung. Aus diesem Grund ist der Open Disks UtilityMenüeintrag enthalten.

Während ich ursprünglich versucht hatte, es dem iStat-Menulet ähnlich zu machen, weicht das Projekt von diesem Ziel ab - der Indikator ist in Design und Zweck einzigartig. Ich hoffe, es wird für viele Benutzer nützlich sein und ihre Ubuntu-Erfahrung viel angenehmer machen.

udisks-Indikator (ursprüngliche Antwort)

Anzeige für Ubuntu mit Unity-Desktop zur Anzeige der Festplattennutzung

Überblick

Dieser Indikator für Ubuntu mit Unity ermöglicht das einfache Anzeigen von Informationen zu Ihren bereitgestellten Partitionen. Es ist bestrebt, dem iStat Menu 3-Menulet von OS X optisch ähnlich zu sein.

Die Einträge sind in der Reihenfolge organisiert:

• Trennwand
• Alias ​​(falls vom Benutzer festgelegt)
• Festplattenlaufwerk, zu dem die Partition gehört
• Mountpoint der Partition (Verzeichnis)
• % Verwendung

Durch Klicken auf jeden Partitionseintrag wird der Mountpunkt der Partition im Standarddateimanager geöffnet

Das Menü "Nicht gemountete Partitionen" listet alle Partitionen auf, die derzeit nicht vom System gemountet werden. Durch Klicken auf einen Eintrag in diesem Untermenü wird diese Partition automatisch bereitgestellt, normalerweise in einem /media/username/drive-idOrdner

Der Indikator verwendet die im System enthaltenen Standardsymbole. Daher sollte sich das Symbol ändern, wenn Sie das Symbolthema mit dem Unity Tweak Tool oder anderen Methoden ändern

HINWEIS : Wenn Sie mehrere Aliase gleichzeitig hinzufügen möchten, anstatt nacheinander über die Option "Alias ~/.partition_aliases.jsonerstellen ", können Sie dies durch Bearbeiten der Konfigurationsdatei tun . Das Format ist wie folgt:

{
    "sda1": "Alias 1",
    "sda2": "Alias 2",
    "sdb1": "Alias 3"
}

Installation

PPA für eine einfache Installation ist in Kürze verfügbar. . .

In der Zwischenzeit sind hier alternative Schritte:

1. cd /tmp
2. wget https://github.com/SergKolo/udisks-indicator/archive/master.zip
3. unzip master.zip
4. sudo install udisks-indicator-master/udisks-indicator /usr/bin/udisks-indicator
5. sudo install udisks-indicator-master/udisks-indicator.desktop /usr/share/applications/udisks-indicator.desktop

All diese Schritte können in ein nettes kleines Installationsskript eingefügt werden:

#!/bin/bash

cd /tmp
rm master.zip*
wget https://github.com/SergKolo/udisks-indicator/archive/master.zip
unzip master.zip
install udisks-indicator-master/udisks-indicator /usr/bin/udisks-indicator
install udisks-indicator-master/udisks-indicator.desktop /usr/share/applications/udisks-indicator.desktop

Quellcode

Der Original-Quellcode (Version v1.0) mit den grundlegenden Funktionen dieses Indikators finden Sie unten. Die neuesten Funktionen finden Sie im GitHub-Repository für dieses Projekt . Bitte melden Sie alle Funktionsanfragen sowie Fehler auf GitHub.

Die /usr/bin/udisks-indicator:

#!/usr/bin/env python3
# -*- coding: utf-8 -*-

#
# Author: Serg Kolo , contact: [email protected]
# Date: September 27 , 2016
# Purpose: appindicator for displaying mounted filesystem usage
# Tested on: Ubuntu 16.04 LTS
#
#
# Licensed under The MIT License (MIT).
# See included LICENSE file or the notice below.
#
# Copyright © 2016 Sergiy Kolodyazhnyy
#
# Permission is hereby granted, free of charge, to any person obtaining a copy
# of this software and associated documentation files (the "Software"), to deal
# in the Software without restriction, including without limitation the rights
# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
# copies of the Software, and to permit persons to whom the Software is
# furnished to do so, subject to the following conditions:
#
# The above copyright notice and this permission notice shall be included
# in all copies or substantial portions of the Software.
#
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
# SOFTWARE.
import gi
gi.require_version('AppIndicator3', '0.1')
from gi.repository import GLib as glib
from gi.repository import AppIndicator3 as appindicator
from gi.repository import Gtk as gtk
from os import statvfs
#from collections import OrderedDict
import subprocess
import shutil
import dbus
import json
import os

class UdisksIndicator(object):

    def __init__(self):
        self.app = appindicator.Indicator.new(
            'udisks-indicator', "drive-harddisk-symbolic.svg",
            appindicator.IndicatorCategory.HARDWARE
            )

        if not self.app.get_icon():
           self.app.set_icon("drive-harddisk-symbolic")

        self.app.set_status(appindicator.IndicatorStatus.ACTIVE)

        filename = '.partition_aliases.json'
        user_home = os.path.expanduser('~')
        self.config_file = os.path.join(user_home,filename)
        self.cache = self.get_partitions()
        self.make_menu()
        self.update()


    def update(self):
        timeout = 5
        glib.timeout_add_seconds(timeout,self.callback)

    def callback(self):
        if self.cache != self.get_partitions():
            self.make_menu()
        self.update()        

    def make_menu(self,*args):
        """ generates entries in the indicator"""
        if hasattr(self, 'app_menu'):
            for item in self.app_menu.get_children():
                self.app_menu.remove(item)

        self.app_menu = gtk.Menu()

        partitions = self.get_partitions()
        for i in partitions:

            part = "Partition: " + i[0]
            alias = self.find_alias(i[0])
            drive = "\nDrive: " + i[1]
            mount = "\nMountPoint: " + i[2]
            usage = "\n%Usage: " + i[3]

            item = part + drive + mount + usage
            if alias:
                alias = "\nAlias: " + alias
                item = part + alias + drive + mount + usage

            self.menu_item = gtk.MenuItem(item)
            self.menu_item.connect('activate',self.open_mountpoint,i[2])
            self.app_menu.append(self.menu_item)
            self.menu_item.show()

            self.separator = gtk.SeparatorMenuItem()
            self.app_menu.append(self.separator)
            self.separator.show()

        self.unmounted = gtk.MenuItem('Unmounted Partitions')
        self.unmounted_submenu = gtk.Menu()
        self.unmounted.set_submenu(self.unmounted_submenu)

        for i in self.get_unmounted_partitions():

            # TODO: add type checking, prevent swap

            part = "Partition: " + i[0]
            alias = self.find_alias(i[0])
            drive = "\nDrive: " + i[1]
            label = part + drive
            if alias: 
               alias = "\nAlias: " + alias
               label = part + alias + drive

            self.menu_item = gtk.MenuItem(label)
            self.menu_item.connect('activate',self.mount_partition,i[0])
            self.unmounted_submenu.append(self.menu_item)
            self.menu_item.show()

            self.separator = gtk.SeparatorMenuItem()
            self.unmounted_submenu.append(self.separator)
            self.separator.show()

        self.app_menu.append(self.unmounted)
        self.unmounted.show()


        self.separator = gtk.SeparatorMenuItem()
        self.app_menu.append(self.separator)
        self.separator.show()

        self.make_part_alias = gtk.MenuItem('Make Alias')
        self.make_part_alias.connect('activate',self.make_alias)
        self.app_menu.append(self.make_part_alias)
        self.make_part_alias.show()

        user_home = os.path.expanduser('~')
        desktop_file = '.config/autostart/udisks-indicator.desktop'
        full_path = os.path.join(user_home,desktop_file)

        label = 'Start Automatically' 
        if os.path.exists(full_path):
           label = label + ' \u2714'
        self.autostart = gtk.MenuItem(label)
        self.autostart.connect('activate',self.toggle_auto_startup)
        self.app_menu.append(self.autostart)
        self.autostart.show()

        self.open_gnome_disks = gtk.MenuItem('Open Disks Utility')
        self.open_gnome_disks.connect('activate',self.open_disks_utility)
        self.app_menu.append(self.open_gnome_disks)
        self.open_gnome_disks.show()

        self.quit_app = gtk.MenuItem('Quit')
        self.quit_app.connect('activate', self.quit)
        self.app_menu.append(self.quit_app)
        self.quit_app.show()

        self.app.set_menu(self.app_menu)

    def mount_partition(self,*args):
        # TODO: implement error checking for mounting
        return self.run_cmd(['udisksctl','mount','-b','/dev/' + args[-1]])

    def get_mountpoint_usage(self,mountpoint):
        fs = statvfs(mountpoint)
        usage = 100*(float(fs.f_blocks)-float(fs.f_bfree))/float(fs.f_blocks)
        return str("{0:.2f}".format(usage))

    def get_partitions(self):
        objects = self.get_dbus('system', 
                           'org.freedesktop.UDisks2', 
                           '/org/freedesktop/UDisks2', 
                           'org.freedesktop.DBus.ObjectManager',
                           'GetManagedObjects',
                           None)


        partitions = []
        for item in objects:
            try:
                if 'block_devices'  in str(item):


                       drive = self.get_dbus_property('system',
                                        'org.freedesktop.UDisks2',
                                        item,
                                        'org.freedesktop.UDisks2.Block',
                                        'Drive')
                       if drive == '/': continue

                       mountpoint = self.get_mountpoint(item)
                       if not mountpoint: continue
                       mountpoint = mountpoint.replace('\x00','')

                       drive = str(drive).split('/')[-1]
                       usage = self.get_mountpoint_usage(mountpoint)

                       part = str(item.split('/')[-1])
                       partitions.append((part,drive,mountpoint,usage))                       

            except Exception as e:
                #print(e)
                pass

        # returning list of tuples
        partitions.sort()
        return partitions

    def get_mountpoint(self,dev_path):
        try:
            data = self.get_dbus_property(
                             'system',
                             'org.freedesktop.UDisks2',
                             dev_path,
                             'org.freedesktop.UDisks2.Filesystem',
                             'MountPoints')[0]

        except Exception as e:
            #print(e)
            return None
        else:
            if len(data) > 0:
                return ''.join([ chr(byte) for byte in data])


    def get_unmounted_partitions(self):
        objects = self.get_dbus('system', 
                           'org.freedesktop.UDisks2', 
                           '/org/freedesktop/UDisks2', 
                           'org.freedesktop.DBus.ObjectManager',
                           'GetManagedObjects',
                           None)


        partitions = []
        for item in objects:
            try:
                if 'block_devices'  in str(item):
                       drive = self.get_dbus_property('system',
                                        'org.freedesktop.UDisks2',
                                        item,
                                        'org.freedesktop.UDisks2.Block',
                                        'Drive')
                       if drive == '/': continue

                       mountpoint = self.get_mountpoint(item)
                       if  mountpoint: continue

                       drive = str(drive).split('/')[-1]
                       part = str(item.split('/')[-1])
                       if not part[-1].isdigit(): continue
                       partitions.append((part,drive))                       
                       #print(partitions)

            except Exception as e:
                #print(e)
                pass

        partitions.sort()
        return partitions

    def get_dbus(self,bus_type,obj,path,interface,method,arg):
        if bus_type == "session":
            bus = dbus.SessionBus() 
        if bus_type == "system":
            bus = dbus.SystemBus()
        proxy = bus.get_object(obj,path)
        method = proxy.get_dbus_method(method,interface)
        if arg:
            return method(arg)
        else:
            return method()

    def get_dbus_property(self,bus_type,obj,path,iface,prop):

        if bus_type == "session":
           bus = dbus.SessionBus()
        if bus_type == "system":
           bus = dbus.SystemBus()
        proxy = bus.get_object(obj,path)
        aux = 'org.freedesktop.DBus.Properties'
        props_iface = dbus.Interface(proxy,aux)
        props = props_iface.Get(iface,prop)
        return props

    def make_alias(self,*args):
        partitions = [ i[0] for i in self.get_partitions() ]

        combo_values = '|'.join(partitions)
        #print(combo_values)
        command=[ 'zenity','--forms','--title','Make Alias',
                  '--add-combo','Partition','--combo-values',
                  combo_values,'--add-entry','Alias'    ]        
        user_input = self.run_cmd(command)
        if not user_input: return

        alias = user_input.decode().strip().split('|')

        existing_values = None

        if os.path.isfile(self.config_file):
            with open(self.config_file) as conf_file:
                try:
                    existing_values = json.load(conf_file)
                except ValueError:
                    pass


        with open(self.config_file,'w') as conf_file:
             if existing_values:
                 existing_values[alias[0]] = alias[1]
             else:
                 existing_values = {alias[0]:alias[1]}

             #print(existing_values)
             json.dump(existing_values,conf_file,indent=4,sort_keys=True)


    def find_alias(self,part):
        if os.path.isfile(self.config_file):
            with open(self.config_file) as conf_file:
                try:
                    aliases = json.load(conf_file)
                except ValueError:
                    pass
                else:
                    if part in aliases:
                       return aliases[part]
                    else:
                       return None

    def toggle_auto_startup(self,*args):
        user_home = os.path.expanduser('~')
        desktop_file = '.config/autostart/udisks-indicator.desktop'
        full_path = os.path.join(user_home,desktop_file)

        if os.path.exists(full_path):
           os.unlink(full_path)
        else:
           original = '/usr/share/applications/udisks-indicator.desktop'
           if os.path.exists(original):
               shutil.copyfile(original,full_path)

        self.make_menu()


    def open_mountpoint(self,*args):
        pid = subprocess.Popen(['xdg-open',args[-1]]).pid

    def open_disks_utility(self,*args):
        pid = subprocess.Popen(['gnome-disks']).pid

    def run_cmd(self, cmdlist):
        """ Reusable function for running external commands """
        new_env = dict(os.environ)
        new_env['LC_ALL'] = 'C'
        try:
            stdout = subprocess.check_output(cmdlist, env=new_env)
        except subprocess.CalledProcessError:
            pass
        else:
            if stdout:
                return stdout

    def run(self):
        """ Launches the indicator """
        try:
            gtk.main()
        except KeyboardInterrupt:
            pass

    def quit(self, data=None):
        """ closes indicator """
        gtk.main_quit()

def main():
    """ defines program entry point """
    indicator = UdisksIndicator()
    indicator.run()

if __name__ == '__main__':
    main()

Das /usr/share/applications/udisks-indicator.desktop

[Desktop Entry]
Version=1.0
Name=Udisks Indicator
Comment=Indicator for reporting partition information
Exec=udisks-indicator
Type=Application
Icon=drive-harddisk-symbolic.svg
Terminal=false

Zusätzliche Information:

Ubuntu Mate 16.04 Test:

Gnome-Benutzer benötigen eine Erweiterung (KStatusNotifierItem / AppIndicator-Unterstützung), damit sich der Indikator ordnungsgemäß verhält:

Installieren Sie den Sysmonitor Indicator :

sudo add-apt-repository ppa:fossfreedom/indicator-sysmonitor
sudo apt-get update
sudo apt-get install indicator-sysmonitor

und es hat die Option "Verfügbarer Speicherplatz im Dateisystem".

Es gibt eine andere Antwort mit dem grundlegenden Sysmonitor-Indikator, aber Sie können Ihr eigenes benutzerdefiniertes Bedienfeld mit so vielen Informationen erstellen, wie Sie möchten .

Google (zumindest gut suchen) ist dein Freund

Der erste Schritt besteht darin, herauszufinden, wie der Prozentsatz der Partitionsnutzung berechnet wird :

$ percentage=($(df -k --output=pcent /dev/sda1))
$ echo "${percentage[1]}"
13%

Erstellen Sie ein Bash-Skript, um das Panel wiederzugeben

Hier ist ein Bash-Skript, das als "benutzerdefinierte" Option in Sysmonitor Indicator verwendet werden kann . Es wird der Prozentsatz angezeigt, der für die ersten drei Partitionen verwendet wurde /dev/sda:

#!/bin/bash
echo "sda1: "
percentage=($(df -k --output=pcent /dev/sda1))
echo "${percentage[1]}"
echo " | sda2: "
percentage=($(df -k --output=pcent /dev/sda2))
echo "${percentage[1]}"
echo " | sda3: "
percentage=($(df -k --output=pcent /dev/sda3))
echo "${percentage[1]}"

Beispielausgabe

Beim Laufen sieht es so aus:

Installieren und konfigurieren Sie benutzerdefinierte Skripts in Sysmonitor Indicator

Ausführliche Anweisungen zum Installieren von Sysmonitor Indicator und zum Zuweisen eines benutzerdefinierten Skripts finden Sie in dieser Antwort: Kann BASH in Systray als Anwendungsindikator angezeigt werden?