← 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: William Grant
  • Date: 2009-04-29 05:19:27 UTC
  • Revision ID: grantw@unimelb.edu.au-20090429051927-iifguope5cmj6sik
URL-quote SVN repository paths in fileservice.

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