1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
|
#
# Copyright (C) 2017 Codethink Limited
#
# This program 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 of the License, or (at your option) any later version.
#
# This library 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 this library. If not, see <http://www.gnu.org/licenses/>.
#
# Authors:
# Tristan Van Berkom <tristan.vanberkom@codethink.co.uk>
import os
import signal
import time
import sys
from contextlib import contextmanager
from multiprocessing import Process
from .fuse import FUSE
from .._exceptions import ImplError
from .. import _signals
# Just a custom exception to raise here, for identifying possible
# bugs with a fuse layer implementation
#
class FuseMountError(Exception):
pass
# This is a convenience class which takes care of synchronizing the
# startup of FUSE and shutting it down.
#
# The implementations / subclasses should:
#
# - Overload the instance initializer to add any parameters
# needed for their fuse Operations implementation
#
# - Implement create_operations() to create the Operations
# instance on behalf of the superclass, using any additional
# parameters collected in the initializer.
#
# Mount objects can be treated as contextmanagers, the volume
# will be mounted during the context.
#
# UGLY CODE NOTE:
#
# This is a horrible little piece of code. The problem we face
# here is that the highlevel libfuse API has fuse_main(), which
# will either block in the foreground, or become a full daemon.
#
# With the daemon approach, we know that the fuse is mounted right
# away when fuse_main() returns, then the daemon will go and handle
# requests on its own, but then we have no way to shut down the
# daemon.
#
# With the blocking approach, we still have it as a child process
# so we can tell it to gracefully terminate; but it's impossible
# to know when the mount is done, there is no callback for that
#
# The solution we use here without digging too deep into the
# low level fuse API, is to fork a child process which will
# fun the fuse loop in foreground, and we block the parent
# process until the volume is mounted with a busy loop with timeouts.
#
class Mount():
# These are not really class data, they are
# just here for the sake of having None setup instead
# of missing attributes, since we do not provide any
# initializer and leave the initializer to the subclass.
#
__mountpoint = None
__operations = None
__process = None
################################################
# User Facing API #
################################################
def __init__(self, fuse_mount_options=None):
self._fuse_mount_options = {} if fuse_mount_options is None else fuse_mount_options
# mount():
#
# User facing API for mounting a fuse subclass implementation
#
# Args:
# (str): Location to mount this fuse fs
#
def mount(self, mountpoint):
assert self.__process is None
self.__mountpoint = mountpoint
self.__process = Process(target=self.__run_fuse)
# Ensure the child fork() does not inherit our signal handlers, if the
# child wants to handle a signal then it will first set its own
# handler, and then unblock it.
with _signals.blocked([signal.SIGTERM, signal.SIGTSTP, signal.SIGINT], ignore=False):
self.__process.start()
# This is horrible, we're going to wait until mountpoint is mounted and that's it.
while not os.path.ismount(mountpoint):
time.sleep(1 / 100)
# unmount():
#
# User facing API for unmounting a fuse subclass implementation
#
def unmount(self):
# Terminate child process and join
if self.__process is not None:
self.__process.terminate()
self.__process.join()
# Report an error if ever the underlying operations crashed for some reason.
if self.__process.exitcode != 0:
raise FuseMountError("{} reported exit code {} when unmounting"
.format(type(self).__name__, self.__process.exitcode))
self.__mountpoint = None
self.__process = None
# mounted():
#
# A context manager to run a code block with this fuse Mount
# mounted, this will take care of automatically unmounting
# in the case that the calling process is terminated.
#
# Args:
# (str): Location to mount this fuse fs
#
@contextmanager
def mounted(self, mountpoint):
self.mount(mountpoint)
try:
with _signals.terminator(self.unmount):
yield
finally:
self.unmount()
################################################
# Abstract Methods #
################################################
# create_operations():
#
# Create an Operations class (from fusepy) and return it
#
# Returns:
# (Operations): A FUSE Operations implementation
def create_operations(self):
raise ImplError("Mount subclass '{}' did not implement create_operations()"
.format(type(self).__name__))
################################################
# Child Process #
################################################
def __run_fuse(self):
# First become session leader while signals are still blocked
#
# Then reset the SIGTERM handler to the default and finally
# unblock SIGTERM.
#
os.setsid()
signal.signal(signal.SIGTERM, signal.SIG_DFL)
signal.pthread_sigmask(signal.SIG_UNBLOCK, [signal.SIGTERM])
# Ask the subclass to give us an Operations object
#
self.__operations = self.create_operations() # pylint: disable=assignment-from-no-return
# Run fuse in foreground in this child process, internally libfuse
# will handle SIGTERM and gracefully exit its own little main loop.
#
FUSE(self.__operations, self.__mountpoint, nothreads=True, foreground=True, nonempty=True,
**self._fuse_mount_options)
# Explicit 0 exit code, if the operations crashed for some reason, the exit
# code will not be 0, and we want to know about it.
#
sys.exit(0)
|
