← 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: William Grant
  • Date: 2010-02-11 05:27:24 UTC
  • Revision ID: grantw@unimelb.edu.au-20100211052724-171m0779yqzn1y1x
Add a setup.cfg with nose settings. You can now run the suite with 'IVLECONF=. nosetests'.

Show diffs side-by-side

added added

removed removed

Lines of Context:
lib/common/makeuser.py
1
 
# IVLE - Informatics Virtual Learning Environment
2
 
# Copyright (C) 2007-2008 The University of Melbourne
3
 
#
4
 
# This program is free software; you can redistribute it and/or modify
5
 
# it under the terms of the GNU General Public License as published by
6
 
# the Free Software Foundation; either version 2 of the License, or
7
 
# (at your option) any later version.
8
 
#
9
 
# This program is distributed in the hope that it will be useful,
10
 
# but WITHOUT ANY WARRANTY; without even the implied warranty of
11
 
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
12
 
# GNU General Public License for more details.
13
 
#
14
 
# You should have received a copy of the GNU General Public License
15
 
# along with this program; if not, write to the Free Software
16
 
# Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
17
 
 
18
 
# Module: MakeUser
19
 
# Author: Matt Giuca
20
 
# Date:   1/2/2008
21
 
 
22
 
# Allows creation of users. This sets up the following:
23
 
# * User's jail and home directory within the jail.
24
 
# * Subversion repository (TODO)
25
 
# * Check out Subversion workspace into jail (TODO)
26
 
# * Database details for user
27
 
# * Unix user account
28
 
 
29
 
# TODO: Sanitize login name and other fields.
30
 
# Users must not be called "temp" or "template".
31
 
 
32
 
# TODO: When creating a new home directory, chown it to its owner
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
 
import md5
39
 
import os
40
 
import stat
41
 
import shutil
42
 
import time
43
 
import uuid
44
 
import warnings
45
 
import filecmp
46
 
import logging
47
 
import conf
48
 
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
 
 
62
 
def make_svn_repo(login, throw_on_error=True):
63
 
    """Create a repository for the given user.
64
 
    """
65
 
    path = os.path.join(conf.svn_repo_path, login)
66
 
    try:
67
 
        res = os.system("svnadmin create '%s'" % path)
68
 
        if res != 0 and throw_on_error:
69
 
            raise Exception("Cannot create repository for %s" % login)
70
 
    except Exception, exc:
71
 
        print repr(exc)
72
 
        if throw_on_error:
73
 
            raise
74
 
 
75
 
    chown_to_webserver(path)
76
 
 
77
 
def rebuild_svn_config():
78
 
    """Build the complete SVN configuration file.
79
 
    """
80
 
    conn = db.DB()
81
 
    res = conn.query("SELECT login, rolenm FROM login;").dictresult()
82
 
    groups = {}
83
 
    for r in res:
84
 
        role = r['rolenm']
85
 
        if role not in groups:
86
 
            groups[role] = []
87
 
        groups[role].append(r['login'])
88
 
    f = open(conf.svn_conf + ".new", "w")
89
 
    f.write("# IVLE SVN Repositories Configuration\n")
90
 
    f.write("# Auto-generated on %s\n" % time.asctime())
91
 
    f.write("\n")
92
 
    f.write("[groups]\n")
93
 
    for (g,ls) in groups.iteritems():
94
 
        f.write("%s = %s\n" % (g, ",".join(ls)))
95
 
    f.write("\n")
96
 
    for r in res:
97
 
        login = r['login']
98
 
        f.write("[%s:/]\n" % login)
99
 
        f.write("%s = rw\n" % login)
100
 
        #f.write("@tutor = r\n")
101
 
        #f.write("@lecturer = rw\n")
102
 
        #f.write("@admin = rw\n")
103
 
        f.write("\n")
104
 
    f.close()
105
 
    os.rename(conf.svn_conf + ".new", conf.svn_conf)
106
 
    chown_to_webserver(conf.svn_conf)
107
 
 
108
 
def make_svn_config(login, throw_on_error=True):
109
 
    """Add an entry to the apache-svn config file for the given user.
110
 
       Assumes the given user is either a guest or a student.
111
 
    """
112
 
    f = open(conf.svn_conf, "a")
113
 
    f.write("[%s:/]\n" % login)
114
 
    f.write("%s = rw\n" % login)
115
 
    #f.write("@tutor = r\n")
116
 
    #f.write("@lecturer = rw\n")
117
 
    #f.write("@admin = rw\n")
118
 
    f.write("\n")
119
 
    f.close()
120
 
    chown_to_webserver(conf.svn_conf)
121
 
 
122
 
def make_svn_auth(login, throw_on_error=True):
123
 
    """Setup svn authentication for the given user.
124
 
       FIXME: create local.auth entry
125
 
    """
126
 
    passwd = md5.new(uuid.uuid4().bytes).digest().encode('hex')
127
 
    if os.path.exists(conf.svn_auth_ivle):
128
 
        create = ""
129
 
    else:
130
 
        create = "c"
131
 
 
132
 
    db.DB().update_user(login, svn_pass=passwd)
133
 
 
134
 
    res = os.system("htpasswd -%smb %s %s %s" % (create,
135
 
                                              conf.svn_auth_ivle,
136
 
                                              login, passwd))
137
 
    if res != 0 and throw_on_error:
138
 
        raise Exception("Unable to create ivle-auth for %s" % login)
139
 
 
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
 
    return passwd
145
 
 
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):
176
 
    """Creates a new user's jail space, in the jail directory as configured in
177
 
    conf.py.
178
 
 
179
 
    This only creates things within /home - everything else is expected to be
180
 
    part of another UnionFS branch.
181
 
 
182
 
    Returns the path to the user's home directory.
183
 
 
184
 
    Chowns the user's directory within the jail to the given UID.
185
 
 
186
 
    Note: This takes separate username and uid arguments. The UID need not
187
 
    *necessarily* correspond to a Unix username at all, if all you are
188
 
    planning to do is setuid to it. This allows the caller the freedom of
189
 
    deciding the binding between username and uid, if any.
190
 
 
191
 
    force: If false, exception if jail already exists for this user.
192
 
    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
 
    """
198
 
    # MUST run as root or some of this may fail
199
 
    if os.getuid() != 0:
200
 
        raise Exception("Must run make_jail as root")
201
 
    
202
 
    # tempdir is for putting backup homes in
203
 
    tempdir = os.path.join(conf.jail_base, '__temp__')
204
 
    if not os.path.exists(tempdir):
205
 
        os.makedirs(tempdir)
206
 
    elif not os.path.isdir(tempdir):
207
 
        os.unlink(tempdir)
208
 
        os.mkdir(tempdir)
209
 
    userdir = os.path.join(conf.jail_src_base, username)
210
 
    homedir = os.path.join(userdir, 'home')
211
 
    userhomedir = os.path.join(homedir, username)   # Return value
212
 
 
213
 
    if os.path.exists(userdir):
214
 
        if not force:
215
 
            raise Exception("User's jail already exists")
216
 
        # 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!
219
 
        # Ignore warnings about the use of tmpnam
220
 
        warnings.simplefilter('ignore')
221
 
        homebackup = os.tempnam(tempdir)
222
 
        warnings.resetwarnings()
223
 
        # Note: shutil.move does not behave like "mv" - it does not put a file
224
 
        # into a directory if it already exists, just fails. Therefore it is
225
 
        # not susceptible to tmpnam symlink attack.
226
 
        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)
237
 
    else:
238
 
        # No user jail exists
239
 
        # Set up the user's home directory
240
 
        os.makedirs(userhomedir)
241
 
        # Chown (and set the GID to the same as the UID).
242
 
        os.chown(userhomedir, uid, uid)
243
 
        # Chmod to rwxr-xr-x (755)
244
 
        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()
317
 
 
318
 
def linktree(src, dst):
319
 
    """Recursively hard-link a directory tree using os.link().
320
 
 
321
 
    The destination directory must not already exist.
322
 
    If exception(s) occur, an Error is raised with a list of reasons.
323
 
 
324
 
    Symlinks are preserved (in fact, hard links are created which point to the
325
 
    symlinks).
326
 
 
327
 
    Code heavily based upon shutil.copytree from Python 2.5 library.
328
 
    """
329
 
    names = os.listdir(src)
330
 
    os.makedirs(dst)
331
 
    errors = []
332
 
    for name in names:
333
 
        srcname = os.path.join(src, name)
334
 
        dstname = os.path.join(dst, name)
335
 
        try:
336
 
            if os.path.isdir(srcname):
337
 
                linktree(srcname, dstname)
338
 
            else:
339
 
                os.link(srcname, dstname)
340
 
            # XXX What about devices, sockets etc.?
341
 
        except (IOError, os.error), why:
342
 
            errors.append((srcname, dstname, str(why)))
343
 
        # catch the Error from the recursive copytree so that we can
344
 
        # continue with other files
345
 
        except Exception, err:
346
 
            errors.append(err.args[0])
347
 
    try:
348
 
        shutil.copystat(src, dst)
349
 
    except WindowsError:
350
 
        # can't copy file access times on Windows
351
 
        pass
352
 
    except OSError, why:
353
 
        errors.extend((src, dst, str(why)))
354
 
    if errors:
355
 
        raise Exception, errors
356
 
 
357
 
def make_user_db(throw_on_error = True, **kwargs):
358
 
    """Creates a user's entry in the database, filling in all the fields.
359
 
    All arguments must be keyword args. They are the fields in the table.
360
 
    However, instead of supplying a "passhash", you must supply a
361
 
    "password" argument, which will be hashed internally.
362
 
    Also do not supply a state. All users are created in the "no_agreement"
363
 
    state.
364
 
    Also pulls the user's subjects using the configured subject pulldown
365
 
    module, and adds enrolments to the DB.
366
 
    Throws an exception if the user already exists.
367
 
    """
368
 
    dbconn = db.DB()
369
 
    dbconn.create_user(**kwargs)
370
 
    dbconn.close()
371
 
 
372
 
    if kwargs['password']:
373
 
        if os.path.exists(conf.svn_auth_local):
374
 
            create = ""
375
 
        else:
376
 
            create = "c"
377
 
        res = os.system("htpasswd -%smb %s %s %s" % (create,
378
 
                                                     conf.svn_auth_local,
379
 
                                                     kwargs['login'],
380
 
                                                     kwargs['password']))
381
 
        if res != 0 and throw_on_error:
382
 
            raise Exception("Unable to create local-auth for %s" % kwargs['login'])
383
 
 
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))