← Back to branch summary

~azzar1/unity/add-show-desktop-key

« back to all changes in this revision

Viewing changes to lib/common/makeuser.py

  • Committer: mattgiuca
  • Date: 2008-07-07 12:01:03 UTC
  • Revision ID: svn-v3-trunk0:2b9c9e99-6f39-0410-b283-7f802c844ae2:trunk:820
lib: Added new package pulldown_subj, a collection of modules designed to
    pull student subject enrolments from the server.
    Note that the actual code to do this is not included (since that is
    specific to the organisation running IVLE) - just a pluggable interface
    and an example plugin module.
configure.py: Added new config option: subject_pulldown_modules, which allows
    you to specify which modules are plugged in here.
    (Actually that was added accidentally in a previous commit; but this
    revision fixes some comments).

Show diffs side-by-side

added added

removed removed

Lines of Context:
lib/common/makeuser.py
31
31
 
32
32
# TODO: When creating a new home directory, chown it to its owner
33
33
 
 
34
# TODO: In chown_to_webserver:
 
35
# Do not call os.system("chown www-data") - use Python lib
 
36
# and use the web server uid given in conf. (Several places).
 
37
 
34
38
import md5
35
39
import os
36
40
import stat
38
42
import time
39
43
import uuid
40
44
import warnings
41
 
 
 
45
import filecmp
 
46
import logging
42
47
import conf
43
48
import db
44
49
 
 
50
def chown_to_webserver(filename):
 
51
    """
 
52
    Chowns a file so the web server user owns it.
 
53
    (This is useful in setting up Subversion conf files).
 
54
    Assumes root.
 
55
    """
 
56
    try:
 
57
        os.system("chown -R www-data:www-data %s" % filename)
 
58
    except:
 
59
        pass
 
60
 
45
61
def make_svn_repo(login, throw_on_error=True):
46
62
    """Create a repository for the given user.
47
63
    """
54
70
        print repr(exc)
55
71
        if throw_on_error:
56
72
            raise
57
 
    try:
58
 
        os.system("chown -R www-data:www-data %s" % path)
59
 
    except Exception:
60
 
        pass
 
73
 
 
74
    chown_to_webserver(path)
61
75
 
62
76
def rebuild_svn_config():
63
77
    """Build the complete SVN configuration file.
88
102
        f.write("\n")
89
103
    f.close()
90
104
    os.rename(conf.svn_conf + ".new", conf.svn_conf)
 
105
    chown_to_webserver(conf.svn_conf)
91
106
 
92
107
def make_svn_config(login, throw_on_error=True):
93
108
    """Add an entry to the apache-svn config file for the given user.
101
116
    #f.write("@admin = rw\n")
102
117
    f.write("\n")
103
118
    f.close()
 
119
    chown_to_webserver(conf.svn_conf)
104
120
 
105
121
def make_svn_auth(login, throw_on_error=True):
106
122
    """Setup svn authentication for the given user.
120
136
    if res != 0 and throw_on_error:
121
137
        raise Exception("Unable to create ivle-auth for %s" % login)
122
138
 
 
139
    # Make sure the file is owned by the web server
 
140
    if create == "c":
 
141
        chown_to_webserver(conf.svn_auth_ivle)
 
142
 
123
143
    return passwd
124
144
 
125
 
def make_jail(username, uid, force=True):
 
145
def generate_manifest(basedir, targetdir, parent=''):
 
146
    """ From a basedir and a targetdir work out which files are missing or out 
 
147
    of date and need to be added/updated and which files are redundant and need 
 
148
    to be removed.
 
149
    
 
150
    parent: This is used for the recursive call to track the relative paths 
 
151
    that we have decended.
 
152
    """
 
153
    
 
154
    cmp = filecmp.dircmp(basedir, targetdir)
 
155
 
 
156
    # Add all new files and files that have changed
 
157
    to_add = [os.path.join(parent,x) for x in (cmp.left_only + cmp.diff_files)]
 
158
 
 
159
    # Remove files that are redundant
 
160
    to_remove = [os.path.join(parent,x) for x in cmp.right_only]
 
161
    
 
162
    # Recurse
 
163
    for d in cmp.common_dirs:
 
164
        newbasedir = os.path.join(basedir, d)
 
165
        newtargetdir = os.path.join(targetdir, d)
 
166
        newparent = os.path.join(parent, d)
 
167
        (sadd,sremove) = generate_manifest(newbasedir, newtargetdir, newparent)
 
168
        to_add += sadd
 
169
        to_remove += sremove
 
170
 
 
171
    return (to_add, to_remove)
 
172
 
 
173
 
 
174
def make_jail(username, uid, force=True, svn_pass=None):
126
175
    """Creates a new user's jail space, in the jail directory as configured in
127
176
    conf.py.
128
177
 
129
 
    This expects there to be a "template" directory within the jail root which
130
 
    contains all the files for a sample student jail. It creates the student's
131
 
    directory in the jail root, by making a hard-link copy of every file in the
132
 
    template directory, recursively.
 
178
    This only creates things within /home - everything else is expected to be
 
179
    part of another UnionFS branch.
133
180
 
134
181
    Returns the path to the user's home directory.
135
182
 
142
189
 
143
190
    force: If false, exception if jail already exists for this user.
144
191
    If true (default), overwrites it, but preserves home directory.
 
192
 
 
193
    svn_pass: If provided this will be a string, the randomly-generated
 
194
    Subversion password for this user (if you happen to already have it).
 
195
    If not provided, it will be read from the database.
145
196
    """
146
197
    # MUST run as root or some of this may fail
147
198
    if os.getuid() != 0:
148
199
        raise Exception("Must run make_jail as root")
149
200
    
150
 
    templatedir = os.path.join(conf.jail_base, 'template')
151
 
    if not os.path.isdir(templatedir):
152
 
        raise Exception("Template jail directory does not exist: " +
153
 
            templatedir)
154
201
    # tempdir is for putting backup homes in
155
 
    tempdir = os.path.join(conf.jail_base, 'temp')
 
202
    tempdir = os.path.join(conf.jail_base, '__temp__')
156
203
    if not os.path.exists(tempdir):
157
204
        os.makedirs(tempdir)
158
205
    elif not os.path.isdir(tempdir):
159
206
        os.unlink(tempdir)
160
207
        os.mkdir(tempdir)
161
 
    userdir = os.path.join(conf.jail_base, username)
 
208
    userdir = os.path.join(conf.jail_src_base, username)
162
209
    homedir = os.path.join(userdir, 'home')
 
210
    userhomedir = os.path.join(homedir, username)   # Return value
163
211
 
164
212
    if os.path.exists(userdir):
165
213
        if not force:
166
214
            raise Exception("User's jail already exists")
167
215
        # User jail already exists. Blow it away but preserve their home
168
 
        # directory.
 
216
        # directory. It should be all that is there anyway, but you never
 
217
        # know!
169
218
        # Ignore warnings about the use of tmpnam
170
219
        warnings.simplefilter('ignore')
171
220
        homebackup = os.tempnam(tempdir)
174
223
        # into a directory if it already exists, just fails. Therefore it is
175
224
        # not susceptible to tmpnam symlink attack.
176
225
        shutil.move(homedir, homebackup)
177
 
        try:
178
 
            # Any errors that occur after making the backup will be caught and
179
 
            # the backup will be un-made.
180
 
            # XXX This will still leave the user's jail in an unusable state,
181
 
            # but at least they won't lose their files.
182
 
            shutil.rmtree(userdir)
183
 
 
184
 
            # Hard-link (copy aliasing) the entire tree over
185
 
            linktree(templatedir, userdir)
186
 
        finally:
187
 
            # Set up the user's home directory (restore backup)
188
 
            # First make sure the directory is empty and its parent exists
189
 
            try:
190
 
                shutil.rmtree(homedir)
191
 
            except:
192
 
                pass
193
 
            # XXX If this fails the user's directory will be lost (in the temp
194
 
            # directory). But it shouldn't fail as homedir should not exist.
195
 
            os.makedirs(homedir)
196
 
            shutil.move(homebackup, homedir)
197
 
        return os.path.join(homedir, username)
 
226
        shutil.rmtree(userdir)
 
227
        os.makedirs(homedir)
 
228
        shutil.move(homebackup, homedir)
198
229
    else:
199
230
        # No user jail exists
200
 
        # Hard-link (copy aliasing) the entire tree over
201
 
        linktree(templatedir, userdir)
202
 
 
203
231
        # Set up the user's home directory
204
 
        userhomedir = os.path.join(homedir, username)
205
 
        os.mkdir(userhomedir)
 
232
        os.makedirs(userhomedir)
206
233
        # Chown (and set the GID to the same as the UID).
207
234
        os.chown(userhomedir, uid, uid)
208
235
        # Chmod to rwxr-xr-x (755)
209
236
        os.chmod(userhomedir, 0755)
210
 
        return userhomedir
 
237
 
 
238
    # There are 2 special files which need to be generated specific to this
 
239
    # user: /opt/ivle/lib/conf/conf.py and /etc/passwd.
 
240
    # "__" username "__" users are exempt (special)
 
241
    if not (username.startswith("__") and username.endswith("__")):
 
242
        make_conf_py(username, userdir, conf.jail_system, svn_pass)
 
243
        make_etc_passwd(username, userdir, conf.jail_system, uid)
 
244
 
 
245
    return userhomedir
 
246
 
 
247
def make_conf_py(username, user_jail_dir, staging_dir, svn_pass=None):
 
248
    """
 
249
    Creates (overwriting any existing file, and creating directories) a
 
250
    file /opt/ivle/lib/conf/conf.py in a given user's jail.
 
251
    username: Username.
 
252
    user_jail_dir: User's jail dir, ie. conf.jail_base + username
 
253
    staging_dir: The dir with the staging copy of the jail. (With the
 
254
        template conf.py file).
 
255
    svn_pass: As with make_jail. User's SVN password, but if not supplied,
 
256
        will look up in the DB.
 
257
    """
 
258
    template_conf_path = os.path.join(staging_dir,"opt/ivle/lib/conf/conf.py")
 
259
    conf_path = os.path.join(user_jail_dir, "opt/ivle/lib/conf/conf.py")
 
260
    os.makedirs(os.path.dirname(conf_path))
 
261
 
 
262
    # If svn_pass isn't supplied, grab it from the DB
 
263
    if svn_pass is None:
 
264
        dbconn = db.DB()
 
265
        svn_pass = dbconn.get_user(username).svn_pass
 
266
        dbconn.close()
 
267
 
 
268
    # Read the contents of the template conf file
 
269
    try:
 
270
        template_conf_file = open(template_conf_path, "r")
 
271
        template_conf_data = template_conf_file.read()
 
272
        template_conf_file.close()
 
273
    except:
 
274
        # Couldn't open template conf.py for some reason
 
275
        # Just treat it as empty file
 
276
        template_conf_data = ("# Warning: Problem building config script.\n"
 
277
                              "# Could not find template conf.py file.\n")
 
278
 
 
279
    conf_file = open(conf_path, "w")
 
280
    conf_file.write(template_conf_data)
 
281
    conf_file.write("\n# The login name for the owner of the jail\n")
 
282
    conf_file.write("login = %s\n" % repr(username))
 
283
    conf_file.write("\n")
 
284
    conf_file.write("# The subversion-only password for the owner of "
 
285
        "the jail\n")
 
286
    conf_file.write("svn_pass = %s\n" % repr(svn_pass))
 
287
    conf_file.close()
 
288
 
 
289
    # Make this file world-readable
 
290
    # (chmod 644 conf_path)
 
291
    os.chmod(conf_path, stat.S_IRUSR | stat.S_IWUSR | stat.S_IRGRP
 
292
                        | stat.S_IROTH)
 
293
 
 
294
def make_etc_passwd(username, user_jail_dir, template_dir, unixid):
 
295
    """
 
296
    Creates /etc/passwd in the given user's jail. This will be identical to
 
297
    that in the template jail, except for the added entry for this user.
 
298
    """
 
299
    template_passwd_path = os.path.join(template_dir, "etc/passwd")
 
300
    passwd_path = os.path.join(user_jail_dir, "etc/passwd")
 
301
    passwd_dir = os.path.dirname(passwd_path)
 
302
    if not os.path.exists(passwd_dir):
 
303
        os.makedirs(passwd_dir)
 
304
    shutil.copy(template_passwd_path, passwd_path)
 
305
    passwd_file = open(passwd_path, 'a')
 
306
    passwd_file.write('%s:x:%d:%d::/home/%s:/bin/bash'
 
307
                      % (username, unixid, unixid, username))
 
308
    passwd_file.close()
211
309
 
212
310
def linktree(src, dst):
213
311
    """Recursively hard-link a directory tree using os.link().
273
371
        if res != 0 and throw_on_error:
274
372
            raise Exception("Unable to create local-auth for %s" % kwargs['login'])
275
373
 
 
374
    # Make sure the file is owned by the web server
 
375
    if create == "c":
 
376
        chown_to_webserver(conf.svn_auth_local)
 
377
 
 
378
def mount_jail(login):
 
379
    # This is where we'll mount to...
 
380
    destdir = os.path.join(conf.jail_base, login)
 
381
    # ... and this is where we'll get the user bits.
 
382
    srcdir = os.path.join(conf.jail_src_base, login)
 
383
    try:
 
384
        if not os.path.exists(destdir):
 
385
            os.mkdir(destdir)
 
386
        if os.system('/bin/mount -t aufs -o dirs=%s:%s=ro none %s'
 
387
                     % (srcdir, conf.jail_system, destdir)) == 0:
 
388
            logging.info("mounted user %s's jail." % login)
 
389
        else:
 
390
            logging.error("failed to mount user %s's jail!" % login)
 
391
    except Exception, message:
 
392
        logging.warning(str(message))