← 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-27 10:29:16 UTC
  • Revision ID: svn-v3-trunk0:2b9c9e99-6f39-0410-b283-7f802c844ae2:trunk:954
Added svn:ignore on some directories.

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(path, throw_on_error=True):
 
63
    """Create a Subversion repository at the given path.
 
64
    """
 
65
    try:
 
66
        res = os.system("svnadmin create '%s'" % path)
 
67
        if res != 0 and throw_on_error:
 
68
            raise Exception("Cannot create repository for %s" % login)
 
69
    except Exception, exc:
 
70
        print repr(exc)
 
71
        if throw_on_error:
 
72
            raise
 
73
 
 
74
    chown_to_webserver(path)
 
75
 
 
76
def rebuild_svn_config():
 
77
    """Build the complete SVN configuration file.
 
78
    """
 
79
    conn = db.DB()
 
80
    users = conn.get_users()
 
81
    groups = {}
 
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(conf.svn_conf + ".new", "w")
 
88
    f.write("# IVLE SVN Repositories Configuration\n")
 
89
    f.write("# Auto-generated on %s\n" % time.asctime())
 
90
    f.write("\n")
 
91
    f.write("[groups]\n")
 
92
    for (g,ls) in groups.iteritems():
 
93
        f.write("%s = %s\n" % (g, ",".join(ls)))
 
94
    f.write("\n")
 
95
    for u in users:
 
96
        f.write("[%s:/]\n" % u.login)
 
97
        f.write("%s = rw\n" % u.login)
 
98
        #f.write("@tutor = r\n")
 
99
        #f.write("@lecturer = rw\n")
 
100
        #f.write("@admin = rw\n")
 
101
        f.write("\n")
 
102
    f.close()
 
103
    os.rename(conf.svn_conf + ".new", conf.svn_conf)
 
104
    chown_to_webserver(conf.svn_conf)
 
105
 
 
106
def make_svn_auth(login, throw_on_error=True):
 
107
    """Setup svn authentication for the given user.
 
108
       FIXME: create local.auth entry
 
109
    """
 
110
    passwd = md5.new(uuid.uuid4().bytes).digest().encode('hex')
 
111
    if os.path.exists(conf.svn_auth_ivle):
 
112
        create = ""
 
113
    else:
 
114
        create = "c"
 
115
 
 
116
    db.DB().update_user(login, svn_pass=passwd)
 
117
 
 
118
    res = os.system("htpasswd -%smb %s %s %s" % (create,
 
119
                                              conf.svn_auth_ivle,
 
120
                                              login, passwd))
 
121
    if res != 0 and throw_on_error:
 
122
        raise Exception("Unable to create ivle-auth for %s" % login)
 
123
 
 
124
    # Make sure the file is owned by the web server
 
125
    if create == "c":
 
126
        chown_to_webserver(conf.svn_auth_ivle)
 
127
 
 
128
    return passwd
 
129
 
 
130
def generate_manifest(basedir, targetdir, parent=''):
 
131
    """ From a basedir and a targetdir work out which files are missing or out 
 
132
    of date and need to be added/updated and which files are redundant and need 
 
133
    to be removed.
 
134
    
 
135
    parent: This is used for the recursive call to track the relative paths 
 
136
    that we have decended.
 
137
    """
 
138
    
 
139
    cmp = filecmp.dircmp(basedir, targetdir)
 
140
 
 
141
    # Add all new files and files that have changed
 
142
    to_add = [os.path.join(parent,x) for x in (cmp.left_only + cmp.diff_files)]
 
143
 
 
144
    # Remove files that are redundant
 
145
    to_remove = [os.path.join(parent,x) for x in cmp.right_only]
 
146
    
 
147
    # Recurse
 
148
    for d in cmp.common_dirs:
 
149
        newbasedir = os.path.join(basedir, d)
 
150
        newtargetdir = os.path.join(targetdir, d)
 
151
        newparent = os.path.join(parent, d)
 
152
        (sadd,sremove) = generate_manifest(newbasedir, newtargetdir, newparent)
 
153
        to_add += sadd
 
154
        to_remove += sremove
 
155
 
 
156
    return (to_add, to_remove)
 
157
 
 
158
 
 
159
def make_jail(username, uid, force=True, svn_pass=None):
 
160
    """Creates a new user's jail space, in the jail directory as configured in
 
161
    conf.py.
 
162
 
 
163
    This only creates things within /home - everything else is expected to be
 
164
    part of another UnionFS branch.
 
165
 
 
166
    Returns the path to the user's home directory.
 
167
 
 
168
    Chowns the user's directory within the jail to the given UID.
 
169
 
 
170
    Note: This takes separate username and uid arguments. The UID need not
 
171
    *necessarily* correspond to a Unix username at all, if all you are
 
172
    planning to do is setuid to it. This allows the caller the freedom of
 
173
    deciding the binding between username and uid, if any.
 
174
 
 
175
    force: If false, exception if jail already exists for this user.
 
176
    If true (default), overwrites it, but preserves home directory.
 
177
 
 
178
    svn_pass: If provided this will be a string, the randomly-generated
 
179
    Subversion password for this user (if you happen to already have it).
 
180
    If not provided, it will be read from the database.
 
181
    """
 
182
    # MUST run as root or some of this may fail
 
183
    if os.getuid() != 0:
 
184
        raise Exception("Must run make_jail as root")
 
185
    
 
186
    # tempdir is for putting backup homes in
 
187
    tempdir = os.path.join(conf.jail_base, '__temp__')
 
188
    if not os.path.exists(tempdir):
 
189
        os.makedirs(tempdir)
 
190
    elif not os.path.isdir(tempdir):
 
191
        os.unlink(tempdir)
 
192
        os.mkdir(tempdir)
 
193
    userdir = os.path.join(conf.jail_src_base, username)
 
194
    homedir = os.path.join(userdir, 'home')
 
195
    userhomedir = os.path.join(homedir, username)   # Return value
 
196
 
 
197
    if os.path.exists(userdir):
 
198
        if not force:
 
199
            raise Exception("User's jail already exists")
 
200
        # User jail already exists. Blow it away but preserve their home
 
201
        # directory. It should be all that is there anyway, but you never
 
202
        # know!
 
203
        # Ignore warnings about the use of tmpnam
 
204
        warnings.simplefilter('ignore')
 
205
        homebackup = os.tempnam(tempdir)
 
206
        warnings.resetwarnings()
 
207
        # Note: shutil.move does not behave like "mv" - it does not put a file
 
208
        # into a directory if it already exists, just fails. Therefore it is
 
209
        # not susceptible to tmpnam symlink attack.
 
210
        shutil.move(homedir, homebackup)
 
211
        shutil.rmtree(userdir)
 
212
        os.makedirs(homedir)
 
213
        shutil.move(homebackup, homedir)
 
214
        # Change the ownership of all the files to the right unixid
 
215
        logging.debug("chown %s's home directory files to uid %d"
 
216
            %(username, uid))
 
217
        os.chown(userhomedir, uid, uid)
 
218
        for root, dirs, files in os.walk(userhomedir):
 
219
            for fsobj in dirs + files:
 
220
                os.chown(os.path.join(root, fsobj), uid, uid)
 
221
    else:
 
222
        # No user jail exists
 
223
        # Set up the user's home directory
 
224
        os.makedirs(userhomedir)
 
225
        # Chown (and set the GID to the same as the UID).
 
226
        os.chown(userhomedir, uid, uid)
 
227
        # Chmod to rwxr-xr-x (755)
 
228
        os.chmod(userhomedir, 0755)
 
229
 
 
230
    # There are 2 special files which need to be generated specific to this
 
231
    # user: /opt/ivle/lib/conf/conf.py and /etc/passwd.
 
232
    # "__" username "__" users are exempt (special)
 
233
    if not (username.startswith("__") and username.endswith("__")):
 
234
        make_conf_py(username, userdir, conf.jail_system, svn_pass)
 
235
        make_etc_passwd(username, userdir, conf.jail_system, uid)
 
236
 
 
237
    return userhomedir
 
238
 
 
239
def make_conf_py(username, user_jail_dir, staging_dir, svn_pass=None):
 
240
    """
 
241
    Creates (overwriting any existing file, and creating directories) a
 
242
    file /opt/ivle/lib/conf/conf.py in a given user's jail.
 
243
    username: Username.
 
244
    user_jail_dir: User's jail dir, ie. conf.jail_base + username
 
245
    staging_dir: The dir with the staging copy of the jail. (With the
 
246
        template conf.py file).
 
247
    svn_pass: As with make_jail. User's SVN password, but if not supplied,
 
248
        will look up in the DB.
 
249
    """
 
250
    template_conf_path = os.path.join(staging_dir,"opt/ivle/lib/conf/conf.py")
 
251
    conf_path = os.path.join(user_jail_dir, "opt/ivle/lib/conf/conf.py")
 
252
    os.makedirs(os.path.dirname(conf_path))
 
253
 
 
254
    # If svn_pass isn't supplied, grab it from the DB
 
255
    if svn_pass is None:
 
256
        dbconn = db.DB()
 
257
        svn_pass = dbconn.get_user(username).svn_pass
 
258
        dbconn.close()
 
259
 
 
260
    # Read the contents of the template conf file
 
261
    try:
 
262
        template_conf_file = open(template_conf_path, "r")
 
263
        template_conf_data = template_conf_file.read()
 
264
        template_conf_file.close()
 
265
    except:
 
266
        # Couldn't open template conf.py for some reason
 
267
        # Just treat it as empty file
 
268
        template_conf_data = ("# Warning: Problem building config script.\n"
 
269
                              "# Could not find template conf.py file.\n")
 
270
 
 
271
    conf_file = open(conf_path, "w")
 
272
    conf_file.write(template_conf_data)
 
273
    conf_file.write("\n# The login name for the owner of the jail\n")
 
274
    conf_file.write("login = %s\n" % repr(username))
 
275
    conf_file.write("\n")
 
276
    conf_file.write("# The subversion-only password for the owner of "
 
277
        "the jail\n")
 
278
    conf_file.write("svn_pass = %s\n" % repr(svn_pass))
 
279
    conf_file.close()
 
280
 
 
281
    # Make this file world-readable
 
282
    # (chmod 644 conf_path)
 
283
    os.chmod(conf_path, stat.S_IRUSR | stat.S_IWUSR | stat.S_IRGRP
 
284
                        | stat.S_IROTH)
 
285
 
 
286
def make_etc_passwd(username, user_jail_dir, template_dir, unixid):
 
287
    """
 
288
    Creates /etc/passwd in the given user's jail. This will be identical to
 
289
    that in the template jail, except for the added entry for this user.
 
290
    """
 
291
    template_passwd_path = os.path.join(template_dir, "etc/passwd")
 
292
    passwd_path = os.path.join(user_jail_dir, "etc/passwd")
 
293
    passwd_dir = os.path.dirname(passwd_path)
 
294
    if not os.path.exists(passwd_dir):
 
295
        os.makedirs(passwd_dir)
 
296
    shutil.copy(template_passwd_path, passwd_path)
 
297
    passwd_file = open(passwd_path, 'a')
 
298
    passwd_file.write('%s:x:%d:%d::/home/%s:/bin/bash'
 
299
                      % (username, unixid, unixid, username))
 
300
    passwd_file.close()
 
301
 
 
302
def linktree(src, dst):
 
303
    """Recursively hard-link a directory tree using os.link().
 
304
 
 
305
    The destination directory must not already exist.
 
306
    If exception(s) occur, an Error is raised with a list of reasons.
 
307
 
 
308
    Symlinks are preserved (in fact, hard links are created which point to the
 
309
    symlinks).
 
310
 
 
311
    Code heavily based upon shutil.copytree from Python 2.5 library.
 
312
    """
 
313
    names = os.listdir(src)
 
314
    os.makedirs(dst)
 
315
    errors = []
 
316
    for name in names:
 
317
        srcname = os.path.join(src, name)
 
318
        dstname = os.path.join(dst, name)
 
319
        try:
 
320
            if os.path.isdir(srcname):
 
321
                linktree(srcname, dstname)
 
322
            else:
 
323
                os.link(srcname, dstname)
 
324
            # XXX What about devices, sockets etc.?
 
325
        except (IOError, os.error), why:
 
326
            errors.append((srcname, dstname, str(why)))
 
327
        # catch the Error from the recursive copytree so that we can
 
328
        # continue with other files
 
329
        except Exception, err:
 
330
            errors.append(err.args[0])
 
331
    try:
 
332
        shutil.copystat(src, dst)
 
333
    except WindowsError:
 
334
        # can't copy file access times on Windows
 
335
        pass
 
336
    except OSError, why:
 
337
        errors.extend((src, dst, str(why)))
 
338
    if errors:
 
339
        raise Exception, errors
 
340
 
 
341
def make_user_db(throw_on_error = True, **kwargs):
 
342
    """Creates a user's entry in the database, filling in all the fields.
 
343
    All arguments must be keyword args. They are the fields in the table.
 
344
    However, instead of supplying a "passhash", you must supply a
 
345
    "password" argument, which will be hashed internally.
 
346
    Also do not supply a state. All users are created in the "no_agreement"
 
347
    state.
 
348
    Also pulls the user's subjects using the configured subject pulldown
 
349
    module, and adds enrolments to the DB.
 
350
    Throws an exception if the user already exists.
 
351
    """
 
352
    dbconn = db.DB()
 
353
    dbconn.create_user(**kwargs)
 
354
    dbconn.close()
 
355
 
 
356
    if kwargs['password']:
 
357
        if os.path.exists(conf.svn_auth_local):
 
358
            create = ""
 
359
        else:
 
360
            create = "c"
 
361
        res = os.system("htpasswd -%smb %s %s %s" % (create,
 
362
                                                     conf.svn_auth_local,
 
363
                                                     kwargs['login'],
 
364
                                                     kwargs['password']))
 
365
        if res != 0 and throw_on_error:
 
366
            raise Exception("Unable to create local-auth for %s" % kwargs['login'])
 
367
 
 
368
    # Make sure the file is owned by the web server
 
369
    if create == "c":
 
370
        chown_to_webserver(conf.svn_auth_local)
 
371
 
 
372
    # Pulldown subjects and add enrolments
 
373
    pulldown_subj.enrol_user(kwargs['login'])
 
374
 
 
375
def mount_jail(login):
 
376
    # This is where we'll mount to...
 
377
    destdir = os.path.join(conf.jail_base, login)
 
378
    # ... and this is where we'll get the user bits.
 
379
    srcdir = os.path.join(conf.jail_src_base, login)
 
380
    try:
 
381
        if not os.path.exists(destdir):
 
382
            os.mkdir(destdir)
 
383
        if os.system('/bin/mount -t aufs -o dirs=%s:%s=ro none %s'
 
384
                     % (srcdir, conf.jail_system, destdir)) == 0:
 
385
            logging.info("mounted user %s's jail." % login)
 
386
        else:
 
387
            logging.error("failed to mount user %s's jail!" % login)
 
388
    except Exception, message:
 
389
        logging.warning(str(message))