← 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-01-13 01:36:15 UTC
  • Revision ID: svn-v3-trunk0:2b9c9e99-6f39-0410-b283-7f802c844ae2:trunk:1123
Merge setup-refactor branch. This completely breaks existing installations;
every path (both filesystem and Python) has changed. Do not upgrade without
knowing what you are doing.

Show diffs side-by-side

added added

removed removed

Lines of Context:
ivle/makeuser.py
35
35
# Do not call os.system("chown www-data") - use Python lib
36
36
# and use the web server uid given in conf. (Several places).
37
37
 
38
 
import hashlib
 
38
import md5
39
39
import os
40
40
import stat
41
41
import shutil
44
44
import warnings
45
45
import filecmp
46
46
import logging
 
47
import ivle.conf
 
48
import ivle.db
47
49
import ivle.pulldown_subj
48
50
 
49
 
from ivle.database import ProjectGroup
50
 
 
51
51
def chown_to_webserver(filename):
52
52
    """
53
53
    Chowns a file so the web server user owns it.
73
73
 
74
74
    chown_to_webserver(path)
75
75
 
76
 
def rebuild_svn_config(store, config):
 
76
def rebuild_svn_config():
77
77
    """Build the complete SVN configuration file.
78
 
    @param config: An ivle.config.Config object.
79
78
    """
80
 
    users = store.find(ivle.database.User)
 
79
    conn = ivle.db.DB()
 
80
    users = conn.get_users()
81
81
    groups = {}
82
 
    # TODO: Populate groups with per-offering tutors/lecturers/etc.
83
 
    conf_name = config['paths']['svn']['conf']
84
 
    temp_name = conf_name + ".new"
85
 
    f = open(temp_name, "w")
 
82
    for u in users:
 
83
        role = str(u.role)
 
84
        if role not in groups:
 
85
            groups[role] = []
 
86
        groups[role].append(u.login)
 
87
    f = open(ivle.conf.svn_conf + ".new", "w")
86
88
    f.write("# IVLE SVN Repositories Configuration\n")
87
89
    f.write("# Auto-generated on %s\n" % time.asctime())
88
90
    f.write("\n")
98
100
        #f.write("@admin = rw\n")
99
101
        f.write("\n")
100
102
    f.close()
101
 
    os.rename(temp_name, conf_name)
102
 
    chown_to_webserver(conf_name)
 
103
    os.rename(ivle.conf.svn_conf + ".new", ivle.conf.svn_conf)
 
104
    chown_to_webserver(ivle.conf.svn_conf)
103
105
 
104
 
def rebuild_svn_group_config(store, config):
 
106
def rebuild_svn_group_config():
105
107
    """Build the complete SVN configuration file for groups
106
 
    @param config: An ivle.config.Config object.
107
108
    """
108
 
    conf_name = config['paths']['svn']['group_conf']
109
 
    temp_name = conf_name + ".new"
110
 
    f = open(temp_name, "w")
 
109
    conn = ivle.db.DB()
 
110
    groups = conn.get_all('project_group',
 
111
        ['groupid', 'groupnm', 'projectsetid'])
 
112
    f = open(ivle.conf.svn_group_conf + ".new", "w")
111
113
    f.write("# IVLE SVN Group Repositories Configuration\n")
112
114
    f.write("# Auto-generated on %s\n" % time.asctime())
113
115
    f.write("\n")
114
 
    for group in store.find(ProjectGroup):
115
 
        offering = group.project_set.offering
116
 
        reponame = "_".join([offering.subject.short_name,
117
 
                             offering.semester.year,
118
 
                             offering.semester.semester,
119
 
                             group.name])
 
116
    for g in groups:
 
117
        projectsetid = g['projectsetid']
 
118
        offeringinfo = conn.get_offering_info(projectsetid)
 
119
        subj_short_name = offeringinfo['subj_short_name']
 
120
        year = offeringinfo['year']
 
121
        semester = offeringinfo['semester']
 
122
        reponame = "_".join([subj_short_name, year, semester, g['groupnm']])
120
123
        f.write("[%s:/]\n"%reponame)
121
 
        for user in group.members:
122
 
            f.write("%s = rw\n" % user.login)
 
124
        users = conn.get_projectgroup_members(g['groupid'])
 
125
        for u in users:
 
126
            f.write("%s = rw\n"%u['login'])
123
127
        f.write("\n")
124
128
    f.close()
125
 
    os.rename(temp_name, conf_name)
126
 
    chown_to_webserver(conf_name)
 
129
    os.rename(ivle.conf.svn_group_conf + ".new", ivle.conf.svn_group_conf)
 
130
    chown_to_webserver(ivle.conf.svn_group_conf)
127
131
 
128
 
def make_svn_auth(store, login, config, throw_on_error=True):
 
132
def make_svn_auth(login, throw_on_error=True):
129
133
    """Setup svn authentication for the given user.
130
 
       Uses the given DB store object. Does not commit to the db.
 
134
       FIXME: create local.auth entry
131
135
    """
132
 
    # filename is, eg, /var/lib/ivle/svn/ivle.auth
133
 
    filename = config['paths']['svn']['auth_ivle']
134
 
    passwd = hashlib.md5(uuid.uuid4().bytes).hexdigest()
135
 
    if os.path.exists(filename):
 
136
    passwd = md5.new(uuid.uuid4().bytes).digest().encode('hex')
 
137
    if os.path.exists(ivle.conf.svn_auth_ivle):
136
138
        create = ""
137
139
    else:
138
140
        create = "c"
139
141
 
140
 
    user = ivle.database.User.get_by_login(store, login)
141
 
    user.svn_pass = unicode(passwd)
 
142
    ivle.db.DB().update_user(login, svn_pass=passwd)
142
143
 
143
 
    res = os.system("htpasswd -%smb %s %s %s" % (create, filename,
 
144
    res = os.system("htpasswd -%smb %s %s %s" % (create,
 
145
                                              ivle.conf.svn_auth_ivle,
144
146
                                              login, passwd))
145
147
    if res != 0 and throw_on_error:
146
148
        raise Exception("Unable to create ivle-auth for %s" % login)
147
149
 
148
150
    # Make sure the file is owned by the web server
149
151
    if create == "c":
150
 
        chown_to_webserver(filename)
 
152
        chown_to_webserver(ivle.conf.svn_auth_ivle)
151
153
 
152
154
    return passwd
153
155
 
180
182
    return (to_add, to_remove)
181
183
 
182
184
 
183
 
def make_jail(user, config, force=True):
 
185
def make_jail(username, uid, force=True, svn_pass=None):
184
186
    """Creates a new user's jail space, in the jail directory as configured in
185
187
    conf.py.
186
188
 
191
193
 
192
194
    Chowns the user's directory within the jail to the given UID.
193
195
 
 
196
    Note: This takes separate username and uid arguments. The UID need not
 
197
    *necessarily* correspond to a Unix username at all, if all you are
 
198
    planning to do is setuid to it. This allows the caller the freedom of
 
199
    deciding the binding between username and uid, if any.
 
200
 
194
201
    force: If false, exception if jail already exists for this user.
195
202
    If true (default), overwrites it, but preserves home directory.
 
203
 
 
204
    svn_pass: If provided this will be a string, the randomly-generated
 
205
    Subversion password for this user (if you happen to already have it).
 
206
    If not provided, it will be read from the database.
196
207
    """
197
208
    # MUST run as root or some of this may fail
198
209
    if os.getuid() != 0:
199
210
        raise Exception("Must run make_jail as root")
200
211
    
201
212
    # tempdir is for putting backup homes in
202
 
    jail_src_base = config['paths']['jails']['src']
203
 
    tempdir = os.path.join(jail_src_base, '__temp__')
 
213
    tempdir = os.path.join(ivle.conf.jail_base, '__temp__')
204
214
    if not os.path.exists(tempdir):
205
215
        os.makedirs(tempdir)
206
216
    elif not os.path.isdir(tempdir):
207
217
        os.unlink(tempdir)
208
218
        os.mkdir(tempdir)
209
 
    userdir = os.path.join(jail_src_base, user.login)
 
219
    userdir = os.path.join(ivle.conf.jail_src_base, username)
210
220
    homedir = os.path.join(userdir, 'home')
211
 
    userhomedir = os.path.join(homedir, user.login)   # Return value
 
221
    userhomedir = os.path.join(homedir, username)   # Return value
212
222
 
213
223
    if os.path.exists(userdir):
214
224
        if not force:
220
230
        warnings.simplefilter('ignore')
221
231
        homebackup = os.tempnam(tempdir)
222
232
        warnings.resetwarnings()
223
 
        # Back up the /home directory, delete the entire jail, recreate the
224
 
        # jail directory tree, then copy the /home back
225
 
        # NOTE that shutil.move changed in Python 2.6, it now moves a
226
 
        # directory INTO the target (like `mv`), which it didn't use to do.
227
 
        # This code works regardless.
 
233
        # Note: shutil.move does not behave like "mv" - it does not put a file
 
234
        # into a directory if it already exists, just fails. Therefore it is
 
235
        # not susceptible to tmpnam symlink attack.
228
236
        shutil.move(homedir, homebackup)
229
237
        shutil.rmtree(userdir)
230
 
        os.makedirs(userdir)
 
238
        os.makedirs(homedir)
231
239
        shutil.move(homebackup, homedir)
232
240
        # Change the ownership of all the files to the right unixid
233
241
        logging.debug("chown %s's home directory files to uid %d"
234
 
            %(user.login, user.unixid))
235
 
        os.spawnvp(os.P_WAIT, 'chown', ['chown', '-R', '%d:%d' % (user.unixid,
236
 
                                        user.unixid), userhomedir])
 
242
            %(username, uid))
 
243
        os.chown(userhomedir, uid, uid)
 
244
        for root, dirs, files in os.walk(userhomedir):
 
245
            for fsobj in dirs + files:
 
246
                os.chown(os.path.join(root, fsobj), uid, uid)
237
247
    else:
238
248
        # No user jail exists
239
249
        # Set up the user's home directory
240
250
        os.makedirs(userhomedir)
241
251
        # Chown (and set the GID to the same as the UID).
242
 
        os.chown(userhomedir, user.unixid, user.unixid)
 
252
        os.chown(userhomedir, uid, uid)
243
253
        # Chmod to rwxr-xr-x (755)
244
254
        os.chmod(userhomedir, 0755)
245
255
 
246
 
    make_ivle_conf(user.login, userdir, user.svn_pass, config)
247
 
    make_etc_passwd(user.login, userdir, config['paths']['jails']['template'],
248
 
                    user.unixid)
 
256
    # There are 2 special files which need to be generated specific to this
 
257
    # user: ${python_site_packages}/lib/conf/conf.py and /etc/passwd.
 
258
    # "__" username "__" users are exempt (special)
 
259
    if not (username.startswith("__") and username.endswith("__")):
 
260
        make_conf_py(username, userdir, ivle.conf.jail_system, svn_pass)
 
261
        make_etc_passwd(username, userdir, ivle.conf.jail_system, uid)
249
262
 
250
263
    return userhomedir
251
264
 
252
 
def make_ivle_conf(username, user_jail_dir, svn_pass, sys_config):
 
265
def make_conf_py(username, user_jail_dir, staging_dir, svn_pass=None):
253
266
    """
254
267
    Creates (overwriting any existing file, and creating directories) a
255
 
    file /etc/ivle/ivle.conf in a given user's jail.
256
 
    @param username: Username.
257
 
    @param user_jail_dir: User's jail dir, ie. ['jails']['src'] + username
258
 
    @param svn_pass: User's SVN password.
259
 
    @param sys_config: An ivle.config.Config object (the system-wide config).
 
268
    file ${python_site_packages}/ivle/conf/conf.py in a given user's jail.
 
269
    username: Username.
 
270
    user_jail_dir: User's jail dir, ie. ivle.conf.jail_base + username
 
271
    staging_dir: The dir with the staging copy of the jail. (With the
 
272
        template conf.py file).
 
273
    svn_pass: As with make_jail. User's SVN password, but if not supplied,
 
274
        will look up in the DB.
260
275
    """
261
 
    conf_path = os.path.join(user_jail_dir, "etc/ivle/ivle.conf")
 
276
    template_conf_path = os.path.join(staging_dir,
 
277
            ivle.conf.python_site_packages[1:], "ivle/conf/conf.py")
 
278
    conf_path = os.path.join(user_jail_dir,
 
279
            ivle.conf.python_site_packages[1:], "ivle/conf/conf.py")
262
280
    os.makedirs(os.path.dirname(conf_path))
263
281
 
264
 
    # In the "in-jail" version of conf, we don't need MOST of the details
265
 
    # (it would be a security risk to have them here).
266
 
    # So we just write root_dir.
267
 
    conf_obj = ivle.config.Config(blank=True)
268
 
    conf_obj.filename = conf_path
269
 
    conf_obj['urls']['root'] = sys_config['urls']['root']
270
 
    conf_obj['urls']['public_host'] = sys_config['urls']['public_host']
271
 
    conf_obj['urls']['svn_addr'] = sys_config['urls']['svn_addr']
272
 
    conf_obj['user_info']['login'] = username
273
 
    conf_obj['user_info']['svn_pass'] = svn_pass
274
 
    conf_obj.write()
 
282
    # If svn_pass isn't supplied, grab it from the DB
 
283
    if svn_pass is None:
 
284
        dbconn = ivle.db.DB()
 
285
        svn_pass = dbconn.get_user(username).svn_pass
 
286
        dbconn.close()
 
287
 
 
288
    # Read the contents of the template conf file
 
289
    try:
 
290
        template_conf_file = open(template_conf_path, "r")
 
291
        template_conf_data = template_conf_file.read()
 
292
        template_conf_file.close()
 
293
    except:
 
294
        # Couldn't open template conf.py for some reason
 
295
        # Just treat it as empty file
 
296
        template_conf_data = ("# Warning: Problem building config script.\n"
 
297
                              "# Could not find template conf.py file.\n")
 
298
 
 
299
    conf_file = open(conf_path, "w")
 
300
    conf_file.write(template_conf_data)
 
301
    conf_file.write("\n# The login name for the owner of the jail\n")
 
302
    conf_file.write("login = %s\n" % repr(username))
 
303
    conf_file.write("\n")
 
304
    conf_file.write("# The subversion-only password for the owner of "
 
305
        "the jail\n")
 
306
    conf_file.write("svn_pass = %s\n" % repr(svn_pass))
 
307
    conf_file.close()
275
308
 
276
309
    # Make this file world-readable
277
310
    # (chmod 644 conf_path)
294
327
                      % (username, unixid, unixid, username))
295
328
    passwd_file.close()
296
329
 
297
 
def mount_jail(login, config):
 
330
def make_user_db(throw_on_error = True, **kwargs):
 
331
    """Creates a user's entry in the database, filling in all the fields.
 
332
    All arguments must be keyword args. They are the fields in the table.
 
333
    However, instead of supplying a "passhash", you must supply a
 
334
    "password" argument, which will be hashed internally.
 
335
    Also do not supply a state. All users are created in the "no_agreement"
 
336
    state.
 
337
    Also pulls the user's subjects using the configured subject pulldown
 
338
    module, and adds enrolments to the DB.
 
339
    Throws an exception if the user already exists.
 
340
    """
 
341
    dbconn = ivle.db.DB()
 
342
    dbconn.create_user(**kwargs)
 
343
    dbconn.close()
 
344
 
 
345
    if kwargs['password']:
 
346
        if os.path.exists(ivle.conf.svn_auth_local):
 
347
            create = ""
 
348
        else:
 
349
            create = "c"
 
350
        res = os.system("htpasswd -%smb %s %s %s" % (create,
 
351
                                                     ivle.conf.svn_auth_local,
 
352
                                                     kwargs['login'],
 
353
                                                     kwargs['password']))
 
354
        if res != 0 and throw_on_error:
 
355
            raise Exception("Unable to create local-auth for %s" % kwargs['login'])
 
356
 
 
357
    # Make sure the file is owned by the web server
 
358
    if create == "c":
 
359
        chown_to_webserver(ivle.conf.svn_auth_local)
 
360
 
 
361
    # Pulldown subjects and add enrolments
 
362
    ivle.pulldown_subj.enrol_user(kwargs['login'])
 
363
 
 
364
def mount_jail(login):
298
365
    # This is where we'll mount to...
299
 
    destdir = os.path.join(config['paths']['jails']['mounts'], login)
 
366
    destdir = os.path.join(ivle.conf.jail_base, login)
300
367
    # ... and this is where we'll get the user bits.
301
 
    srcdir = os.path.join(config['paths']['jails']['src'], login)
 
368
    srcdir = os.path.join(ivle.conf.jail_src_base, login)
302
369
    try:
303
370
        if not os.path.exists(destdir):
304
371
            os.mkdir(destdir)
305
372
        if os.system('/bin/mount -t aufs -o dirs=%s:%s=ro none %s'
306
 
                     % (srcdir, config['paths']['jails']['template'],
307
 
                        destdir)) == 0:
 
373
                     % (srcdir, ivle.conf.jail_system, destdir)) == 0:
308
374
            logging.info("mounted user %s's jail." % login)
309
375
        else:
310
376
            logging.error("failed to mount user %s's jail!" % login)