From c020663ff8fb093343c0497f926f0104cd181789 Mon Sep 17 00:00:00 2001
From: Marius Vollmer <mvollmer@redhat.com>
Date: Mon, 21 Aug 2017 10:57:01 +0300
Subject: [PATCH] storage: NFS clients

---
 pkg/storaged/client.js        |  86 +++++++++
 pkg/storaged/dialog.js        |   2 +
 pkg/storaged/index.html       | 120 +++++++++++-
 pkg/storaged/nfs-mounts.py    | 344 ++++++++++++++++++++++++++++++++++
 pkg/storaged/overview.js      | 261 ++++++++++++++++++++++++++
 pkg/storaged/storage.css      |  26 ++-
 test/verify/check-storage-nfs | 168 +++++++++++++++++
 test/verify/storagelib.py     |   4 +
 tools/cockpit.spec            |   2 +
 tools/debian/control          |   2 +
 10 files changed, 1011 insertions(+), 4 deletions(-)
 create mode 100755 pkg/storaged/nfs-mounts.py
 create mode 100755 test/verify/check-storage-nfs

diff --git a/pkg/storaged/client.js b/pkg/storaged/client.js
index fdc6e319c4a..1599c5d02e0 100644
--- a/pkg/storaged/client.js
+++ b/pkg/storaged/client.js
@@ -25,6 +25,9 @@
 
     var utils = require('./utils');
 
+    var nfs_mounts_py = require("raw!./nfs-mounts.py");
+    var pyinvoke = [ "sh", "-ec", "exec $(which python3 2>/dev/null || which python) $@", "--", "-" ];
+
     /* STORAGED CLIENT
      */
 
@@ -404,6 +407,89 @@
         return utils.compare_versions(this.manager.Version, version) < 0;
     };
 
+    /* NFS mounts
+     */
+
+    function nfs_mounts() {
+        var self = {
+            entries: [ ],
+
+            update_entry: update_entry,
+            add_entry: add_entry,
+            remove_entry: remove_entry,
+
+            entry_users: entry_users,
+
+            mount_entry: mount_entry,
+            unmount_entry: unmount_entry,
+            stop_and_unmount_entry: stop_and_unmount_entry,
+            stop_and_remove_entry: stop_and_remove_entry
+        };
+
+        function spawn_nfs_mounts(args) {
+            return cockpit.spawn(pyinvoke.concat(args),
+                                 { superuser: "try", err: "message" })
+                .input(nfs_mounts_py);
+        }
+
+        var buf = "";
+        spawn_nfs_mounts([ "monitor" ])
+            .stream(function (output) {
+                var lines;
+
+                buf += output;
+                lines = buf.split("\n");
+                buf = lines[lines.length-1];
+                if (lines.length >= 2) {
+                    self.entries = JSON.parse(lines[lines.length-2]);
+                    $(self).triggerHandler('changed');
+                }
+            }).
+            fail(function (error) {
+                if (error != "closed") {
+                    console.warn(error);
+                }
+            });
+
+        function update_entry(entry, new_fields) {
+            return spawn_nfs_mounts([ "update", JSON.stringify(entry), JSON.stringify(new_fields) ]);
+        }
+
+        function add_entry(fields) {
+            return spawn_nfs_mounts([ "add", JSON.stringify(fields) ]);
+        }
+
+        function remove_entry(entry) {
+            return spawn_nfs_mounts([ "remove", JSON.stringify(entry) ]);
+        }
+
+        function mount_entry(entry) {
+            return spawn_nfs_mounts([ "mount", JSON.stringify(entry) ]);
+        }
+
+        function unmount_entry(entry) {
+            return spawn_nfs_mounts([ "unmount", JSON.stringify(entry) ]);
+        }
+
+        function stop_and_unmount_entry(users, entry) {
+            var units = users.map(function (u) { return u.unit; });
+            return spawn_nfs_mounts([ "stop-and-unmount", JSON.stringify(units), JSON.stringify(entry) ]);
+        }
+
+        function stop_and_remove_entry(users, entry) {
+            var units = users.map(function (u) { return u.unit; });
+            return spawn_nfs_mounts([ "stop-and-remove", JSON.stringify(units), JSON.stringify(entry) ]);
+        }
+
+        function entry_users(entry) {
+            return spawn_nfs_mounts([ "users", JSON.stringify(entry) ]).then(JSON.parse);
+        }
+
+        return self;
+    }
+
+    client.nfs = nfs_mounts();
+
     function init_manager() {
         /* Storaged 2.6 and later uses the UDisks2 API names, but try the
          * older storaged API first as a fallback.
diff --git a/pkg/storaged/dialog.js b/pkg/storaged/dialog.js
index 0cf0c05b093..ca857e6cfa9 100644
--- a/pkg/storaged/dialog.js
+++ b/pkg/storaged/dialog.js
@@ -57,6 +57,8 @@
                 f.HasOptions = (f.Options.length > 0);
         });
 
+        if (def.Action && def.Action.Danger)
+            def.Action.DangerButton = true;
 
         function empty(obj) { return !obj || obj.length == 0; }
 
diff --git a/pkg/storaged/index.html b/pkg/storaged/index.html
index d945dff7ab4..ce13054dbd1 100644
--- a/pkg/storaged/index.html
+++ b/pkg/storaged/index.html
@@ -271,6 +271,109 @@ <h1 translatable="yes">The "storaged" API is not available on this system.</h1>
     </div>
   </script>
 
+  <script id="nfs-mounts-tmpl" type="x-template/mustache">
+    <div class="panel panel-default storage-mounts">
+      <div class="panel-heading">
+        <span class="pull-right">
+          {{#HasMounts}}
+          <button class="btn btn-default fa fa-check nfs-arm-button {{#armed}}active{{/armed}}"></button>
+          {{/HasMounts}}
+          <button class="btn btn-primary fa fa-plus" data-action="mount-add" ></button>
+        </span>
+        <span translatable="yes">NFS Mounts</span>
+      </div>
+      {{#HasMounts}}
+      <table class="table">
+        <thead>
+          <tr>
+            <th class="mount-name" translatable="yes">Server</th>
+            <th class="mount-point" translatable="yes">Mount Point</th>
+            {{#armed}}
+            <th class="mount-actions">&nbsp;</th>
+            {{/armed}}
+            {{^armed}}
+            <th class="mount-size-graph" translatable="yes">Size</th>
+            <th class="mount-size-number">&nbsp;</th>
+            {{/armed}}
+          </tr>
+        </thead>
+        <tbody>
+          {{#Mounts}}
+          <tr>
+            <td>
+              {{Server}} {{RemoteDir}}
+            </td>
+            <td>
+              {{MountPoint}}
+            </td>
+            {{#armed}}
+            <td class="text-right">
+              {{#IsMounted}}
+              <button translatable="yes" class="btn btn-default"
+                      data-action="mount-unmount" data-arg="{{action_arg}}">Unmount</button>
+              {{/IsMounted}}
+              {{^IsMounted}}
+              <button translatable="yes" class="btn btn-default"
+                      data-action="mount-mount" data-arg="{{action_arg}}">Mount</button>
+              {{/IsMounted}}
+              {{#CanEdit}}
+              <button class="btn btn-default pficon pficon-edit"
+                      data-action="mount-edit" data-arg="{{action_arg}}"></button>
+              <button class="btn btn-danger pficon pficon-delete"
+                      data-action="mount-remove" data-arg="{{action_arg}}"></button>
+              {{/CanEdit}}
+            </td>
+            {{/armed}}
+            {{^armed}}
+            {{#IsMounted}}
+            <td>
+              <div class="progress">
+                <div class="progress-bar {{#UsageCritical}}progress-bar-danger{{/UsageCritical}}"
+                     data-width="{{UsagePercent}}%">
+                </div>
+              </div>
+            </td>
+            <td class="usage-text">
+              {{UsageText}}
+            </td>
+            {{/IsMounted}}
+            {{^IsMounted}}
+            <td>
+              Not mounted
+            </td>
+            <td>
+            </td>
+            {{/IsMounted}}
+            {{/armed}}
+          </tr>
+          {{/Mounts}}
+        </tbody>
+      </table>
+      {{/HasMounts}}
+      {{^HasMounts}}
+      <div translatable="yes" class="empty-panel-text">No NFS mounts set up</div>
+      {{/HasMounts}}
+    </div>
+  </script>
+
+  <script id="nfs-users-tmpl" type="x-template/mustache">
+    <div>
+      <p>{{Description}}</p>
+      <div class="nfs-users-table">
+        <table>
+          <tbody>
+            {{#Users}}
+            <tr>
+              <td>{{unit}}</td>
+              <td>{{desc}}</td>
+            </tr>
+            {{/Users}}
+          </tbody>
+        </table>
+      </div>
+    </div>
+  </script>
+
   <script id="jobs-tmpl" type="x-template/mustache">
     {{#HasJobs}}
     <div class="panel panel-default">
@@ -335,6 +438,7 @@ <h1 translatable="yes">The "storaged" API is not available on this system.</h1>
       </div>
       <br/>
       <div id="mounts"></div>
+      <div id="nfs-mounts"></div>
       <div id="jobs"></div>
       <div class="panel panel-default cockpit-log-panel">
         <div class="panel-heading" translatable="yes">Storage Logs</div>
@@ -673,13 +777,14 @@ <h4 class="modal-title">{{Title}}</h4>
             </table>
             {{/HasMDRaidMembers}}
             {{/Blocking}}
+            {{{Body}}}
             <table class="form-table-ct">
               {{#Fields}}
               <tr>
                 {{#TextInput}}
                 <td class="top">{{Title}}</td>
                 <td>
-                  <input class="form-control" type="text" {{#Value}}value="{{.}}"{{/Value}} data-field={{.}}>
+                  <input class="form-control" {{#disabled}}disabled{{/disabled}} type="text" {{#Value}}value="{{.}}"{{/Value}} data-field={{.}}>
                 </td>
                 {{/TextInput}}
                 {{#PassInput}}
@@ -803,7 +908,7 @@ <h4 class="modal-title">{{Title}}</h4>
                 <td>
                   <div data-field={{.}} class="combobox-container">
                     <div class="input-group">
-                      <input autocomplete="false" class="combobox form-control" type="text" value={{Value}} />
+                      <input autocomplete="false" class="combobox form-control" type="text" {{#disabled}}disabled{{/disabled}} value={{Value}} />
                       <span class="form-control-feedback caret"></span>
                       <ul class="typeahead typeahead-long dropdown-menu">
                       </ul>
@@ -854,13 +959,22 @@ <h4 class="modal-title">{{Title}}</h4>
                 {{/MDRaidMembers}}
               </table>
               {{/HasMDRaidMembers}}
+              {{#HasUnits}}
+              <p translate>The filesystem is in use by system services or login sessions.<br>
+                Proceeding will stop these services and sessions.</p>
+              <table class="table table-bordered">
+                {{#Units}}
+                <tr><td><span class="pull-right">{{Name}}</span>{{Unit}}</td></tr>
+                {{/Units}}
+              </table>
+              {{/HasUnits}}
             </div>
             {{/Teardown}}
             {{#Action}}
             {{#Danger}}<div class="modal-footer-danger">{{.}}</div>{{/Danger}}
             <div class="spinner spinner-sm pull-left" hidden></div>
             <button class="btn btn-default" translatable="yes" data-action="cancel">Cancel</button>
-            <button class="btn {{#Danger}}btn-danger{{/Danger}}{{^Danger}}btn-primary{{/Danger}}"
+            <button class="btn {{#DangerButton}}btn-danger{{/DangerButton}}{{^DangerButton}}btn-primary{{/DangerButton}}"
                     data-action="apply">{{Title}}</button>
             {{/Action}}
             {{^Action}}
diff --git a/pkg/storaged/nfs-mounts.py b/pkg/storaged/nfs-mounts.py
new file mode 100755
index 00000000000..11bd710d6f1
--- /dev/null
+++ b/pkg/storaged/nfs-mounts.py
@@ -0,0 +1,344 @@
+#! /usr/bin/python
+
+# nfs-mounts   --  Monitor and manage NFS mounts
+#
+# This is similar to how UDisks2 monitors and manages block device
+# mounts, but for NFS.  This might be moved into UDisks2, or not.
+
+import select
+import re
+import sys
+import json
+
+import os
+import ctypes
+import struct
+import subprocess
+import traceback
+
+# We monitor all NFS remotes listed in /etc/fstab and in /etc/mtab.
+# If a entry from mtab is also found in fstab, we report only the
+# fstab entry and mark it is "mounted".
+
+IN_CLOSE_WRITE = 0x00000008
+IN_IGNORED     = 0x00008000
+
+class Inotify:
+    def __init__(self):
+        self._libc = ctypes.CDLL(None, use_errno=True)
+        self._get_errno_func = ctypes.get_errno
+
+        self._libc.inotify_init.argtypes = []
+        self._libc.inotify_init.restype = ctypes.c_int
+        self._libc.inotify_add_watch.argtypes = [ctypes.c_int, ctypes.c_char_p,
+                                                 ctypes.c_uint32]
+        self._libc.inotify_add_watch.restype = ctypes.c_int
+        self._libc.inotify_rm_watch.argtypes = [ctypes.c_int, ctypes.c_int]
+        self._libc.inotify_rm_watch.restype = ctypes.c_int
+
+        self.fd = self._libc.inotify_init()
+
+    def add_watch(self, path, mask):
+        path = ctypes.create_string_buffer(path.encode(sys.getfilesystemencoding()))
+        wd = self._libc.inotify_add_watch(self.fd, path, mask)
+        if wd < 0:
+            sys.stderr.write("can't add watch for %s: %s\n" % (path, os.strerror(self._get_errno_func())))
+        return wd
+
+    def rem_watch(self, wd):
+        if self._libc.inotify_rm_watch(self.fd, wd) < 0:
+            sys.stderr.write("can't remove watch: %s\n" % (os.strerror(self._get_errno_func())))
+
+    def process(self, callback):
+        buf = os.read(self.fd, 4096)
+        pos = 0
+        while pos < len(buf):
+            (wd, mask, cookie, name_len) = struct.unpack('iIII', buf[pos:pos+16])
+            pos += 16
+            (name,) = struct.unpack('%ds' % name_len, buf[pos:pos + name_len])
+            pos += name_len
+            callback(wd, mask, name.decode().rstrip('\0'))
+
+class Watcher:
+    def __init__(self, path):
+        self.inotify = Inotify()
+        self.path = path
+        self.setup()
+
+    def setup(self):
+        self.wd = self.inotify.add_watch(self.path, IN_CLOSE_WRITE)
+
+    def process(self, callback = None):
+        def event(wd, mask, name):
+            if callback:
+                callback()
+            if mask & IN_IGNORED:
+                self.setup()
+        self.inotify.process(event)
+
+def field_escape(str):
+    return str.replace("\\", "\\134").replace(" ", "\\040").replace("\t", "\\011")
+
+def field_unescape(str):
+    return re.sub("\\\\([0-7]{1,3})", lambda m: chr(int(m.group(1), 8)), str)
+
+def parse_tab(name):
+    entries = [ ]
+    for line in open(name, "r").read().split("\n"):
+        sline = line.strip()
+        if sline == "" or sline[0] == "#":
+            continue
+        fields = list(map(field_unescape, re.split("[ \t]+", sline)))
+        if len(fields) > 0 and ":" in fields[0]:
+            entries.append(fields)
+    return entries
+
+def index_tab(tab):
+    by_remote = { }
+    for t in tab:
+        if not t[0] in by_remote:
+            by_remote[t[0]] = [ ]
+        by_remote[t[0]].append(t)
+    return by_remote
+
+def modify_tab(name, modify):
+    lines = open(name, "r").read().split("\n")
+    if len(lines) > 0 and lines[len(lines)-1] == "":
+        del lines[len(lines)-1]
+
+    new_lines = [ ]
+    for line in lines:
+        sline = line.strip()
+        if sline == "" or sline[0] == "#":
+            new_lines.append(line)
+        else:
+            fields = list(map(field_unescape, re.split("[ \t]+", sline)))
+            if len(fields) > 0 and ":" in fields[0]:
+                new_fields = modify(fields)
+                if new_fields:
+                    if new_fields == fields:
+                        new_lines.append(line)
+                    else:
+                        new_lines.append(" ".join(map(field_escape, new_fields)))
+            else:
+                new_lines.append(line)
+    new_fields = modify(None)
+    if new_fields:
+        new_lines.append(" ".join(map(field_escape, new_fields)))
+
+    f = open(name + ".tmp", "w")
+    f.write("\n".join(new_lines) + "\n")
+    f.flush()
+    os.fsync(f.fileno())
+    f.close()
+    os.rename(name + ".tmp", name)
+
+fstab = [ ]
+fstab_by_remote = { }
+
+mtab = [ ]
+mtab_by_remote = { }
+
+def process_fstab():
+    global fstab, fstab_by_remote
+    fstab = parse_tab("/etc/fstab")
+    fstab_by_remote = index_tab(fstab)
+
+def process_mtab():
+    global mtab, mtab_by_remote
+    mtab = parse_tab("/etc/mtab")
+    mtab_by_remote = index_tab(mtab)
+
+def find_in_tab(tab_by_remote, fields):
+    for t in tab_by_remote.get(fields[0], [ ]):
+        if t[0] == fields[0] and t[1] == fields[1]:
+            return t
+    return None
+
+def report():
+    data = [ ]
+    for f in fstab:
+        m = find_in_tab(mtab_by_remote, f)
+        data.append({ "fstab": True, "fields": f, "mounted": m is not None })
+    for m in mtab:
+        if not find_in_tab(fstab_by_remote, m):
+            data.append({ "fstab": False, "fields": m, "mounted": True })
+    sys.stdout.write(json.dumps(data) + "\n")
+    sys.stdout.flush()
+
+def monitor():
+    process_mtab()
+    process_fstab()
+    report()
+    fstab_watcher = Watcher("/etc/fstab")
+    mtab_file = open("/proc/mounts", "r")
+    while True:
+        (r, w, x) = select.select([ fstab_watcher.inotify.fd ], [ ], [ mtab_file ])
+        if mtab_file in x:
+            process_mtab()
+            report()
+        if fstab_watcher.inotify.fd in r:
+            fstab_watcher.process()
+            process_fstab()
+            report()
+
+def mkdir_if_necessary(path):
+    if not os.path.isdir(path):
+        os.makedirs(path)
+
+def rmdir_if_empty(path):
+    try:
+        os.rmdir(path)
+    except OSError as e:
+        if e.errno != errno.ENOTEMPTY:
+            raise
+
+def update(entry, new_fields):
+    old_fields = entry["fields"]
+    mkdir_if_necessary(new_fields[1])
+    modify_tab("/etc/fstab", lambda fields: new_fields if fields == old_fields else fields)
+    if entry["mounted"]:
+        if (new_fields[0] == old_fields[0]
+            and new_fields[1] == old_fields[1]
+            and new_fields[2] == old_fields[2]):
+            remount(new_fields)
+        else:
+            try:
+                unmount(entry)
+                rmdir_if_empty(old_fields[1])
+            except subprocess.CalledProcessError:
+                pass
+            mount({ "fields": new_fields })
+    else:
+        rmdir_if_empty(old_fields[1])
+
+def add(new_fields):
+    mkdir_if_necessary(new_fields[1])
+    modify_tab("/etc/fstab", lambda fields: new_fields if fields is None else fields)
+    mount({ "fields": new_fields })
+
+def remove(entry):
+    old_fields = entry["fields"]
+    if entry["mounted"]:
+        unmount(entry)
+    rmdir_if_empty(old_fields[1])
+    modify_tab("/etc/fstab", lambda fields: None if fields == old_fields else fields)
+
+def mount(entry):
+    fields = entry["fields"]
+    subprocess.check_call([ "mount",
+                            "-t", fields[2],
+                            "-o", fields[3],
+                            fields[0],
+                            fields[1] ])
+
+def remount(fields):
+    subprocess.check_call([ "mount",
+                            "-o", "remount," + fields[3],
+                            fields[0],
+                            fields[1] ])
+
+def unmount(entry):
+    subprocess.check_call([ "umount", entry["fields"][1] ])
+
+def fuser(entry):
+
+    import dbus
+    bus = dbus.SystemBus()
+    systemd_manager = dbus.Interface(bus.get_object('org.freedesktop.systemd1', '/org/freedesktop/systemd1'),
+                                     dbus_interface='org.freedesktop.systemd1.Manager')
+
+    if not entry["mounted"]:
+        return { }
+
+    mount_point = entry["fields"][1]
+    results = { }
+
+    def check(path, pid):
+        t = os.readlink(path)
+        if t == mount_point or t.startswith(mount_point + "/"):
+            unit = systemd_manager.GetUnitByPID(int(pid))
+            if unit not in results:
+                unit_obj = bus.get_object('org.freedesktop.systemd1', unit)
+                desc = unit_obj.Get("org.freedesktop.systemd1.Unit", "Description",
+                                    dbus_interface="org.freedesktop.DBus.Properties")
+                id = unit_obj.Get("org.freedesktop.systemd1.Unit", "Id",
+                                  dbus_interface="org.freedesktop.DBus.Properties")
+                results[unit] = { "unit": id, "desc": desc }
+            return True
+        return False
+
+    def checkdir(path, pid):
+        for f in os.listdir(path):
+            if check(os.path.join(path, f), pid):
+                return True
+        return False
+
+    my_pid = os.getpid()
+
+    for p in os.listdir("/proc/"):
+        if not p.isdigit():
+            continue
+        if int(p) == my_pid:
+            continue
+        proc = "/proc/%s/" % p
+        try:
+            if check(proc + "exe", p): continue
+            if check(proc + "root", p): continue
+            if check(proc + "cwd", p): continue
+            if checkdir(proc + "fd", p): continue
+            if checkdir(proc + "map_files", p): continue
+        except OSError:
+            pass
+
+    return list(results.values())
+
+def users(entry):
+    data = fuser(entry)
+    sys.stdout.write(json.dumps(data) + "\n")
+    sys.stdout.flush()
+
+def stop_units(units):
+    import dbus
+    bus = dbus.SystemBus()
+    systemd_manager = dbus.Interface(bus.get_object('org.freedesktop.systemd1', '/org/freedesktop/systemd1'),
+                                     dbus_interface='org.freedesktop.systemd1.Manager')
+    for u in units:
+        systemd_manager.StopUnit(u, 'replace')
+
+def stop_and_unmount(units, entry):
+    stop_units(units)
+    unmount(entry)
+
+def stop_and_remove(units, entry):
+    stop_units(units)
+    remove(entry)
+
+def dispatch(argv):
+    if argv[1] == "monitor":
+        monitor()
+    elif argv[1] == "update":
+        update(json.loads(argv[2]), json.loads(argv[3]))
+    elif argv[1] == "add":
+        add(json.loads(argv[2]))
+    elif argv[1] == "remove":
+        remove(json.loads(argv[2]))
+    elif argv[1] == "mount":
+        mount(json.loads(argv[2]))
+    elif argv[1] == "unmount":
+        unmount(json.loads(argv[2]))
+    elif argv[1] == "stop-and-unmount":
+        stop_and_unmount(json.loads(argv[2]), json.loads(argv[3]))
+    elif argv[1] == "stop-and-remove":
+        stop_and_remove(json.loads(argv[2]), json.loads(argv[3]))
+    elif argv[1] == "users":
+        users(json.loads(argv[2]))
+
+try:
+    dispatch(sys.argv)
+except subprocess.CalledProcessError as e:
+    sys.exit(e.returncode)
+except:
+    sys.stderr.write("".join(traceback.format_exception_only(sys.exc_info()[0], sys.exc_info()[1])))
+    sys.stderr.flush()
+    sys.exit(1)
diff --git a/pkg/storaged/overview.js b/pkg/storaged/overview.js
index 35991908e94..8f4f85eeb51 100644
--- a/pkg/storaged/overview.js
+++ b/pkg/storaged/overview.js
@@ -317,6 +317,266 @@
         $(client).on('changed', render_mounts);
         $(client.fsys_sizes).on('changed', render_mounts);
 
+        var nfs_mounts_tmpl = $("#nfs-mounts-tmpl").html();
+        mustache.parse(nfs_mounts_tmpl);
+
+        var nfs_users_tmpl = $("#nfs-users-tmpl").html();
+        mustache.parse(nfs_users_tmpl);
+
+        function render_nfs_mounts() {
+
+            function make_nfs_mount(entry, index) {
+                var fsys_size;
+                if (entry.mounted)
+                    fsys_size = client.fsys_sizes.data[entry.fields[1]];
+
+                return {
+                    Server: entry.fields[0].split(":")[0],
+                    RemoteDir: entry.fields[0].split(":")[1],
+                    UsageText: fsys_size? utils.format_fsys_usage(fsys_size[0], fsys_size[1]) : null,
+                    UsagePercent: fsys_size? fsys_size[0] / fsys_size[1] * 100 : null,
+                    UsageCritical: fsys_size && fsys_size[0] > 0.95 * fsys_size[1],
+                    MountPoint: entry.fields[1],
+                    IsMounted: entry.mounted,
+                    CanEdit: entry.fstab,
+                    action_arg: index
+                };
+            }
+
+            var m = client.nfs.entries.map(make_nfs_mount);
+
+            var is_armed = $('#nfs-mounts .nfs-arm-button').hasClass('active');
+            $('#nfs-mounts').amend(mustache.render(nfs_mounts_tmpl,
+                                                   { armed: is_armed,
+                                                     Mounts: m,
+                                                     HasMounts: m.length > 0
+                                                   }));
+
+            /* Apply these styles */
+            $('#nfs-mounts [data-width]').each(function() {
+                $(this).css("width", $(this).attr("data-width"));
+            });
+        }
+
+        $('#storage').on('click', '#nfs-mounts .nfs-arm-button', function (event) {
+            $(this).toggleClass('active');
+            render_nfs_mounts();
+        });
+
+        function nfs_disarm() {
+            $('#nfs-mounts .nfs-arm-button').removeClass('active');
+            render_nfs_mounts();
+        }
+
+        function checked(error_title, promise) {
+            promise.fail(function (error, output) {
+                $('#error-popup-title').text(error_title);
+                $('#error-popup-message').text(error.toString());
+                $('#error-popup').modal('show');
+            });
+        }
+
+        $('#storage').on('click', '[data-action="mount-mount"]', function () {
+            var arg = $(this).attr('data-arg');
+            var entry = client.nfs.entries[arg];
+            checked("Could not mount the filesystem",
+                    client.nfs.mount_entry(entry));
+            nfs_disarm();
+            return false;
+        });
+
+        function nfs_busy_dialog(dialog_title,
+                                 entry, error,
+                                 action_title, action) {
+
+            function show(users) {
+                dialog.open({ Title: dialog_title,
+                              Teardown: {
+                                  HasUnits: users.length > 0,
+                                  Units: users.map(function (u) { return { Unit: u.unit, Name: u.desc }; })
+                              },
+                              Fields: [ ],
+                              Action: users? {
+                                  DangerButton: true,
+                                  Title: action_title,
+                                  action: function () {
+                                      return action(users);
+                                  }
+                              } : null
+                            });
+            }
+
+            client.nfs.entry_users(entry)
+                .done(function (users) {
+                    show(users);
+                })
+                .fail(function (error) {
+                    show(null);
+                });
+        }
+
+        $('#storage').on('click', '[data-action="mount-unmount"]', function () {
+            var arg = $(this).attr('data-arg');
+            var entry = client.nfs.entries[arg];
+            client.nfs.unmount_entry(entry)
+                .fail(function (error) {
+                    nfs_busy_dialog(_("Unable to unmount filesystem"),
+                                    entry, error,
+                                    _("Stop and unmount"),
+                                    function (users) {
+                                        return client.nfs.stop_and_unmount_entry(users, entry);
+                                    });
+                });
+            nfs_disarm();
+            return false;
+        });
+
+        function nfs_fstab_dialog(entry) {
+
+            var server_to_check;
+            var server_check_deferred;
+
+            function remote_choices(vals) {
+                if (vals.server == server_to_check)
+                    return false;
+
+                server_to_check = vals.server;
+                if (server_check_deferred)
+                    server_check_deferred.resolve(false);
+
+                var this_deferred = cockpit.defer();
+                server_check_deferred = this_deferred;
+
+                cockpit.spawn([ "showmount", "-e", "--no-headers", server_to_check ], { err: "message" })
+                        .done(function (output) {
+                            if (this_deferred == server_check_deferred) {
+                                var dirs = [ ];
+                                output.split("\n").forEach(function (line) {
+                                    var d = line.split(" ")[0];
+                                    if (d)
+                                        dirs.push(d);
+                                });
+                                this_deferred.resolve(dirs);
+                                server_check_deferred = null;
+                            } else {
+                                this_deferred.resolve(false);
+                            }
+                        }).
+                        fail(function (error) {
+                            console.warn(error);
+                            this_deferred.resolve([ ]);
+                        });
+
+                return this_deferred.promise();
+            }
+
+            function show(busy) {
+                dialog.open({ Title: entry? _("NFS Mount") : _("New NFS Mount"),
+                              Alerts: busy? [ { Message: _("This NFS mount is in use and only its options can be changed.") } ] : null,
+                              Fields: [
+                                  { TextInput: "server",
+                                    Title: _("Server Address"),
+                                    Value: entry? entry.fields[0].split(":")[0] : "",
+                                    validate: function (val) {
+                                        if (val === "")
+                                            return _("Server cannot be empty.");
+                                    },
+                                    disabled: busy
+                                  },
+                                  { ComboBox: "remote",
+                                    Title: _("Path on Server"),
+                                    Value: entry? entry.fields[0].split(":")[1] : "",
+                                    Choices: remote_choices,
+                                    validate: function (val) {
+                                        if (val === "")
+                                            return _("Path on server cannot be empty.");
+                                        if (val[0] !== "/")
+                                            return _("Path on server must start with \"/\".");
+                                    },
+                                    disabled: busy
+                                  },
+                                  { TextInput: "dir",
+                                    Title: _("Local Mount Point"),
+                                    Value: entry? entry.fields[1] : "",
+                                    validate: function (val) {
+                                        if (val === "")
+                                            return _("Mount point cannot be empty.");
+                                        if (val[0] !== "/")
+                                            return _("Mount point must start with \"/\".");
+                                    },
+                                    disabled: busy
+                                  },
+                                  { TextInput: "opts",
+                                    Title: _("Mount Options"),
+                                    Value: entry? entry.fields[3] : "defaults",
+                                    validate: function (val) {
+                                        if (val === "")
+                                            return _("Options cannot be empty.");
+                                    }
+                                  }
+                              ],
+                              Action: {
+                                  Title: entry? _("Apply") : _("Add"),
+                                  action: function (vals) {
+                                      var fields = [ vals.server + ":" + vals.remote,
+                                                     vals.dir,
+                                                     entry? entry.fields[2]: "nfs",
+                                                     vals.opts ];
+
+                                      if (entry)
+                                          return client.nfs.update_entry(entry, fields);
+                                      else
+                                          return client.nfs.add_entry(fields);
+                                  }
+                              }
+                            });
+            }
+
+            if (entry) {
+                client.nfs.entry_users(entry)
+                    .done(function (users) {
+                        show(users.length > 0);
+                    })
+                    .fail(function () {
+                        show(false);
+                    });
+            } else
+                show(false);
+        }
+
+        $('#storage').on('click', '[data-action="mount-edit"]', function () {
+            var arg = $(this).attr('data-arg');
+            var entry = client.nfs.entries[arg];
+            if (entry)
+                nfs_fstab_dialog(entry);
+            nfs_disarm();
+            return false;
+        });
+
+        $('#storage').on('click', '[data-action="mount-add"]', function () {
+            nfs_fstab_dialog(null);
+            return false;
+        });
+
+        $('#storage').on('click', '[data-action="mount-remove"]', function () {
+            var arg = $(this).attr('data-arg');
+            var entry = client.nfs.entries[arg];
+            client.nfs.remove_entry(entry)
+                .fail(function (error) {
+                    nfs_busy_dialog(_("Unable to remove mount"),
+                                    entry, error,
+                                    _("Stop and remove"),
+                                    function (users) {
+                                        return client.nfs.stop_and_remove_entry(users, entry);
+                                    });
+                });
+            nfs_disarm();
+            return false;
+        });
+
+        $(client.nfs).on('changed', render_nfs_mounts);
+        $(client.fsys_sizes).on('changed', render_nfs_mounts);
+
         function render_jobs() {
             $('#jobs').amend(jobs.render());
             permissions.update();
@@ -400,6 +660,7 @@
         render_drives();
         render_others();
         render_mounts();
+        render_nfs_mounts();
         render_jobs();
 
         $('#storage-log').append(
diff --git a/pkg/storaged/storage.css b/pkg/storaged/storage.css
index 4191c9e1a85..d1a4cca411e 100644
--- a/pkg/storaged/storage.css
+++ b/pkg/storaged/storage.css
@@ -39,7 +39,7 @@
     text-overflow: ellipsis;
 }
 
-@media (min-width: 992px) {
+@media (max-width: 1200px) {
     .storage-mounts .mount-name {
         width: 25%;
     }
@@ -52,6 +52,9 @@
     .storage-mounts .mount-size-number {
         width: 25%;
     }
+    .storage-mounts .mount-actions {
+        width: 50%;
+    }
 }
 
 @media (min-width: 1200px) {
@@ -67,6 +70,13 @@
     .storage-mounts .mount-size-number {
         width: 15%;
     }
+    .storage-mounts .mount-actions {
+        width: 60%;
+    }
+}
+
+#nfs-mounts tr {
+    height: 42px;
 }
 
 @media (max-width: 1814px) {
@@ -545,6 +555,20 @@ td.storage-action {
     overflow: visible !important;
 }
 
+.nfs-users-table {
+    max-height: 200px;
+    overflow-y: auto;
+}
+
+.nfs-users-table table {
+    width: 100%;
+}
+
+.nfs-users-table td:nth-child(2) {
+    padding-left: 0.75em;
+    width: 80%;
+}
+
 /* Layout fix for tooltip arrows.
  *
  * Sometimes when there are non-integer coordinates involved
diff --git a/test/verify/check-storage-nfs b/test/verify/check-storage-nfs
new file mode 100755
index 00000000000..70cf70c199b
--- /dev/null
+++ b/test/verify/check-storage-nfs
@@ -0,0 +1,168 @@
+#!/usr/bin/python
+# -*- coding: utf-8 -*-
+
+# This file is part of Cockpit.
+#
+# Copyright (C) 2015 Red Hat, Inc.
+#
+# Cockpit is free software; you can redistribute it and/or modify it
+# under the terms of the GNU Lesser General Public License as published by
+# the Free Software Foundation; either version 2.1 of the License, or
+# (at your option) any later version.
+#
+# Cockpit is distributed in the hope that it will be useful, but
+# WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+# Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public License
+# along with Cockpit; If not, see <http://www.gnu.org/licenses/>.
+
+import parent
+from testlib import *
+from storagelib import *
+
+class TestStorage(StorageCase):
+    def testNfsClient(self):
+        m = self.machine
+        b = self.browser
+
+        self.login_and_go("/storage")
+        b.wait_in_text("#drives", "VirtIO")
+
+        m.execute("mkdir /home/foo /home/bar")
+        m.write("/etc/exports", "/home/foo 127.0.0.0/24(rw)\n/home/bar 127.0.0.0/24(rw)\n")
+        m.execute("systemctl restart nfs-server")
+
+        # Nothing there in the beginnging
+        b.wait_visible("#nfs-mounts .empty-panel-text")
+
+        # Add /home/foo
+        b.click("#nfs-mounts button[data-action=mount-add]")
+        self.dialog_wait_open()
+        self.dialog_set_val("server", "127.0.0.1")
+        self.dialog_set_combobox("remote", "/home/foo")
+        self.dialog_set_val("dir", "/mnt")
+        self.dialog_apply()
+        self.dialog_wait_close()
+
+        b.wait_present("#nfs-mounts td:contains(/home/foo)")
+        b.wait_present("#nfs-mounts td:contains(/mnt)")
+        b.wait_present("#nfs-mounts tr:contains(/mnt) .usage-text")
+        b.wait_text_not("#nfs-mounts tr:contains(/mnt) .usage-text", "")
+
+        # Add /home/bar
+        b.click("#nfs-mounts button[data-action=mount-add]")
+        self.dialog_wait_open()
+        self.dialog_set_val("server", "127.0.0.1")
+        self.dialog_set_combobox("remote", "/home/bar")
+        self.dialog_set_val("dir", "/mounts/bar")
+        self.dialog_apply()
+        self.dialog_wait_close()
+
+        b.wait_present("#nfs-mounts td:contains(/home/bar)")
+        b.wait_present("#nfs-mounts td:contains(/mounts/bar)")
+        b.wait_present("#nfs-mounts tr:contains(/mounts/bar) .usage-text")
+        b.wait_text_not("#nfs-mounts tr:contains(/mounts/bar) .usage-text", "")
+        m.execute("test -d /mounts/bar")
+
+        # Change mount point of /home/bar
+        b.click("#nfs-mounts .nfs-arm-button")
+        b.click("#nfs-mounts button[data-action=mount-edit][data-arg=1]")
+
+        self.dialog_wait_open()
+        self.dialog_set_val("dir", "/mounts/barbar")
+        self.dialog_apply()
+        self.dialog_wait_close()
+
+        b.wait_present("#nfs-mounts td:contains(/mounts/barbar)")
+        m.execute("! test -e /mounts/bar")
+        m.execute("test -d /mounts/barbar")
+
+        # Unmount and remount /home/foo
+        b.click("#nfs-mounts .nfs-arm-button")
+        b.click("#nfs-mounts button[data-action=mount-unmount][data-arg=0]")
+        b.wait_in_text("#nfs-mounts tr:contains(/home/foo)", "Not mounted")
+
+        b.click("#nfs-mounts .nfs-arm-button")
+        b.click("#nfs-mounts button[data-action=mount-mount][data-arg=0]")
+        b.wait_present("#nfs-mounts tr:contains(/mnt) .usage-text")
+        b.wait_text_not("#nfs-mounts tr:contains(/mnt) .usage-text", "")
+
+        # Remove /home/foo
+        b.click("#nfs-mounts .nfs-arm-button")
+        b.click("#nfs-mounts button[data-action=mount-remove][data-arg=0]")
+        b.wait_not_present("#nfs-mounts td:contains(/home/foo)")
+        m.execute("! test -e /mnt")
+
+    def testNfsListExports(self):
+        m = self.machine
+        b = self.browser
+
+        self.login_and_go("/storage")
+        b.wait_in_text("#drives", "VirtIO")
+
+        m.execute("mkdir /home/foo /home/bar")
+        m.write("/etc/exports", "/home/foo 127.0.0.0/24(rw)\n/home/bar 127.0.0.0/24(rw)\n")
+        m.execute("systemctl restart nfs-server")
+
+        b.click("#nfs-mounts button[data-action=mount-add]")
+        self.dialog_wait_open()
+        self.dialog_set_val("server", "127.0.0.1")
+
+        def wait_for_exports():
+            def check():
+                choices = self.dialog_combobox_choices("remote")
+                return len(choices) == 2 and "/home/foo" in choices and "/home/bar" in choices
+            self.retry(None, check, None)
+
+        wait_for_exports()
+
+    def testNfsBusy(self):
+        m = self.machine
+        b = self.browser
+
+        self.login_and_go("/storage")
+        b.wait_in_text("#drives", "VirtIO")
+
+        m.execute("mkdir /home/foo /home/bar")
+        m.write("/etc/exports", "/home/foo 127.0.0.0/24(rw)\n/home/bar 127.0.0.0/24(rw)\n")
+        m.execute("systemctl restart nfs-server")
+
+        # Nothing there in the beginnging
+        b.wait_visible("#nfs-mounts .empty-panel-text")
+
+        # Add /home/foo
+        b.click("#nfs-mounts button[data-action=mount-add]")
+        self.dialog_wait_open()
+        self.dialog_set_val("server", "127.0.0.1")
+        self.dialog_set_combobox("remote", "/home/foo")
+        self.dialog_set_val("dir", "/mounts/foo")
+        self.dialog_apply()
+        self.dialog_wait_close()
+
+        b.wait_present("#nfs-mounts td:contains(/home/foo)")
+        b.wait_present("#nfs-mounts td:contains(/mounts/foo)")
+        b.wait_present("#nfs-mounts tr:contains(/mounts/foo) .usage-text")
+        b.wait_text_not("#nfs-mounts tr:contains(/mounts/foo) .usage-text", "")
+
+        m.spawn("cd /mounts/foo; sleep infinity", "busy")
+        b.click("#nfs-mounts .nfs-arm-button")
+        b.click("#nfs-mounts button[data-action=mount-edit][data-arg=0]")
+
+        self.dialog_wait_open()
+        self.dialog_wait_alert("This NFS mount is in use")
+        self.dialog_cancel()
+        self.dialog_wait_close()
+
+        b.click("#nfs-mounts .nfs-arm-button")
+        b.click("#nfs-mounts button[data-action=mount-unmount][data-arg=0]")
+        self.dialog_wait_open()
+        b.wait_in_text("#dialog", "The filesystem can't be unmounted")
+        b.wait_in_text("#dialog", "of user root")
+        self.dialog_apply()
+
+        b.wait_in_text("#nfs-mounts tr:contains(/home/foo)", "Not mounted")
+
+if __name__ == '__main__':
+    test_main()
diff --git a/test/verify/storagelib.py b/test/verify/storagelib.py
index 866eef75163..c028bef64f6 100644
--- a/test/verify/storagelib.py
+++ b/test/verify/storagelib.py
@@ -207,6 +207,10 @@ def dialog_set_expander(self, field, val):
     def dialog_set_combobox(self, field, val):
         self.browser.set_val(self.dialog_field(field) + " input[type=text]", val)
 
+    def dialog_combobox_choices(self, field):
+        return self.browser.call_js_func("(function (sel) { return $(sel).find('li').get().map(function (elt) { return $(elt).text(); }) })",
+                                         self.dialog_field(field))
+
     def dialog_is_present(self, field, label):
         return self.browser.is_present('%s .checkbox:contains("%s") input' % (self.dialog_field(field), label))
 
diff --git a/tools/cockpit.spec b/tools/cockpit.spec
index bc468cc4822..7a4c87e0951 100644
--- a/tools/cockpit.spec
+++ b/tools/cockpit.spec
@@ -389,6 +389,8 @@ fi
 Summary: Cockpit user interface for storage, using Storaged
 Requires: %{name}-shell >= %{required_base}
 Requires: storaged >= 2.1.1
+Requires: python
+Requires: python-dbus
 %if 0%{?fedora} >= 24 || 0%{?rhel} >= 8
 Recommends: storaged-lvm2 >= 2.1.1
 Recommends: storaged-iscsi >= 2.1.1
diff --git a/tools/debian/control b/tools/debian/control
index 1d5b0e3615a..b5aa0ff0322 100644
--- a/tools/debian/control
+++ b/tools/debian/control
@@ -129,6 +129,8 @@ Architecture: all
 Depends: ${misc:Depends},
          udisks2 | storaged,
          cockpit-bridge (>= ${bridge:minversion}),
+         python3,
+         python3-dbus
 Description: Cockpit user interface for storage
  The Cockpit components for interacting with storage.