← Back to branch summary

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

« back to all changes in this revision

Viewing changes to ivle/makeuser.py

  • Committer: William Grant
  • Date: 2009-04-29 04:58:42 UTC
  • Revision ID: grantw@unimelb.edu.au-20090429045842-upijb1ybcbz1zg6u
Kill --nosvnrevno from setup.install - we don't use Subversion now.

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.pulldown_subj
 
48
 
 
49
from ivle.database import ProjectGroup
35
50
 
36
51
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.
 
52
    """
 
53
    Chowns a file so the web server user owns it.
 
54
    (This is useful in setting up Subversion conf files).
40
55
    Assumes root.
41
56
    """
42
 
    subprocess.call(['chown', '-R', 'www-data:www-data', filename])
 
57
    try:
 
58
        os.system("chown -R www-data:www-data %s" % filename)
 
59
    except:
 
60
        pass
43
61
 
44
62
def make_svn_repo(path, throw_on_error=True):
45
 
    """Create a Subversion repository at the given path."""
 
63
    """Create a Subversion repository at the given path.
 
64
    """
46
65
    try:
47
 
        res = subprocess.call(['svnadmin', 'create', path])
 
66
        res = os.system("svnadmin create '%s'" % path)
48
67
        if res != 0 and throw_on_error:
49
68
            raise Exception("Cannot create repository: %s" % path)
50
69
    except Exception, exc:
56
75
 
57
76
def rebuild_svn_config(store, config):
58
77
    """Build the complete SVN configuration file.
59
 
 
60
78
    @param config: An ivle.config.Config object.
61
79
    """
62
 
    users = store.find(User)
 
80
    users = store.find(ivle.database.User)
 
81
    groups = {}
 
82
    # TODO: Populate groups with per-offering tutors/lecturers/etc.
63
83
    conf_name = config['paths']['svn']['conf']
64
84
    temp_name = conf_name + ".new"
65
85
    f = open(temp_name, "w")
66
 
    f.write("""\
67
 
# IVLE SVN repository authorisation configuration
68
 
# Generated: %(time)s
69
 
""" % {'time': time.asctime()})
70
 
 
 
86
    f.write("# IVLE SVN Repositories Configuration\n")
 
87
    f.write("# Auto-generated on %s\n" % time.asctime())
 
88
    f.write("\n")
 
89
    f.write("[groups]\n")
 
90
    for (g,ls) in groups.iteritems():
 
91
        f.write("%s = %s\n" % (g, ",".join(ls)))
 
92
    f.write("\n")
71
93
    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
 
 
 
94
        f.write("[%s:/]\n" % u.login)
 
95
        f.write("%s = rw\n" % u.login)
 
96
        #f.write("@tutor = r\n")
 
97
        #f.write("@lecturer = rw\n")
 
98
        #f.write("@admin = rw\n")
 
99
        f.write("\n")
120
100
    f.close()
121
101
    os.rename(temp_name, conf_name)
122
102
    chown_to_webserver(conf_name)
123
103
 
124
104
def rebuild_svn_group_config(store, config):
125
105
    """Build the complete SVN configuration file for groups
126
 
 
127
106
    @param config: An ivle.config.Config object.
128
107
    """
129
108
    conf_name = config['paths']['svn']['group_conf']
130
109
    temp_name = conf_name + ".new"
131
110
    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 = {}
 
111
    f.write("# IVLE SVN Group Repositories Configuration\n")
 
112
    f.write("# Auto-generated on %s\n" % time.asctime())
 
113
    f.write("\n")
140
114
    for group in store.find(ProjectGroup):
141
115
        offering = group.project_set.offering
142
116
        reponame = "_".join([offering.subject.short_name,
143
117
                             offering.semester.year,
144
118
                             offering.semester.semester,
145
119
                             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()
 
120
        f.write("[%s:/]\n"%reponame)
150
121
        for user in group.members:
151
 
            group_members_cache[group.id].add(user.login)
152
122
            f.write("%s = rw\n" % user.login)
153
123
        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
124
    f.close()
203
125
    os.rename(temp_name, conf_name)
204
126
    chown_to_webserver(conf_name)
205
127
 
206
128
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.
 
129
    """Setup svn authentication for the given user.
 
130
       Uses the given DB store object. Does not commit to the db.
211
131
    """
212
132
    # filename is, eg, /var/lib/ivle/svn/ivle.auth
213
133
    filename = config['paths']['svn']['auth_ivle']
 
134
    passwd = hashlib.md5(uuid.uuid4().bytes).hexdigest()
214
135
    if os.path.exists(filename):
215
136
        create = ""
216
137
    else:
217
138
        create = "c"
218
139
 
219
 
    user = User.get_by_login(store, login)
220
 
 
221
 
    if user.svn_pass is None:
222
 
        passwd = hashlib.md5(uuid.uuid4().bytes).hexdigest()
223
 
        user.svn_pass = unicode(passwd)
224
 
 
225
 
    res = subprocess.call(['htpasswd', '-%smb' % create,
226
 
                           filename, login, user.svn_pass])
 
140
    user = ivle.database.User.get_by_login(store, login)
 
141
    user.svn_pass = unicode(passwd)
 
142
 
 
143
    res = os.system("htpasswd -%smb %s %s %s" % (create, filename,
 
144
                                              login, passwd))
227
145
    if res != 0 and throw_on_error:
228
146
        raise Exception("Unable to create ivle-auth for %s" % login)
229
147
 
231
149
    if create == "c":
232
150
        chown_to_webserver(filename)
233
151
 
234
 
    return user.svn_pass
 
152
    return passwd
 
153
 
 
154
def generate_manifest(basedir, targetdir, parent=''):
 
155
    """ From a basedir and a targetdir work out which files are missing or out 
 
156
    of date and need to be added/updated and which files are redundant and need 
 
157
    to be removed.
 
158
    
 
159
    parent: This is used for the recursive call to track the relative paths 
 
160
    that we have decended.
 
161
    """
 
162
    
 
163
    cmp = filecmp.dircmp(basedir, targetdir)
 
164
 
 
165
    # Add all new files and files that have changed
 
166
    to_add = [os.path.join(parent,x) for x in (cmp.left_only + cmp.diff_files)]
 
167
 
 
168
    # Remove files that are redundant
 
169
    to_remove = [os.path.join(parent,x) for x in cmp.right_only]
 
170
    
 
171
    # Recurse
 
172
    for d in cmp.common_dirs:
 
173
        newbasedir = os.path.join(basedir, d)
 
174
        newtargetdir = os.path.join(targetdir, d)
 
175
        newparent = os.path.join(parent, d)
 
176
        (sadd,sremove) = generate_manifest(newbasedir, newtargetdir, newparent)
 
177
        to_add += sadd
 
178
        to_remove += sremove
 
179
 
 
180
    return (to_add, to_remove)
 
181
 
235
182
 
236
183
def make_jail(user, config, force=True):
237
 
    """Create or update a user's jail.
 
184
    """Creates a new user's jail space, in the jail directory as configured in
 
185
    conf.py.
238
186
 
239
 
    Only the user-specific parts of the jail are created here - everything
240
 
    else is expected to be part of another aufs branch.
 
187
    This only creates things within /home - everything else is expected to be
 
188
    part of another UnionFS branch.
241
189
 
242
190
    Returns the path to the user's home directory.
243
191
 
244
192
    Chowns the user's directory within the jail to the given UID.
245
193
 
246
 
    @param force: If False, raise an exception if the user already has a jail.
247
 
                  If True (default), rebuild the jail preserving /home.
 
194
    force: If false, exception if jail already exists for this user.
 
195
    If true (default), overwrites it, but preserves home directory.
248
196
    """
249
197
    # MUST run as root or some of this may fail
250
198
    if os.getuid() != 0:
260
208
        os.mkdir(tempdir)
261
209
    userdir = os.path.join(jail_src_base, user.login)
262
210
    homedir = os.path.join(userdir, 'home')
263
 
    tmpdir = os.path.join(userdir, 'tmp')
264
211
    userhomedir = os.path.join(homedir, user.login)   # Return value
265
212
 
266
213
    if os.path.exists(userdir):
278
225
        # NOTE that shutil.move changed in Python 2.6, it now moves a
279
226
        # directory INTO the target (like `mv`), which it didn't use to do.
280
227
        # This code works regardless.
281
 
        shutil.move(userhomedir, homebackup)
 
228
        shutil.move(homedir, homebackup)
282
229
        shutil.rmtree(userdir)
283
 
        os.makedirs(homedir)
284
 
        shutil.move(homebackup, userhomedir)
 
230
        os.makedirs(userdir)
 
231
        shutil.move(homebackup, homedir)
285
232
        # Change the ownership of all the files to the right unixid
286
233
        logging.debug("chown %s's home directory files to uid %d"
287
234
            %(user.login, user.unixid))
299
246
    make_ivle_conf(user.login, userdir, user.svn_pass, config)
300
247
    make_etc_passwd(user.login, userdir, config['paths']['jails']['template'],
301
248
                    user.unixid)
302
 
    os.makedirs(tmpdir)
303
 
    os.chmod(tmpdir, 01777)
304
249
 
305
250
    return userhomedir
306
251
 
307
252
def make_ivle_conf(username, user_jail_dir, svn_pass, sys_config):
308
 
    """Generate an ivle.conf for a user's jail.
309
 
 
 
253
    """
310
254
    Creates (overwriting any existing file, and creating directories) a
311
255
    file /etc/ivle/ivle.conf in a given user's jail.
312
 
 
313
256
    @param username: Username.
314
257
    @param user_jail_dir: User's jail dir, ie. ['jails']['src'] + username
315
258
    @param svn_pass: User's SVN password.
316
259
    @param sys_config: An ivle.config.Config object (the system-wide config).
317
260
    """
318
 
    conf_path = os.path.join(user_jail_dir, "home/.ivle.conf")
319
 
    if not os.path.exists(os.path.dirname(conf_path)):
320
 
        os.makedirs(os.path.dirname(conf_path))
 
261
    conf_path = os.path.join(user_jail_dir, "etc/ivle/ivle.conf")
 
262
    os.makedirs(os.path.dirname(conf_path))
321
263
 
322
264
    # In the "in-jail" version of conf, we don't need MOST of the details
323
265
    # (it would be a security risk to have them here).
337
279
                        | stat.S_IROTH)
338
280
 
339
281
def make_etc_passwd(username, user_jail_dir, template_dir, unixid):
340
 
    """Create a passwd file for a user's jail.
341
 
 
 
282
    """
342
283
    Creates /etc/passwd in the given user's jail. This will be identical to
343
284
    that in the template jail, except for the added entry for this user.
344
285
    """
345
 
    template_passwd_path = os.path.join(template_dir, "home/.passwd")
346
 
    passwd_path = os.path.join(user_jail_dir, "home/.passwd")
 
286
    template_passwd_path = os.path.join(template_dir, "etc/passwd")
 
287
    passwd_path = os.path.join(user_jail_dir, "etc/passwd")
347
288
    passwd_dir = os.path.dirname(passwd_path)
348
289
    if not os.path.exists(passwd_dir):
349
290
        os.makedirs(passwd_dir)
352
293
    passwd_file.write('%s:x:%d:%d::/home/%s:/bin/bash'
353
294
                      % (username, unixid, unixid, username))
354
295
    passwd_file.close()
 
296
 
 
297
def mount_jail(login, config):
 
298
    # This is where we'll mount to...
 
299
    destdir = os.path.join(config['paths']['jails']['mounts'], login)
 
300
    # ... and this is where we'll get the user bits.
 
301
    srcdir = os.path.join(config['paths']['jails']['src'], login)
 
302
    try:
 
303
        if not os.path.exists(destdir):
 
304
            os.mkdir(destdir)
 
305
        if os.system('/bin/mount -t aufs -o dirs=%s:%s=ro none %s'
 
306
                     % (srcdir, config['paths']['jails']['template'],
 
307
                        destdir)) == 0:
 
308
            logging.info("mounted user %s's jail." % login)
 
309
        else:
 
310
            logging.error("failed to mount user %s's jail!" % login)
 
311
    except Exception, message:
 
312
        logging.warning(str(message))