파일 시스템 사용량 표시기


10

패널에서 파일 시스템 사용량 (파티션을위한 여유 공간 %)을 나타내는 적절한 유틸리티를 찾을 수 없습니다.

그리고 나는 나쁜 종류의 데스크탑 관리 도구를 설치하기를 기대하지 않고 간단한 표시기를 사용합니다.

모든 제안에 감사드립니다.


그것은 구현 될 수 있습니다. 어떻게 보이길 원하십니까? 장치 이름 /dev/sdb1과 그 사용법을 바로 옆에 파티션 하십시오. 퍼센트 또는 실제 기가 바이트?
Sergiy Kolodyazhnyy

차라리 HDD의 모든 파티션과 xternal HDD 또는 usb 저장 장치를 플러그인 할 때 사용자 정의 이름과 % 무료를 선호합니다.
Dinesh Kalidassan

사용자 정의 이름으로 무엇을 의미하는지 설명 할 수 있습니까? 드라이브의 이름을 지정 하시겠습니까?
Sergiy Kolodyazhnyy

/ dev / sdb1을 "Critical", "Entertainment"또는 "Official"등으로
언급하고 싶습니다

2
안녕 Dinesh, 당신이 찾고있는 (일반적으로) 답변 중 하나라도 제공한다면, 당신 그것을 받아 들일 수 있습니다. 나는 당신의 프로필에서 당신이 전에 대답을 받아들이지 않았다는 것을 알았습니다. 당신은 그것에 익숙하지 않을 수도 있습니다. 답변 중 하나라도 문제를 해결하는 경우 수락 하시겠습니까? (답변 옆의 위 / 아래 화살표 아래에있는 큰 V를 체크하십시오).
Jacob Vlijm

답변:


19

편집하다:

1. 새로운 답변

이 답변의 맨 아래에있는 답변을 사용할 수 있지만 (참조 [2.]) ppa추가 옵션이있는 버전이 환경 설정 창에서 설정됩니다.

여기에 이미지 설명을 입력하십시오

여기에 이미지 설명을 입력하십시오

옵션은 다음과 같습니다.

  • 하나의 창에서 모든 별칭 설정
  • 패널 아이콘의 테마 색상 설정 :

    여기에 이미지 설명을 입력하십시오여기에 이미지 설명을 입력하십시오여기에 이미지 설명을 입력하십시오여기에 이미지 설명을 입력하십시오

  • 경고 임계 값 설정
  • 알림에 새로 마운트 / 연결된 볼륨에 대한 정보 표시 :

    여기에 이미지 설명을 입력하십시오

  • 시작시 실행

또한 표시기는 이제 다른 배포자 (xfce와 같은)에 대해 더 작은 (너비) 아이콘 세트를 포함하며 창 관리자에 따라 자동으로 적용됩니다.

여기에 이미지 설명을 입력하십시오

설치하기 위해서:

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



2. 오래된 답변

아래 스크립트는 장치를 나열하고 사용법을 나타내는 표시기입니다. 정보는 10 초마다 한 번씩 업데이트됩니다 (필요한 경우).

여기에 이미지 설명을 입력하십시오

더욱이

  • 표시기가 실행되는 동안 아이콘에 표시 할 장치를 선택할 수 있습니다. 다음에 표시기를 실행할 때 장치가 기억됩니다.

    여기에 이미지 설명을 입력하십시오

    ! [여기에 이미지 설명 입력

    여기에 이미지 설명을 입력하십시오

  • 하나 이상의 (또는 모든) 장치의 경우 스크립트 헤드에서 대체 이름 ( "사용자 정의 이름")을 설정할 수 있습니다.

    예를 들면 다음과 같습니다.

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

    표시됩니다:

    여기에 이미지 설명을 입력하십시오

  • 당신은 임계 값을 설정할 수 있습니다 ; 장치 중 하나의 여유 공간이 그 아래에 있으면 경고가 표시됩니다.

    여기에 이미지 설명을 입력하십시오

  • 플러그 / 플러그 해제 된 장치는 10 초 내에 메뉴 목록에서 추가 / 제거됩니다.

스크립트

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

아이콘

여기에 이미지 설명을 입력하십시오 0.png

여기에 이미지 설명을 입력하십시오 1.png

여기에 이미지 설명을 입력하십시오 2.png

여기에 이미지 설명을 입력하십시오 3.png

여기에 이미지 설명을 입력하십시오 4.png

여기에 이미지 설명을 입력하십시오 5.png

여기에 이미지 설명을 입력하십시오 6.png

여기에 이미지 설명을 입력하십시오 7.png

여기에 이미지 설명을 입력하십시오 8.png

여기에 이미지 설명을 입력하십시오 9.png

여기에 이미지 설명을 입력하십시오 10.png

설정

설정은 간단합니다 :

  • 스크립트를 빈 파일로 복사하여 다른 이름으로 저장하십시오. showusage.py
  • 레이블에서 정확히 이름이 지정된 위의 아이콘을 스크립트와 동일한 디렉토리에 저장하십시오 (오른쪽 클릭> 다른 이름으로 저장).
  • 스크립트의 헤드 섹션에서 대체 이름 ( aliasses)을 설정하십시오 (가능한 ). 예 아래 :

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

    장치를 변경하지 않고 표시하려면 다음을 사용하십시오.

    alias = []

    ... 원하는 경우 임계 값을 변경하여 경고를 표시하십시오.

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

    그게 다야

그것을 실행

표시기를 사용하려면 다음 명령을 실행하십시오.

python3 /path/to/showusage.py

시작 응용 프로그램에 추가하려면 다음 명령을 사용하십시오.

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

애플리케이션 : 대시> 시작 애플리케이션> 추가를 선택하고 위 명령을 추가하십시오.


16

면책 조항 : 나는이 지표의 저자 이며이 특정 질문에 대해 작성되었습니다

2018 년 10 월 23 일 업데이트

이 표시기는 이제 네트워크 공유 목록을 지원 합니다 . mihaigalos 덕분에

2016 년 10 월 29 일 업데이트

표시기는 이제 마운트 해제 기능을 가지고 있으며, 같은 블록 장치 이름 대신 각 파티션의 UUID를 참조하여 별명을 고유하게 만들었습니다 sda1. 관련 버그 보고서를 참조하십시오

2016 년 10 월 8 일 업데이트

이 표시기는 현재 버전 2.0이며 몇 가지 기능이 추가되었으며 자체 PPA가 있습니다.

PPA에서 설치하려면 터미널에서 다음 단계를 사용하십시오.

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

릴리스 노트 에서 언급했듯이 기능은 다음과 같습니다.

  • 메뉴 항목 아이콘 : 각 파티션 / 장치에는 적절한 아이콘이 첨부되어 있습니다. 장치가 USB 디스크 인 경우 이동식 미디어 아이콘이 사용되고 iso 이미지 인 경우 광학 디스크 아이콘이 사용되며 하드 드라이브 / SSD 파티션에는 드라이브 아이콘이 있습니다.
  • 사용량은 이제 백분율 및 사람이 읽을 수있는 값 (제곱 1024)으로 표시됩니다.
  • 사용법 막대를 통한 사용법의 그래픽 표현 (아이디어 Salta 덕분에 큰 아이디어)
  • 기본 설정 대화 상자 : 사용자는 각 메뉴 항목마다보고 싶지 않은 특정 필드를 끌 수 있습니다. 이렇게하면 많은 양의 파티션이 연결된 경우 표시기 메뉴를 깨끗하게 유지할 수 있습니다. (Zacharee의 요청에 감사드립니다)
  • 텍스트 간격 : 기본 Ubuntu 글꼴 및 모노 스페이스 글꼴을 사용하면 텍스트 항목의 간격이 깔끔하게 보이고 정보의 가독성이 향상됩니다.
  • 파티션을 마운트 할 수없는 경우 알림 거품

아래는 기본 Ubuntu 아이콘 테마가있는 스크린 샷입니다. 여기에 이미지 설명을 입력하십시오

우분투 카일 린 아이콘 테마

여기에 이미지 설명을 입력하십시오

모든 옵션 필드를 끈 상태

여기에 이미지 설명을 입력하십시오

디자인 선택 및 추가 생각 :

이 지표를 만드는 과정에서 고급 사용자와 일반 사용자 모두에게 적합한 유틸리티를 구현하고자했습니다. 새로운 사용자가 명령 줄 도구를 처리 할 때 발생할 수있는 몇 가지 문제를 해결하려고했습니다. 또한이 유틸리티는 다목적을 지향합니다.

기본 설정 대화 상자를 사용하면 표시기를 사용자가 원하는대로 복잡하거나 간단하게 만들 수 있습니다. 또한 사용자의 상단 패널 공간을 너무 많이 차지하지 않도록 상단 패널에 레이블을 사용하지 않는 것이 특정 설계 결정이었습니다. 또한이 표시기는 파티션을 마운트하고 해당 디렉토리를 열 수있는 다목적 유틸리티가되도록 노력하고 있습니다. 디스크 사용 유틸리티뿐만 아니라 디렉토리를 빠르게 열 수있는 탐색 유틸리티로도 사용할 수 있습니다.

또한 사용자는 어느 파티션에 어떤 파티션이 있는지 알고있어 mount. 대신 데몬 udisksctl에서 정보를 얻는 것뿐만 아니라 그 목적으로도 UDisks2이름을 사용합니다. 수행하지 않는 유일한 작업은 마운트 해제 중이거나 Open Disks Utility메뉴 항목이 포함 된 이유 입니다.

원래 iStat menulet과 비슷하게 만들려고 노력했지만 프로젝트는이 목표에서 벗어났습니다. 지표는 디자인과 목적이 독특합니다. 많은 사용자에게 유용하고 Ubuntu 환경을 훨씬 더 즐겁게 만들기를 바랍니다.


udisks-indicator (원래 답변)

디스크 사용을 보여주기 위해 Unity 데스크탑이있는 Ubuntu 표시기 샘플 스크린 샷

개요

Ubuntu with Unity에 대한이 표시기를 사용하면 마운트 된 파티션에 대한 정보를 쉽게 볼 수 있습니다. OS X의 iStat Menu 3 메뉴와 시각적으로 유사하도록 노력합니다.

출품작은 다음과 같은 순서로 구성됩니다.

  • 분할
  • 별명 (사용자가 설정 한 경우)
  • 파티션이 속한 디스크 드라이브
  • 파티션의 마운트 지점 (디렉토리)
  • 사용률

각 파티션 항목을 클릭하면 기본 파일 관리자에서 파티션의 마운트 포인트가 열립니다

"Unmounted Partitions"메뉴에는 시스템에서 현재 마운트하지 않은 모든 파티션이 나열됩니다. 해당 하위 메뉴에서 항목을 클릭하면 해당 파티션이 일반적으로 /media/username/drive-id폴더에 자동으로 마운트됩니다

인디케이터는 시스템과 함께 제공된 기본 아이콘을 사용하므로 Unity Tweak Tool 또는 다른 방법을 사용하여 아이콘 테마를 변경하면 아이콘이 변경되어야합니다

참고 : "별칭으로 만들기"옵션을 통해 하나씩 여러 개의 별칭을 하나씩 추가하려는 경우 ~/.partition_aliases.json구성 파일 을 편집하면 됩니다. 형식은 다음과 같습니다.

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

설치

쉬운 설치를위한 PPA가 곧 제공 될 예정입니다. . .

그 동안 대체 단계는 다음과 같습니다.

  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

이 모든 단계는 멋진 작은 설치 스크립트에 넣을 수 있습니다.

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

소스 코드

이 표시기의 기본 기능을 갖춘 원본 소스 코드 (버전 v1.0)는 아래에서 찾을 수 있습니다. 최신 기능을 보려면 이 프로젝트의 GitHub 리포지토리를 확인하십시오 . 기능 요청 및 GitHub의 오류를보고하십시오.

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

그만큼 /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

추가 정보:

우분투 메이트 16.04 테스트 :

여기에 이미지 설명을 입력하십시오

그놈 사용자는 인디케이터가 올바르게 작동하도록 확장 (KStatusNotifierItem / AppIndicator 지원)이 필요합니다.

여기에 이미지 설명을 입력하십시오


1
확인할 수 있습니다. 이것은 Xfce4에서 작동합니다. 잘 했어요! =)
Terrance

@Terrance 최신 버전을 얻으려면 답변 업데이트를 참조하십시오. 이미 너무 자신에 Xfce 테스트 자크는 작동했다
세르지 Kolodyazhnyy

멋있는! 알려 주셔서 감사합니다. 나는 소용돌이를 줄 것이다. =) 업데이트 : 정말 좋아 보이고 아이콘 변경이 마음에 듭니다. 잘 했어! =)
Terrance

+1이지만 "PPA가 곧 출시 될 예정"이 제거 될 수 있다고 지적해야합니까?
WinEunuuchs2Unix

@ WinEunuuchs2Unix 예, 제거 할 수 있습니다. 이 답변과 표시 자체는 거대한 업데이트가 필요하지만 최근에는 시간이 필요 없습니다.
Sergiy Kolodyazhnyy

4

Sysmonitor 표시기 설치 :

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

"파일 시스템에서 사용 가능한 공간"옵션이 있습니다.


1

기본 Sysmonitor 표시기를 사용하는 또 다른 답변이 있지만 원하는만큼 많은 정보를 사용하여 사용자 정의 패널을 만들 수 있습니다.

Google (최소한 검색)은 당신의 친구입니다

첫 번째 단계는 파티션 사용률을 계산하는 방법을 알아내는 것입니다 .

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

bash 스크립트를 작성하여 패널에 에코

다음은 Sysmonitor 표시기 에서 "사용자 정의"옵션으로 사용하는 bash 스크립트 입니다. 다음의 첫 세 파티션에서 사용 된 백분율을 표시합니다 /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]}"

샘플 출력

실행하면 다음과 같습니다.

표시기 systmonitor example.png

Sysmonitor 표시기에서 사용자 지정 스크립트 설치 및 구성

Sysmonitor 표시기 설치 및 사용자 지정 스크립트 할당 에 대한 자세한 지침 은 다음 대답을 참조하십시오. BASH는 시스템 표시기에 응용 프로그램 표시기로 표시 될 수 있습니까?


사랑스러운 솔루션. 많은 파티션과 장치를 사용하면 시간이 오래 걸릴 수 있습니다
Sergiy Kolodyazhnyy
당사 사이트를 사용함과 동시에 당사의 쿠키 정책개인정보 보호정책을 읽고 이해하였음을 인정하는 것으로 간주합니다.
Licensed under cc by-sa 3.0 with attribution required.