← 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-02-29 01:18:22 UTC
  • Revision ID: svn-v3-trunk0:2b9c9e99-6f39-0410-b283-7f802c844ae2:trunk:621
Added 2 new apps: home and subjects. Both fairly incomplete, just a basic
    skeleton.
    "home" is the new default app, replacing "files".
    (It has a link to files).

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