it-swarm.com.de

Dateisystem-Verwendungsindikator

Es ist mir nicht möglich, ein geeignetes Dienstprogramm zu finden, das nur die Dateisystemnutzung (% freier Speicherplatz für Partitionen) in der Kontrollleiste angibt.

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

Ich freue mich über alle Ihre Vorschläge.

10

BEARBEITEN:

1. NEUE ANTWORT

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

enter image description here

enter image description here

Zu den Optionen gehören:

  • Einstellen aller Aliase in einem Fenster
  • Festlegen der Themenfarben für das Bedienfeldsymbol:

    enter image description hereenter image description hereenter image description hereenter image description here

  • Einstellungsschwelle für Warnungen
  • Informationen zu neu gemounteten/verbundenen Volumes in einer Benachrichtigung anzeigen:

    enter image description here

  • 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.

enter image description here

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) alle zehn Sekunden aktualisiert.

enter image description here

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 Start der Anzeige gespeichert:

    enter image description here

    ![enter image description here

    enter image description here

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

    Als Beispiel ist dies:

    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:

    enter image description here

  • Sie können eine Schwelle setzen ; Wenn der freie Speicherplatz eines Ihrer Geräte darunter liegt, erhalten Sie eine Warnung:

    enter image description here

  • Gesteckte/nicht gesteckte Geräte werden innerhalb von 10 Sekunden zum Menülisten hinzugefügt/daraus entfernt.

Das Drehbuch

#!/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 Icons

enter image description here0.png

enter image description here1.png

enter image description here2.png

enter image description here3.png

enter image description here4.png

enter image description here5.png

enter image description here6.png

enter image description here7.png

enter image description here8.png

enter image description here9.png

enter image description here10.png

Einrichten

Das Einrichten ist einfach:

  • Kopieren Sie das Skript in eine leere Datei und speichern Sie es als showusage.py
  • Speichern Sie die obigen Symbole genau wie in ihrer Bezeichnung benannt 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 war's

Laufen es

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 Startup Applications hinzuzufügen:

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

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

19
Jacob Vlijm

haftungsausschluss: Ich bin Autor dieses Indikators und er ist für diese spezielle Frage geschrieben

Update 23. Oktober 2008

Der Indikator unterstützt jetzt Auflisten von Netzwerkfreigaben . Dank mihaigalos

Update 29. Oktober 2016

Der Indikator verfügt nun über eine Funktion zum Aufheben der Bereitstellung und Aliase wurden eindeutig gemacht, indem auf die UUID jeder Partition verwiesen wurde, anstatt den Gerätenamen wie sda1 zu blockieren. Siehe verwandter Fehlerbericht

Update, 8. Oktober 2016

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

Führen Sie die folgenden Schritte im Terminal aus, um von PPA aus zu installieren:

  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: Mit jeder Partition/jedem Gerät ist ein entsprechendes Symbol verbunden. Wenn das Gerät eine USB-Festplatte ist, 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 Festplatten-/SSD-Partitionen haben offensichtlich Laufwerkssymbole.
  • Die Verwendung wird jetzt in Prozent und für Menschen lesbaren Werten angezeigt (Potenzen von 1024).
  • Grafische Darstellung der Nutzung über die Nutzungsleiste (großes Dankeschön an Mateo Salta für die Idee)
  • Dialogfeld "Einstellungen": Benutzer können bestimmte Felder deaktivieren, die nicht für jeden Menüeintrag angezeigt werden sollen. Dies ermöglicht es, das Anzeigemenü sauber zu halten, wenn eine große Anzahl von Partitionen angeschlossen ist. (Dank Zacharees Bitte)
  • Textabstand: Bei Ubuntu-Standardschriftarten und Monospace-Schriftarten sind die Texteingaben gut verteilt, um ein saubereres Erscheinungsbild und eine bessere Lesbarkeit der Informationen zu erzielen.
  • Benachrichtigungsblasen für den Fall, dass die Partition nicht bereitgestellt werden kann

Unten ist der Screenshot mit dem Standard Ubuntu Icon Theme: enter image description here

Ubuntu Kylin Icon Theme

enter image description here

Mit allen optionalen Feldern aus

enter image description here

Designauswahl und zusätzliche Gedanken:

Bei der Erstellung dieses Indikators hatte ich gehofft, ein Dienstprogramm zu erhalten, das sowohl für fortgeschrittene als auch für gelegentliche Benutzer geeignet ist. Ich habe versucht, einige der Probleme zu beheben, die die neuen Benutzer möglicherweise beim Umgang mit Befehlszeilentools haben. Darüber hinaus ist das Dienstprogramm bestrebt, vielseitig einsetzbar zu sein.

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

Es ist für Benutzer auch praktisch zu wissen, welche Partition sich auf welcher Festplatte befindet, wodurch häufige Verwechslungen mit der Bereitstellung über Befehlszeilendienstprogramme wie mount vermieden werden. Stattdessen wird udisksctl für diesen Zweck verwendet (und die Informationen vom UDisks2 -Daemon abgerufen, daher die Benennung). Die einzige Aufgabe, die nicht ausgeführt wird, ist das Aufheben der Bereitstellung, und aus diesem Grund ist der Menüeintrag Open Disks Utility enthalten.

Während ich mich ursprünglich bemühte, es dem iStat-Menü ähnlich zu machen, ist das Projekt von diesem Ziel abgewichen - der Indikator ist einzigartig in seinem Design und Zweck. 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 Sample Screenshot

Überblick

Dieser Indikator für Ubuntu mit Unity ermöglicht die einfache Anzeige von Informationen über Ihre gemounteten Partitionen. Es ist bestrebt, dem iStat Menu 3-Menü von OS X optisch ähnlich zu sein.

Einträge sind in der Reihenfolge organisiert:

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

Wenn Sie auf jeden Partitionseintrag klicken, wird der Einhängepunkt der Partition im Standarddateimanager geöffnet

Das Menü "Nicht gemountete Partitionen" listet alle Partitionen auf, die derzeit nicht vom System gemountet sind. Wenn Sie in diesem Untermenü auf einen Eintrag klicken, wird diese Partition automatisch bereitgestellt, normalerweise im Ordner /media/username/drive-id

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

NOTE: Wenn Sie mehrere Aliase gleichzeitig hinzufügen möchten, können Sie dies über die Option "Make Alias" (Alias ​​erstellen) tun durch Bearbeiten der Konfigurationsdatei ~/.partition_aliases.json. Das Format ist wie folgt:

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

Installation

PPA für die 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

Alle 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 ursprüngliche Quellcode (Version v1.0) mit den grundlegenden Funktionen dieses Indikators ist unten aufgeführt. Die neuesten Funktionen finden Sie in GitHub-Repository für dieses Projekt . Bitte melden Sie alle Funktionsanfragen sowie Fehler auf GitHub.

Der /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 __== '__main__':
    main()

Der /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:

enter image description here

Gnome-Benutzer benötigen eine Erweiterung (KStatusNotifierItem/AppIndicator Support), damit sich der Indikator richtig verhält:

enter image description here

14

Install 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".

4
Bernmeister

Es gibt eine andere Antwort mit basic Sysmonitor Indicator , aber Sie können Ihr eigenes benutzerdefiniertes Panel mit so vielen Informationen erstellen, wie Sie möchten.

Google (zumindest bei der Suche) 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 wird. Es wird der Prozentsatz angezeigt, der in den ersten drei Partitionen von /dev/sda verwendet wird:

#!/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:

indicator systmonitor example.png

Installieren und konfigurieren Sie benutzerdefinierte Skripte in Sysmonitor Indicator

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

1