Saya tidak dapat menemukan utilitas yang sesuai untuk hanya menunjukkan penggunaan sistem file (% ruang bebas untuk partisi) pada panel.

Dan saya tidak berharap untuk menginstal segala jenis alat manajemen desktop yang buruk, tetapi indikator sederhana.

Saya menghargai semua saran Anda.

EDIT:

1. JAWABAN BARU

Sementara jawaban di bagian bawah yang satu ini dapat digunakan (lihat [2.]), itu mengarah ke ppa-versi dengan opsi tambahan, yang akan diatur dalam jendela preferensi.

Opsi meliputi:

• Menyetel semua alias dalam satu jendela

• Mengatur warna tema untuk ikon panel:

  

• Menetapkan ambang batas untuk peringatan

• Tampilkan info tentang volume yang baru dipasang / terhubung dalam pemberitahuan:

  

• Jalankan saat Startup

Selain itu, indikator sekarang termasuk ikon yang lebih kecil (lebar) yang ditetapkan untuk distro lain (seperti xfce), yang akan diterapkan secara otomatis, tergantung pada manajer jendela.

Untuk memasang:

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

2. JAWABAN TUA

Skrip di bawah ini adalah indikator yang mencantumkan perangkat Anda dan menunjukkan penggunaannya. Informasi ini diperbarui (jika perlu) sekali per sepuluh detik.

Selanjutnya

• Saat indikator sedang berjalan, Anda dapat memilih perangkat untuk diwakili dalam ikon. Perangkat akan diingat pada saat Anda menjalankan indikator berikutnya:

  

  

  

• Untuk satu atau lebih (atau semua) perangkat, Anda dapat mengatur nama alternatif ("nama khusus"), yang akan ditetapkan di kepala skrip

  Sebagai contoh, ini:

  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"],
      ]
  

  Akan menunjukkan:

  

• Anda dapat menetapkan ambang ; jika ruang kosong salah satu perangkat Anda di bawah itu, Anda akan mendapatkan peringatan:

  

• Perangkat yang dicolokkan / dicabut akan ditambahkan / dihapus dari menulist dalam 10 detik.

Naskah

#!/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()

Ikon

0.png

1.png

2.png

3.png

4.png

5.png

6.png

7.png

8.png

9.png

10.png

Pengaturan

Pengaturannya sederhana:

• Salin skrip ke file kosong, simpan sebagai showusage.py
• Simpan ikon di atas, yang dinamai persis dengan labelnya , ke dalam satu dan direktori yang sama dengan skrip (klik kanan> Simpan sebagai)

• Di kepala naskah, setel (mungkin) nama alternatif ( aliasses). Di bawah ini sebuah contoh:

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

  Jika Anda ingin menampilkan perangkat tidak berubah, gunakan:

  alias = []

  ... dan jika Anda mau, ubah ambang untuk menampilkan peringatan:

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

  Itu dia

Lari itu

Untuk menggunakan indikator, jalankan perintah:

python3 /path/to/showusage.py

Untuk menambahkannya ke Aplikasi Startup, gunakan perintah:

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

Pilih Aplikasi: Dash> Aplikasi Startup> Tambah, tambahkan perintah di atas.

_{disclaimer: Saya penulis indikator ini dan ditulis untuk pertanyaan spesifik ini}

Perbarui 23 Okt.2018

Indikator sekarang mendukung listing jaringan berbagi . Terima kasih untuk mihaigalos

Pembaruan 29 Okt 2016

Indikator sekarang memiliki fungsi unmount dan alias dibuat unik dengan merujuk UUID setiap partisi alih-alih memblokir nama perangkat seperti sda1. Lihat laporan bug terkait

Pembaruan, 8 Oktober 2016

Indikator sekarang dalam versi 2.0, telah menambahkan beberapa fitur dan memiliki PPA sendiri.

Untuk menginstal dari PPA, gunakan langkah-langkah berikut di terminal:

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

Seperti disebutkan dalam catatan rilis , fitur-fiturnya meliputi:

• Ikon untuk entri menu: setiap partisi / perangkat memiliki ikon yang sesuai. Jika perangkat adalah disk usb, ikon media yang dapat dilepas digunakan, jika itu adalah image iso - ikon disk optik digunakan, dan jelas partisi hard drive / SSD memiliki ikon drive.
• Penggunaan sekarang ditampilkan dalam persentase dan nilai yang dapat dibaca manusia (kekuatan 1024).
• Representasi grafis penggunaan melalui bilah penggunaan (terima kasih banyak kepada Mateo Salta untuk idenya)
• Dialog preferensi: pengguna dapat mematikan bidang tertentu yang tidak ingin mereka lihat per setiap entri menu. Ini memungkinkan menjaga indikator menu tetap bersih jika ada banyak partisi yang terpasang. (Terima kasih atas permintaan Zacharee)
• Penspasian teks: dengan font default Ubuntu dan font Monospace, entri teks ditempatkan dengan baik agar terlihat lebih bersih dan meningkatkan keterbacaan informasi.
• Gelembung notifikasi pada partisi case tidak dapat dipasang

Di bawah ini adalah tangkapan layar dengan tema ikon Ubuntu default:

Tema ikon Ubuntu Kylin

Dengan semua bidang opsional tidak aktif

Pilihan desain dan pemikiran tambahan:

Dalam pembuatan indikator ini, saya berharap untuk mencapai utilitas yang cocok untuk pengguna tingkat lanjut dan kasual. Saya mencoba untuk mengatasi beberapa masalah yang saya perhatikan yang mungkin dimiliki pengguna baru dengan menangani alat baris perintah. Selain itu, utilitas berusaha untuk menjadi multiguna.

Dialog Preferensi memungkinkan membuat indikator serumit dan / atau sesederhana yang diinginkan pengguna. Itu juga merupakan keputusan desain khusus untuk menghindari label pada panel atas sehingga tidak memakan terlalu banyak ruang panel atas pengguna. Selain itu, indikator ini berusaha untuk menjadi utilitas multiguna yang memungkinkan pemasangan partisi serta membuka direktori masing-masing. Ini dapat digunakan tidak hanya sebagai utilitas penggunaan disk, tetapi juga sebagai utilitas navigasi untuk membuka direktori dengan cepat.

Juga mudah bagi pengguna untuk mengetahui partisi mana yang mendiami disk mana, sehingga menghindari kerancuan dengan pemasangan melalui utilitas baris perintah seperti mount. Alih-alih ia menggunakan udisksctluntuk tujuan itu (serta mendapatkan informasi dari UDisks2daemon, maka penamaan). Satu-satunya tugas yang tidak dilakukan adalah melepas, dan atau alasan Open Disks Utilitymasuknya menu ini.

Walaupun awalnya saya berusaha untuk membuatnya mirip dengan iStat menulet, proyek ini berbeda dari tujuan ini - indikatornya unik dalam desain dan tujuannya. Saya harap ini akan bermanfaat bagi banyak pengguna dan membuat pengalaman Ubuntu mereka jauh lebih menyenangkan.

udisks-indicator (jawaban asli)

Indikator untuk Ubuntu dengan desktop Unity untuk menunjukkan penggunaan disk

Gambaran

Indikator untuk Ubuntu dengan Unity ini memungkinkan Anda dengan mudah melihat informasi tentang partisi yang Anda pasang. Ini berusaha untuk secara visual mirip dengan Menu iStat 3 menulet dari OS X.

Entri disusun dalam urutan:

• Partisi
• Alias ​​(jika ditetapkan oleh pengguna)
• Disk Drive tempat partisi tersebut berada
• Mountpoint dari partisi (direktori)
• % Penggunaan

Mengklik pada setiap entri partisi akan membuka mountpoint partisi di manajer file default

Menu "Partisi Tidak Diisi" daftar semua partisi yang saat ini tidak dipasang oleh sistem. Mengklik entri apa pun di submenu itu akan memasang partisi itu secara otomatis, biasanya ke /media/username/drive-idfolder

Indikator menggunakan ikon default yang disediakan dengan sistem, sehingga ikon harus berubah saat Anda mengubah tema ikon menggunakan Unity Tweak Tool atau metode lain

CATATAN : jika Anda ingin menambahkan beberapa alias secara bersamaan, alih-alih satu per satu melalui opsi "Make Alias", Anda dapat melakukannya melalui pengeditan ~/.partition_aliases.jsonfile konfigurasi. Formatnya adalah sebagai berikut:

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

Instalasi

AKP untuk kemudahan instalasi akan segera hadir. . .

Sementara itu, berikut adalah langkah-langkah alternatif:

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

Semua langkah ini dapat dimasukkan ke dalam skrip instalasi kecil yang menyenangkan:

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

Kode sumber

Kode sumber asli (Versi v1.0) dengan fungsionalitas dasar indikator ini dapat ditemukan di bawah. Untuk fitur terbaru, periksa repositori GitHub untuk proyek ini . Silakan laporkan permintaan fitur apa pun serta kesalahan pada GitHub.

The /usr/bin/udisks-indicator:

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

#
# Author: Serg Kolo , contact: 1047481448@qq.com
# 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()

Itu /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

Informasi tambahan:

Tes Ubuntu Mate 16.04:

Pengguna Gnome memerlukan ekstensi (Dukungan KStatusNotifierItem / AppIndicator) untuk membuat indikator berperilaku dengan benar:

Pasang Indikator Sysmonitor :

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

dan memiliki opsi "Ruang yang Tersedia di Sistem File".

Ada jawaban lain menggunakan Indikator Sysmonitor dasar tetapi Anda dapat membuat panel kustom Anda sendiri dengan informasi sebanyak yang Anda suka.

Google (paling tidak mencari dengan baik) adalah teman Anda

Langkah pertama adalah mencari cara menghitung persentase penggunaan partisi :

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

Buat skrip bash untuk menggema ke panel

Berikut ini adalah skrip bash untuk digunakan sebagai opsi "custom" di Indikator Sysmonitor . Ini akan menampilkan persentase yang digunakan pada tiga partisi pertama pada /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]}"

Output sampel

Saat menjalankannya akan terlihat seperti ini:

Instal dan konfigurasikan skrip khusus di Indikator Sysmonitor

Untuk petunjuk terperinci tentang menginstal Indikator Sysmonitor dan menetapkan skrip khusus lihat jawaban ini: Dapatkah BASH ditampilkan dalam systray sebagai indikator aplikasi?