← 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-21 09:09:07 UTC
  • Revision ID: svn-v3-trunk0:2b9c9e99-6f39-0410-b283-7f802c844ae2:trunk:923
users.sql: Added groups_student_permissions column to offering table.

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))