← 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-28 06:18:14 UTC
  • Revision ID: grantw@unimelb.edu.au-20090428061814-fiqynzwcmtk3dokn
Replace ivle.util.unmake_path with specialisations in Request and CGIRequest.

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
 
47
import ivle.conf
 
48
import ivle.pulldown_subj
29
49
 
30
 
import ivle.config
31
 
from ivle.database import ProjectGroup, User
 
50
from ivle.database import ProjectGroup
32
51
 
33
52
def chown_to_webserver(filename):
34
 
    """chown a directory and its contents to the web server.
35
 
 
36
 
    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).
37
56
    Assumes root.
38
57
    """
39
 
    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
40
62
 
41
63
def make_svn_repo(path, throw_on_error=True):
42
 
    """Create a Subversion repository at the given path."""
 
64
    """Create a Subversion repository at the given path.
 
65
    """
43
66
    try:
44
 
        res = subprocess.call(['svnadmin', 'create', path])
 
67
        res = os.system("svnadmin create '%s'" % path)
45
68
        if res != 0 and throw_on_error:
46
69
            raise Exception("Cannot create repository: %s" % path)
47
70
    except Exception, exc:
51
74
 
52
75
    chown_to_webserver(path)
53
76
 
54
 
def rebuild_svn_config(store, config):
 
77
def rebuild_svn_config(store):
55
78
    """Build the complete SVN configuration file.
56
 
 
57
 
    @param config: An ivle.config.Config object.
58
79
    """
59
 
    users = store.find(User)
60
 
    conf_name = config['paths']['svn']['conf']
61
 
    temp_name = conf_name + ".new"
62
 
    f = open(temp_name, "w")
63
 
    f.write("""\
64
 
# IVLE SVN repository authorisation configuration
65
 
# Generated: %(time)s
66
 
""" % {'time': time.asctime()})
67
 
 
 
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")
68
91
    for u in users:
69
 
        f.write("""
70
 
[%(login)s:/]
71
 
%(login)s = rw
72
 
""" % {'login': u.login})
73
 
 
 
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")
74
98
    f.close()
75
 
    os.rename(temp_name, conf_name)
76
 
    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)
77
101
 
78
 
def rebuild_svn_group_config(store, config):
 
102
def rebuild_svn_group_config(store):
79
103
    """Build the complete SVN configuration file for groups
80
 
 
81
 
    @param config: An ivle.config.Config object.
82
104
    """
83
 
    conf_name = config['paths']['svn']['group_conf']
84
 
    temp_name = conf_name + ".new"
85
 
    f = open(temp_name, "w")
86
 
 
87
 
    f.write("""\
88
 
# IVLE SVN group repository authorisation configuration
89
 
# Generated: %(time)s
90
 
 
91
 
""" % {'time': time.asctime()})
92
 
 
 
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")
93
109
    for group in store.find(ProjectGroup):
94
110
        offering = group.project_set.offering
95
111
        reponame = "_".join([offering.subject.short_name,
96
112
                             offering.semester.year,
97
113
                             offering.semester.semester,
98
114
                             group.name])
99
 
 
100
 
        f.write("[%s:/]\n" % reponame)
 
115
        f.write("[%s:/]\n"%reponame)
101
116
        for user in group.members:
102
117
            f.write("%s = rw\n" % user.login)
103
118
        f.write("\n")
104
 
 
105
119
    f.close()
106
 
    os.rename(temp_name, conf_name)
107
 
    chown_to_webserver(conf_name)
108
 
 
109
 
def make_svn_auth(store, login, config, throw_on_error=True):
110
 
    """Create a Subversion password for a user.
111
 
 
112
 
    Generates a new random Subversion password, and assigns it to the user.
113
 
    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.
114
126
    """
115
 
    # filename is, eg, /var/lib/ivle/svn/ivle.auth
116
 
    filename = config['paths']['svn']['auth_ivle']
117
127
    passwd = hashlib.md5(uuid.uuid4().bytes).hexdigest()
118
 
    if os.path.exists(filename):
 
128
    if os.path.exists(ivle.conf.svn_auth_ivle):
119
129
        create = ""
120
130
    else:
121
131
        create = "c"
122
132
 
123
 
    user = User.get_by_login(store, login)
 
133
    user = ivle.database.User.get_by_login(store, login)
124
134
    user.svn_pass = unicode(passwd)
125
135
 
126
 
    res = subprocess.call(['htpasswd', '-%smb' % create,
127
 
                           filename, login, passwd])
 
136
    res = os.system("htpasswd -%smb %s %s %s" % (create,
 
137
                                              ivle.conf.svn_auth_ivle,
 
138
                                              login, passwd))
128
139
    if res != 0 and throw_on_error:
129
140
        raise Exception("Unable to create ivle-auth for %s" % login)
130
141
 
131
142
    # Make sure the file is owned by the web server
132
143
    if create == "c":
133
 
        chown_to_webserver(filename)
 
144
        chown_to_webserver(ivle.conf.svn_auth_ivle)
134
145
 
135
146
    return passwd
136
147
 
137
 
def make_jail(user, config, force=True):
138
 
    """Create or update a user's jail.
139
 
 
140
 
    Only the user-specific parts of the jail are created here - everything
141
 
    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.
142
183
 
143
184
    Returns the path to the user's home directory.
144
185
 
145
186
    Chowns the user's directory within the jail to the given UID.
146
187
 
147
 
    @param force: If False, raise an exception if the user already has a jail.
148
 
                  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.
149
190
    """
150
191
    # MUST run as root or some of this may fail
151
192
    if os.getuid() != 0:
152
193
        raise Exception("Must run make_jail as root")
153
194
    
154
195
    # tempdir is for putting backup homes in
155
 
    jail_src_base = config['paths']['jails']['src']
156
 
    tempdir = os.path.join(jail_src_base, '__temp__')
 
196
    tempdir = os.path.join(ivle.conf.jail_src_base, '__temp__')
157
197
    if not os.path.exists(tempdir):
158
198
        os.makedirs(tempdir)
159
199
    elif not os.path.isdir(tempdir):
160
200
        os.unlink(tempdir)
161
201
        os.mkdir(tempdir)
162
 
    userdir = os.path.join(jail_src_base, user.login)
 
202
    userdir = os.path.join(ivle.conf.jail_src_base, user.login)
163
203
    homedir = os.path.join(userdir, 'home')
164
204
    userhomedir = os.path.join(homedir, user.login)   # Return value
165
205
 
196
236
        # Chmod to rwxr-xr-x (755)
197
237
        os.chmod(userhomedir, 0755)
198
238
 
199
 
    make_ivle_conf(user.login, userdir, user.svn_pass, config)
200
 
    make_etc_passwd(user.login, userdir, config['paths']['jails']['template'],
201
 
                    user.unixid)
 
239
    make_ivle_conf(user.login, userdir, user.svn_pass)
 
240
    make_etc_passwd(user.login, userdir, ivle.conf.jail_system, user.unixid)
202
241
 
203
242
    return userhomedir
204
243
 
205
 
def make_ivle_conf(username, user_jail_dir, svn_pass, sys_config):
206
 
    """Generate an ivle.conf for a user's jail.
207
 
 
 
244
def make_ivle_conf(username, user_jail_dir, svn_pass):
 
245
    """
208
246
    Creates (overwriting any existing file, and creating directories) a
209
247
    file /etc/ivle/ivle.conf in a given user's jail.
210
 
 
211
 
    @param username: Username.
212
 
    @param user_jail_dir: User's jail dir, ie. ['jails']['src'] + username
213
 
    @param svn_pass: User's SVN password.
214
 
    @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.
215
251
    """
216
252
    conf_path = os.path.join(user_jail_dir, "etc/ivle/ivle.conf")
217
253
    os.makedirs(os.path.dirname(conf_path))
221
257
    # So we just write root_dir.
222
258
    conf_obj = ivle.config.Config(blank=True)
223
259
    conf_obj.filename = conf_path
224
 
    conf_obj['urls']['root'] = sys_config['urls']['root']
225
 
    conf_obj['urls']['public_host'] = sys_config['urls']['public_host']
226
 
    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
227
263
    conf_obj['user_info']['login'] = username
228
264
    conf_obj['user_info']['svn_pass'] = svn_pass
229
265
    conf_obj.write()
234
270
                        | stat.S_IROTH)
235
271
 
236
272
def make_etc_passwd(username, user_jail_dir, template_dir, unixid):
237
 
    """Create a passwd file for a user's jail.
238
 
 
 
273
    """
239
274
    Creates /etc/passwd in the given user's jail. This will be identical to
240
275
    that in the template jail, except for the added entry for this user.
241
276
    """
249
284
    passwd_file.write('%s:x:%d:%d::/home/%s:/bin/bash'
250
285
                      % (username, unixid, unixid, username))
251
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))