Added configuration changes for Kerberos and passwordless SSH, and fixed some miscell...
[invirt/packages/invirt-console.git] / files / usr / bin / sipb-xen-consolefs
1 #!/usr/bin/python
2
3 import fuse
4 from fuse import Fuse
5
6 from time import time
7
8 import stat     # for file properties
9 import os         # for filesystem modes (O_RDONLY, etc)
10 import errno   # for error number codes (ENOENT, etc)
11                            # - note: these must be returned as negatives
12
13 from syslog import *
14
15 import sipb_xen_database
16
17 fuse.fuse_python_api = (0, 2)
18
19 realpath = "/home/machines/"
20
21 def 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
30 def 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
41 class 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
57 class 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
241 if __name__ == '__main__':
242         sipb_xen_database.connect('postgres://sipb-xen@sipb-xen-dev.mit.edu/sipb_xen')
243         usage="""
244 ConsoleFS [mount_path]
245 """
246         server = ConsoleFS()
247         server.flags = 0
248         server.main()