← Back to branch summary

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

« back to all changes in this revision

Viewing changes to ivle/makeuser.py

  • Committer: Matt Giuca
  • Date: 2009-04-25 15:04:46 UTC
  • Revision ID: matt.giuca@gmail.com-20090425150446-f6z2k8ogs8kgyh1y
Tags: 0.1.9.12
ivle.chat, ivle.database, ivle.makeuser: Replaced use of md5 library with
    hashlib to avoid Python 2.6 producing DeprecationWarnings.
    Also use hexdigest() instead of digest().encode('hex').

Show diffs side-by-side

added added

removed removed

Lines of Context:
ivle/makeuser.py
1
1
# IVLE - Informatics Virtual Learning Environment
2
 
# Copyright (C) 2007-2009 The University of Melbourne
 
2
# Copyright (C) 2007-2008 The University of Melbourne
3
3
#
4
4
# This program is free software; you can redistribute it and/or modify
5
5
# it under the terms of the GNU General Public License as published by
15
15
# along with this program; if not, write to the Free Software
16
16
# Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
17
17
 
18
 
"""User and group filesystem management helpers."""
 
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).
19
37
 
20
38
import hashlib
21
39
import os
24
42
import time
25
43
import uuid
26
44
import warnings
 
45
import filecmp
27
46
import logging
28
 
import subprocess
29
 
 
30
 
from storm.expr import Select, Max
31
 
 
32
 
import ivle.config
33
 
from ivle.database import (User, ProjectGroup, Assessed, ProjectSubmission,
34
 
        Project, ProjectSet, Offering, Enrolment, Subject, Semester)
 
47
import ivle.conf
 
48
import ivle.pulldown_subj
 
49
 
 
50
from ivle.database import ProjectGroup
35
51
 
36
52
def chown_to_webserver(filename):
37
 
    """chown a directory and its contents to the web server.
38
 
 
39
 
    Recursively chowns a file or directory so the web server user owns it.
 
53
    """
 
54
    Chowns a file so the web server user owns it.
 
55
    (This is useful in setting up Subversion conf files).
40
56
    Assumes root.
41
57
    """
42
 
    subprocess.call(['chown', '-R', 'www-data:www-data', filename])
 
58
    try:
 
59
        os.system("chown -R www-data:www-data %s" % filename)
 
60
    except:
 
61
        pass
43
62
 
44
63
def make_svn_repo(path, throw_on_error=True):
45
 
    """Create a Subversion repository at the given path."""
 
64
    """Create a Subversion repository at the given path.
 
65
    """
46
66
    try:
47
 
        res = subprocess.call(['svnadmin', 'create', path])
 
67
        res = os.system("svnadmin create '%s'" % path)
48
68
        if res != 0 and throw_on_error:
49
69
            raise Exception("Cannot create repository: %s" % path)
50
70
    except Exception, exc:
54
74
 
55
75
    chown_to_webserver(path)
56
76
 
57
 
def rebuild_svn_config(store, config):
 
77
def rebuild_svn_config(store):
58
78
    """Build the complete SVN configuration file.
59
 
 
60
 
    @param config: An ivle.config.Config object.
61
79
    """
62
 
    users = store.find(User)
63
 
    conf_name = config['paths']['svn']['conf']
64
 
    temp_name = conf_name + ".new"
65
 
    f = open(temp_name, "w")
66
 
    f.write("""\
67
 
# IVLE SVN repository authorisation configuration
68
 
# Generated: %(time)s
69
 
""" % {'time': time.asctime()})
70
 
 
 
80
    users = store.find(ivle.database.User)
 
81
    groups = {}
 
82
    # TODO: Populate groups with per-offering tutors/lecturers/etc.
 
83
    f = open(ivle.conf.svn_conf + ".new", "w")
 
84
    f.write("# IVLE SVN Repositories Configuration\n")
 
85
    f.write("# Auto-generated on %s\n" % time.asctime())
 
86
    f.write("\n")
 
87
    f.write("[groups]\n")
 
88
    for (g,ls) in groups.iteritems():
 
89
        f.write("%s = %s\n" % (g, ",".join(ls)))
 
90
    f.write("\n")
71
91
    for u in users:
72
 
        f.write("""
73
 
[%(login)s:/]
74
 
%(login)s = rw
75
 
""" % {'login': u.login})
76
 
 
77
 
    # Now we need to grant offering tutors and lecturers access to the latest
78
 
    # submissions in their offerings. There are much prettier ways to do this,
79
 
    # but a lot of browser requests call this function, so it needs to be
80
 
    # fast. We can grab all of the paths needing authorisation directives with
81
 
    # a single query, and we cache the list of viewers for each offering.
82
 
    offering_viewers_cache = {}
83
 
    for (login, psid, pspath, offeringid) in store.find(
84
 
        (User.login, ProjectSubmission.id, ProjectSubmission.path,
85
 
         Offering.id),
86
 
            Assessed.id == ProjectSubmission.assessed_id,
87
 
            User.id == Assessed.user_id,
88
 
            Project.id == Assessed.project_id,
89
 
            ProjectSet.id == Project.project_set_id,
90
 
            Offering.id == ProjectSet.id,
91
 
            ProjectSubmission.date_submitted == Select(
92
 
                    Max(ProjectSubmission.date_submitted),
93
 
                    ProjectSubmission.assessed_id == Assessed.id,
94
 
                    tables=ProjectSubmission
95
 
            )
96
 
        ):
97
 
 
98
 
        # Do we already have the list of logins authorised for this offering
99
 
        # cached? If not, get it.
100
 
        if offeringid not in offering_viewers_cache:
101
 
            offering_viewers_cache[offeringid] = list(store.find(
102
 
                    User.login,
103
 
                    User.id == Enrolment.user_id,
104
 
                    Enrolment.offering_id == offeringid,
105
 
                    Enrolment.role.is_in((u'tutor', u'lecturer'))
106
 
                )
107
 
            )
108
 
 
109
 
        f.write("""
110
 
# Submission %(id)d
111
 
[%(login)s:%(path)s]
112
 
""" % {'login': login, 'id': psid, 'path': pspath})
113
 
 
114
 
        for viewer_login in offering_viewers_cache[offeringid]:
115
 
            # We don't want to override the owner's write privilege,
116
 
            # so we don't add them to the read-only ACL.
117
 
            if login != viewer_login:
118
 
                f.write("%s = r\n" % viewer_login)
119
 
 
 
92
        f.write("[%s:/]\n" % u.login)
 
93
        f.write("%s = rw\n" % u.login)
 
94
        #f.write("@tutor = r\n")
 
95
        #f.write("@lecturer = rw\n")
 
96
        #f.write("@admin = rw\n")
 
97
        f.write("\n")
120
98
    f.close()
121
 
    os.rename(temp_name, conf_name)
122
 
    chown_to_webserver(conf_name)
 
99
    os.rename(ivle.conf.svn_conf + ".new", ivle.conf.svn_conf)
 
100
    chown_to_webserver(ivle.conf.svn_conf)
123
101
 
124
 
def rebuild_svn_group_config(store, config):
 
102
def rebuild_svn_group_config(store):
125
103
    """Build the complete SVN configuration file for groups
126
 
 
127
 
    @param config: An ivle.config.Config object.
128
104
    """
129
 
    conf_name = config['paths']['svn']['group_conf']
130
 
    temp_name = conf_name + ".new"
131
 
    f = open(temp_name, "w")
132
 
 
133
 
    f.write("""\
134
 
# IVLE SVN group repository authorisation configuration
135
 
# Generated: %(time)s
136
 
 
137
 
""" % {'time': time.asctime()})
138
 
 
139
 
    group_members_cache = {}
 
105
    f = open(ivle.conf.svn_group_conf + ".new", "w")
 
106
    f.write("# IVLE SVN Group Repositories Configuration\n")
 
107
    f.write("# Auto-generated on %s\n" % time.asctime())
 
108
    f.write("\n")
140
109
    for group in store.find(ProjectGroup):
141
110
        offering = group.project_set.offering
142
111
        reponame = "_".join([offering.subject.short_name,
143
112
                             offering.semester.year,
144
113
                             offering.semester.semester,
145
114
                             group.name])
146
 
 
147
 
        f.write("[%s:/]\n" % reponame)
148
 
        if group.id not in group_members_cache:
149
 
            group_members_cache[group.id] = set()
 
115
        f.write("[%s:/]\n"%reponame)
150
116
        for user in group.members:
151
 
            group_members_cache[group.id].add(user.login)
152
117
            f.write("%s = rw\n" % user.login)
153
118
        f.write("\n")
154
 
 
155
 
    # Now we need to grant offering tutors and lecturers access to the latest
156
 
    # submissions in their offerings. There are much prettier ways to do this,
157
 
    # but a lot of browser requests call this function, so it needs to be
158
 
    # fast. We can grab all of the paths needing authorisation directives with
159
 
    # a single query, and we cache the list of viewers for each offering.
160
 
    offering_viewers_cache = {}
161
 
    for (ssn, year, sem, name, psid, pspath, gid, offeringid) in store.find(
162
 
        (Subject.short_name, Semester.year, Semester.semester,
163
 
         ProjectGroup.name, ProjectSubmission.id, ProjectSubmission.path,
164
 
         ProjectGroup.id, Offering.id),
165
 
            Assessed.id == ProjectSubmission.assessed_id,
166
 
            ProjectGroup.id == Assessed.project_group_id,
167
 
            Project.id == Assessed.project_id,
168
 
            ProjectSet.id == Project.project_set_id,
169
 
            Offering.id == ProjectSet.offering_id,
170
 
            Subject.id == Offering.subject_id,
171
 
            Semester.id == Offering.semester_id,
172
 
            ProjectSubmission.date_submitted == Select(
173
 
                    Max(ProjectSubmission.date_submitted),
174
 
                    ProjectSubmission.assessed_id == Assessed.id,
175
 
                    tables=ProjectSubmission
176
 
            )
177
 
        ):
178
 
 
179
 
        reponame = "_".join([ssn, year, sem, name])
180
 
 
181
 
        # Do we already have the list of logins authorised for this offering
182
 
        # cached? If not, get it.
183
 
        if offeringid not in offering_viewers_cache:
184
 
            offering_viewers_cache[offeringid] = list(store.find(
185
 
                    User.login,
186
 
                    User.id == Enrolment.user_id,
187
 
                    Enrolment.offering_id == offeringid,
188
 
                    Enrolment.role.is_in((u'tutor', u'lecturer'))
189
 
                )
190
 
            )
191
 
 
192
 
        f.write("""
193
 
# Submission %(id)d
194
 
[%(repo)s:%(path)s]
195
 
""" % {'repo': reponame, 'id': psid, 'path': pspath})
196
 
 
197
 
        for viewer_login in offering_viewers_cache[offeringid]:
198
 
            # Skip existing group members, or they can't write to it any more.
199
 
            if viewer_login not in group_members_cache[gid]:
200
 
                f.write("%s = r\n" % viewer_login)
201
 
 
202
119
    f.close()
203
 
    os.rename(temp_name, conf_name)
204
 
    chown_to_webserver(conf_name)
205
 
 
206
 
def make_svn_auth(store, login, config, throw_on_error=True):
207
 
    """Create a Subversion password for a user.
208
 
 
209
 
    Generates a new random Subversion password, and assigns it to the user.
210
 
    The password is added to Apache's Subversion authentication file.
 
120
    os.rename(ivle.conf.svn_group_conf + ".new", ivle.conf.svn_group_conf)
 
121
    chown_to_webserver(ivle.conf.svn_group_conf)
 
122
 
 
123
def make_svn_auth(store, login, throw_on_error=True):
 
124
    """Setup svn authentication for the given user.
 
125
       Uses the given DB store object. Does not commit to the db.
211
126
    """
212
 
    # filename is, eg, /var/lib/ivle/svn/ivle.auth
213
 
    filename = config['paths']['svn']['auth_ivle']
214
127
    passwd = hashlib.md5(uuid.uuid4().bytes).hexdigest()
215
 
    if os.path.exists(filename):
 
128
    if os.path.exists(ivle.conf.svn_auth_ivle):
216
129
        create = ""
217
130
    else:
218
131
        create = "c"
219
132
 
220
 
    user = User.get_by_login(store, login)
 
133
    user = ivle.database.User.get_by_login(store, login)
221
134
    user.svn_pass = unicode(passwd)
222
135
 
223
 
    res = subprocess.call(['htpasswd', '-%smb' % create,
224
 
                           filename, login, passwd])
 
136
    res = os.system("htpasswd -%smb %s %s %s" % (create,
 
137
                                              ivle.conf.svn_auth_ivle,
 
138
                                              login, passwd))
225
139
    if res != 0 and throw_on_error:
226
140
        raise Exception("Unable to create ivle-auth for %s" % login)
227
141
 
228
142
    # Make sure the file is owned by the web server
229
143
    if create == "c":
230
 
        chown_to_webserver(filename)
 
144
        chown_to_webserver(ivle.conf.svn_auth_ivle)
231
145
 
232
146
    return passwd
233
147
 
234
 
def make_jail(user, config, force=True):
235
 
    """Create or update a user's jail.
236
 
 
237
 
    Only the user-specific parts of the jail are created here - everything
238
 
    else is expected to be part of another aufs branch.
 
148
def generate_manifest(basedir, targetdir, parent=''):
 
149
    """ From a basedir and a targetdir work out which files are missing or out 
 
150
    of date and need to be added/updated and which files are redundant and need 
 
151
    to be removed.
 
152
    
 
153
    parent: This is used for the recursive call to track the relative paths 
 
154
    that we have decended.
 
155
    """
 
156
    
 
157
    cmp = filecmp.dircmp(basedir, targetdir)
 
158
 
 
159
    # Add all new files and files that have changed
 
160
    to_add = [os.path.join(parent,x) for x in (cmp.left_only + cmp.diff_files)]
 
161
 
 
162
    # Remove files that are redundant
 
163
    to_remove = [os.path.join(parent,x) for x in cmp.right_only]
 
164
    
 
165
    # Recurse
 
166
    for d in cmp.common_dirs:
 
167
        newbasedir = os.path.join(basedir, d)
 
168
        newtargetdir = os.path.join(targetdir, d)
 
169
        newparent = os.path.join(parent, d)
 
170
        (sadd,sremove) = generate_manifest(newbasedir, newtargetdir, newparent)
 
171
        to_add += sadd
 
172
        to_remove += sremove
 
173
 
 
174
    return (to_add, to_remove)
 
175
 
 
176
 
 
177
def make_jail(user, force=True):
 
178
    """Creates a new user's jail space, in the jail directory as configured in
 
179
    conf.py.
 
180
 
 
181
    This only creates things within /home - everything else is expected to be
 
182
    part of another UnionFS branch.
239
183
 
240
184
    Returns the path to the user's home directory.
241
185
 
242
186
    Chowns the user's directory within the jail to the given UID.
243
187
 
244
 
    @param force: If False, raise an exception if the user already has a jail.
245
 
                  If True (default), rebuild the jail preserving /home.
 
188
    force: If false, exception if jail already exists for this user.
 
189
    If true (default), overwrites it, but preserves home directory.
246
190
    """
247
191
    # MUST run as root or some of this may fail
248
192
    if os.getuid() != 0:
249
193
        raise Exception("Must run make_jail as root")
250
194
    
251
195
    # tempdir is for putting backup homes in
252
 
    jail_src_base = config['paths']['jails']['src']
253
 
    tempdir = os.path.join(jail_src_base, '__temp__')
 
196
    tempdir = os.path.join(ivle.conf.jail_src_base, '__temp__')
254
197
    if not os.path.exists(tempdir):
255
198
        os.makedirs(tempdir)
256
199
    elif not os.path.isdir(tempdir):
257
200
        os.unlink(tempdir)
258
201
        os.mkdir(tempdir)
259
 
    userdir = os.path.join(jail_src_base, user.login)
 
202
    userdir = os.path.join(ivle.conf.jail_src_base, user.login)
260
203
    homedir = os.path.join(userdir, 'home')
261
 
    tmpdir = os.path.join(userdir, 'tmp')
262
204
    userhomedir = os.path.join(homedir, user.login)   # Return value
263
205
 
264
206
    if os.path.exists(userdir):
276
218
        # NOTE that shutil.move changed in Python 2.6, it now moves a
277
219
        # directory INTO the target (like `mv`), which it didn't use to do.
278
220
        # This code works regardless.
279
 
        shutil.move(userhomedir, homebackup)
 
221
        shutil.move(homedir, homebackup)
280
222
        shutil.rmtree(userdir)
281
 
        os.makedirs(homedir)
282
 
        shutil.move(homebackup, userhomedir)
 
223
        os.makedirs(userdir)
 
224
        shutil.move(homebackup, homedir)
283
225
        # Change the ownership of all the files to the right unixid
284
226
        logging.debug("chown %s's home directory files to uid %d"
285
227
            %(user.login, user.unixid))
294
236
        # Chmod to rwxr-xr-x (755)
295
237
        os.chmod(userhomedir, 0755)
296
238
 
297
 
    make_ivle_conf(user.login, userdir, user.svn_pass, config)
298
 
    make_etc_passwd(user.login, userdir, config['paths']['jails']['template'],
299
 
                    user.unixid)
300
 
    os.makedirs(tmpdir)
301
 
    os.chmod(tmpdir, 01777)
 
239
    make_ivle_conf(user.login, userdir, user.svn_pass)
 
240
    make_etc_passwd(user.login, userdir, ivle.conf.jail_system, user.unixid)
302
241
 
303
242
    return userhomedir
304
243
 
305
 
def make_ivle_conf(username, user_jail_dir, svn_pass, sys_config):
306
 
    """Generate an ivle.conf for a user's jail.
307
 
 
 
244
def make_ivle_conf(username, user_jail_dir, svn_pass):
 
245
    """
308
246
    Creates (overwriting any existing file, and creating directories) a
309
247
    file /etc/ivle/ivle.conf in a given user's jail.
310
 
 
311
 
    @param username: Username.
312
 
    @param user_jail_dir: User's jail dir, ie. ['jails']['src'] + username
313
 
    @param svn_pass: User's SVN password.
314
 
    @param sys_config: An ivle.config.Config object (the system-wide config).
 
248
    username: Username.
 
249
    user_jail_dir: User's jail dir, ie. ivle.conf.jail_base + username
 
250
    svn_pass: User's SVN password.
315
251
    """
316
 
    conf_path = os.path.join(user_jail_dir, "home/.ivle.conf")
317
 
    if not os.path.exists(os.path.dirname(conf_path)):
318
 
        os.makedirs(os.path.dirname(conf_path))
 
252
    conf_path = os.path.join(user_jail_dir, "etc/ivle/ivle.conf")
 
253
    os.makedirs(os.path.dirname(conf_path))
319
254
 
320
255
    # In the "in-jail" version of conf, we don't need MOST of the details
321
256
    # (it would be a security risk to have them here).
322
257
    # So we just write root_dir.
323
258
    conf_obj = ivle.config.Config(blank=True)
324
259
    conf_obj.filename = conf_path
325
 
    conf_obj['urls']['root'] = sys_config['urls']['root']
326
 
    conf_obj['urls']['public_host'] = sys_config['urls']['public_host']
327
 
    conf_obj['urls']['svn_addr'] = sys_config['urls']['svn_addr']
 
260
    conf_obj['urls']['root'] = ivle.conf.root_dir
 
261
    conf_obj['urls']['public_host'] = ivle.conf.public_host
 
262
    conf_obj['urls']['svn_addr'] = ivle.conf.svn_addr
328
263
    conf_obj['user_info']['login'] = username
329
264
    conf_obj['user_info']['svn_pass'] = svn_pass
330
265
    conf_obj.write()
335
270
                        | stat.S_IROTH)
336
271
 
337
272
def make_etc_passwd(username, user_jail_dir, template_dir, unixid):
338
 
    """Create a passwd file for a user's jail.
339
 
 
 
273
    """
340
274
    Creates /etc/passwd in the given user's jail. This will be identical to
341
275
    that in the template jail, except for the added entry for this user.
342
276
    """
343
 
    template_passwd_path = os.path.join(template_dir, "home/.passwd")
344
 
    passwd_path = os.path.join(user_jail_dir, "home/.passwd")
 
277
    template_passwd_path = os.path.join(template_dir, "etc/passwd")
 
278
    passwd_path = os.path.join(user_jail_dir, "etc/passwd")
345
279
    passwd_dir = os.path.dirname(passwd_path)
346
280
    if not os.path.exists(passwd_dir):
347
281
        os.makedirs(passwd_dir)
350
284
    passwd_file.write('%s:x:%d:%d::/home/%s:/bin/bash'
351
285
                      % (username, unixid, unixid, username))
352
286
    passwd_file.close()
 
287
 
 
288
def mount_jail(login):
 
289
    # This is where we'll mount to...
 
290
    destdir = os.path.join(ivle.conf.jail_base, login)
 
291
    # ... and this is where we'll get the user bits.
 
292
    srcdir = os.path.join(ivle.conf.jail_src_base, login)
 
293
    try:
 
294
        if not os.path.exists(destdir):
 
295
            os.mkdir(destdir)
 
296
        if os.system('/bin/mount -t aufs -o dirs=%s:%s=ro none %s'
 
297
                     % (srcdir, ivle.conf.jail_system, destdir)) == 0:
 
298
            logging.info("mounted user %s's jail." % login)
 
299
        else:
 
300
            logging.error("failed to mount user %s's jail!" % login)
 
301
    except Exception, message:
 
302
        logging.warning(str(message))