source: trunk/packages/sipb-xen-console/files/usr/bin/sipb-xen-consolefs @ 819

Last change on this file since 819 was 359, checked in by broder, 17 years ago

Added comments and changed to using the syslog module instead of print

  • Property svn:executable set to *
File size: 7.3 KB
Line 
1#!/usr/bin/python
2
3import fuse
4from fuse import Fuse
5
6from time import time
7
8import stat     # for file properties
9import os         # for filesystem modes (O_RDONLY, etc)
10import errno   # for error number codes (ENOENT, etc)
11                           # - note: these must be returned as negatives
12
13from syslog import *
14
15import sipb_xen_database
16
17fuse.fuse_python_api = (0, 2)
18
19realpath = "/home/machines/"
20
21def getDepth(path):
22        """
23        Return the depth of a given path, zero-based from root ('/')
24        """
25        if path == '/':
26                return 0
27        else:
28                return path.count('/')
29
30def getParts(path):
31        """
32        Return the slash-separated parts of a given path as a list
33        """
34        if path == '/':
35                return ['/']
36        else:
37                # [1:] because otherwise you get an empty list element from the
38                # initial '/'
39                return path[1:].split('/')
40
41class MyStat:
42        def __init__(self):
43                self.st_mode = 0
44                self.st_ino = 0
45                self.st_dev = 0
46                self.st_nlink = 0
47                self.st_uid = 0
48                self.st_gid = 0
49                self.st_size = 0
50                self.st_atime = 0
51                self.st_mtime = 0
52                self.st_ctime = 0
53       
54        def toTuple(self):
55                return (self.st_mode, self.st_ino, self.st_dev, self.st_nlink, self.st_uid, self.st_gid, self.st_size, self.st_atime, self.st_mtime, self.st_ctime)
56
57class ConsoleFS(Fuse):
58        """
59        ConsoleFS creates a series of subdirectories each mirroring the same real
60        directory, except for a single file - the .k5login - which is dynamically
61        generated for each subdirectory
62       
63        This filesystem only implements the getattr, getdir, read, and readlink
64        calls, beacuse this is a read-only filesystem
65        """
66       
67        def __init__(self, *args, **kw):
68                """Initialize the filesystem and set it to allow_other access besides
69                the user who mounts the filesystem (i.e. root)
70                """
71                Fuse.__init__(self, *args, **kw)
72                self.lasttime = time()
73                self.allow_other = 1
74               
75                openlog('sipb-xen-consolefs ', LOG_PID, LOG_DAEMON)
76               
77                syslog(LOG_DEBUG, 'Init complete.')
78       
79        def mirrorPath(self, path):
80                """Translate a virtual path to its real path counterpart"""
81                return realpath + "/".join(getParts(path)[1:])
82       
83        def getMachines(self):
84                """Get the list of VMs in the database, clearing the cache if it's
85                older than 15 seconds"""
86                if time() - self.lasttime > 15:
87                        self.lasttime = time()
88                        sipb_xen_database.clear_cache()
89                return [machine.name for machine in sipb_xen_database.Machine.select()]
90       
91        def getUid(self, machine_name):
92                """Calculate the UID of a machine-account, which is just machine_id+1000
93                """
94                return sipb_xen_database.Machine.get_by(name=machine_name).machine_id + 1000
95       
96        def getK5login(self, machine_name):
97                """Build the ACL for a machine and turn it into a .k5login file
98                """
99                machine = sipb_xen_database.Machine.get_by(name=machine_name)
100                users = [acl.user for acl in machine.acl]
101                return "\n".join(map(self.userToPrinc, users) + [''])
102       
103        def userToPrinc(self, user):
104                """Convert Kerberos v4-style names to v5-style and append a default
105                realm if none is specified
106                """
107                if '@' in user:
108                        (princ, realm) = user.split('@')
109                else:
110                        princ = user
111                        realm = "ATHENA.MIT.EDU"
112               
113                return princ.replace('.', '/') + '@' + realm
114       
115        def getattr(self, path):
116                """
117                - st_mode (protection bits)
118                - st_ino (inode number)
119                - st_dev (device)
120                - st_nlink (number of hard links)
121                - st_uid (user ID of owner)
122                - st_gid (group ID of owner)
123                - st_size (size of file, in bytes)
124                - st_atime (time of most recent access)
125                - st_mtime (time of most recent content modification)
126                - st_ctime (platform dependent; time of most recent metadata change on Unix,
127                                        or the time of creation on Windows).
128                """
129               
130                syslog(LOG_DEBUG, "*** getattr: " + path)
131               
132                depth = getDepth(path)
133                parts = getParts(path)
134               
135                st = MyStat()
136                # / is a directory
137                if path == '/':
138                        st.st_mode = stat.S_IFDIR | 0755
139                        st.st_nlink = 2
140                # /foo is a directory if foo is a machine - otherwise it doesn't exist
141                elif depth == 1:
142                        if parts[-1] in self.getMachines():
143                                st.st_mode = stat.S_IFDIR | 0755
144                                st.st_nlink = 2
145                                # Homedirs should be owned by the user whose homedir it is
146                                st.st_uid = st.st_gid = self.getUid(parts[0])
147                        else:
148                                return -errno.ENOENT
149                # Catch the .k5login file, because it's a special case
150                elif depth == 2 and parts[-1] == '.k5login':
151                        st.st_mode = stat.S_IFREG | 0444
152                        st.st_nlink = 1
153                        st.st_size = len(self.getK5login(parts[0]))
154                        # The .k5login file should be owned by the user whose homedir it is
155                        st.st_uid = st.st_gid = self.getUid(parts[0])
156                # For anything else, we get the mirror path and call out to the OS
157                else:
158                        stats = list(os.lstat(self.mirrorPath(path)))
159                        # Shadow the UID and GID from the original homedir
160                        stats[4:6] = [self.getUid(parts[0])] * 2
161                        return tuple(stats)
162                return st.toTuple()
163       
164        # This call isn't actually used in the version of Fuse on console, but we
165        # wanted to leave it implemented to ease the transition in the future
166        def readdir(self, path, offset):
167                """Return a generator with the listing for a directory
168                """
169                syslog(LOG_DEBUG, '*** readdir %s %s' % (path, offset))
170                for (value, zero) in self.getdir(path):
171                        yield fuse.Direntry(value)
172       
173        def getdir(self, path):
174                """Return a list of tuples of the form (item, 0) with the contents of
175                the directory path
176               
177                Fuse doesn't add '.' or '..' on its own, so we have to
178                """
179                syslog(LOG_DEBUG, '*** getdir %s' % path)
180               
181                # '/' contains a directory for each machine
182                if path == '/':
183                        contents = self.getMachines()
184                # The directory for each machine contains the same files as the realpath
185                # but also the .k5login
186                #
187                # The list is converted to a set so that we can handle the case where
188                # there is already a .k5login in the realpath gracefully
189                elif getDepth(path) == 1:
190                        contents = set(os.listdir(self.mirrorPath(path)) + ['.k5login'])
191                # If it's not the root of the homedir, just pass the call onto the OS
192                # for realpath
193                else:
194                        contents = os.listdir(self.mirrorPath(path))
195                # Format the list the way that Fuse wants it - and don't forget to add
196                # '.' and '..'
197                return [(i, 0) for i in (list(contents) + ['.', '..'])]
198       
199        def read(self, path, length, offset):
200                """Read length bytes starting at offset of path. In most cases, this
201                just gets passed on to the OS
202                """
203                syslog(LOG_DEBUG, '*** read %s %s %s' % (path, length, offset))
204               
205                parts = getParts(path)
206               
207                # If the depth is less than 2, then either it's a directory or the file
208                # doesn't exist
209                # (realistically this doesn't appear to ever happen)
210                if getDepth(path) < 2:
211                        return -errno.ENOENT
212                # If we're asking for a real .k5login file, then create it and return
213                # the snippet requested
214                elif parts[1:] == ['.k5login']:
215                        if parts[0] not in self.getMachines():
216                                return -errno.ENOENT
217                        else:
218                                return self.getK5login(parts[0])[offset:length + offset]
219                # Otherwise, pass the call onto the OS
220                # (note that the file will get closed when this call returns and the
221                # file descriptor goes out of scope)
222                else:
223                        fname = self.mirrorPath(path)
224                        if not os.path.isfile(fname):
225                                return -errno.ENOENT
226                        else:
227                                f = open(fname)
228                                f.seek(offset)
229                                return f.read(length)
230       
231        def readlink(self, path):
232                syslog(LOG_DEBUG, '*** readlink %s' % path)
233               
234                # There aren't any symlinks here
235                if getDepth(path) < 2:
236                        return -errno.ENOENT
237                # But there might be here
238                else:
239                        return os.readlink(self.mirrorPath(path))
240
241if __name__ == '__main__':
242        sipb_xen_database.connect('postgres://sipb-xen@sipb-xen-dev.mit.edu/sipb_xen')
243        usage="""
244ConsoleFS [mount_path]
245"""
246        server = ConsoleFS()
247        server.flags = 0
248        server.main()
Note: See TracBrowser for help on using the repository browser.