← Back to branch summary

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

« back to all changes in this revision

Viewing changes to ivle/makeuser.py

  • Committer: Matt Giuca
  • Date: 2009-02-24 02:02:03 UTC
  • mto: This revision was merged to the branch mainline in revision 1119.
  • Revision ID: matt.giuca@gmail.com-20090224020203-aqdcjnsj6y7wl32o
Added a new look to the IVLE header bar. Mmmm... Web 2.0.
Added top-level directory image-source, containing SVG and script files for
    generating the images.
ivle/webapp/coremedia/images: Added 'chrome' directory containing the rendered
    images.
Modified ivle/webapp/base/ivle-headings.html and
    ivle/webapp/coremedia/ivle.css to support the new images.
    Note that the H1 and H2 at the top of the page are no longer displayed
    (and their custom styles have been removed). There is a heading image
    instead.

Show diffs side-by-side

added added

removed removed

Lines of Context:
ivle/makeuser.py
45
45
import filecmp
46
46
import logging
47
47
import ivle.conf
48
 
import ivle.db
49
48
import ivle.pulldown_subj
50
49
 
 
50
from ivle.database import ProjectGroup
 
51
 
51
52
def chown_to_webserver(filename):
52
53
    """
53
54
    Chowns a file so the web server user owns it.
73
74
 
74
75
    chown_to_webserver(path)
75
76
 
76
 
def rebuild_svn_config():
 
77
def rebuild_svn_config(store):
77
78
    """Build the complete SVN configuration file.
78
79
    """
79
 
    conn = ivle.db.DB()
80
 
    users = conn.get_users()
 
80
    users = store.find(ivle.database.User)
81
81
    groups = {}
82
82
    for u in users:
83
83
        role = str(u.role)
103
103
    os.rename(ivle.conf.svn_conf + ".new", ivle.conf.svn_conf)
104
104
    chown_to_webserver(ivle.conf.svn_conf)
105
105
 
106
 
def rebuild_svn_group_config():
 
106
def rebuild_svn_group_config(store):
107
107
    """Build the complete SVN configuration file for groups
108
108
    """
109
 
    conn = ivle.db.DB()
110
 
    groups = conn.get_all('project_group',
111
 
        ['groupid', 'groupnm', 'projectsetid'])
112
109
    f = open(ivle.conf.svn_group_conf + ".new", "w")
113
110
    f.write("# IVLE SVN Group Repositories Configuration\n")
114
111
    f.write("# Auto-generated on %s\n" % time.asctime())
115
112
    f.write("\n")
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']])
 
113
    for group in store.find(ProjectGroup):
 
114
        offering = group.project_set.offering
 
115
        reponame = "_".join([offering.subject.short_name,
 
116
                             offering.semester.year,
 
117
                             offering.semester.semester,
 
118
                             group.name])
123
119
        f.write("[%s:/]\n"%reponame)
124
 
        users = conn.get_projectgroup_members(g['groupid'])
125
 
        for u in users:
126
 
            f.write("%s = rw\n"%u['login'])
 
120
        for user in group.members:
 
121
            f.write("%s = rw\n" % user.login)
127
122
        f.write("\n")
128
123
    f.close()
129
124
    os.rename(ivle.conf.svn_group_conf + ".new", ivle.conf.svn_group_conf)
132
127
def make_svn_auth(store, login, throw_on_error=True):
133
128
    """Setup svn authentication for the given user.
134
129
       Uses the given DB store object. Does not commit to the db.
135
 
       FIXME: create local.auth entry
136
130
    """
137
131
    passwd = md5.new(uuid.uuid4().bytes).digest().encode('hex')
138
132
    if os.path.exists(ivle.conf.svn_auth_ivle):
184
178
    return (to_add, to_remove)
185
179
 
186
180
 
187
 
def make_jail(username, uid, force=True, svn_pass=None):
 
181
def make_jail(user, force=True):
188
182
    """Creates a new user's jail space, in the jail directory as configured in
189
183
    conf.py.
190
184
 
195
189
 
196
190
    Chowns the user's directory within the jail to the given UID.
197
191
 
198
 
    Note: This takes separate username and uid arguments. The UID need not
199
 
    *necessarily* correspond to a Unix username at all, if all you are
200
 
    planning to do is setuid to it. This allows the caller the freedom of
201
 
    deciding the binding between username and uid, if any.
202
 
 
203
192
    force: If false, exception if jail already exists for this user.
204
193
    If true (default), overwrites it, but preserves home directory.
205
 
 
206
 
    svn_pass: If provided this will be a string, the randomly-generated
207
 
    Subversion password for this user (if you happen to already have it).
208
 
    If not provided, it will be read from the database.
209
194
    """
210
195
    # MUST run as root or some of this may fail
211
196
    if os.getuid() != 0:
218
203
    elif not os.path.isdir(tempdir):
219
204
        os.unlink(tempdir)
220
205
        os.mkdir(tempdir)
221
 
    userdir = os.path.join(ivle.conf.jail_src_base, username)
 
206
    userdir = os.path.join(ivle.conf.jail_src_base, user.login)
222
207
    homedir = os.path.join(userdir, 'home')
223
 
    userhomedir = os.path.join(homedir, username)   # Return value
 
208
    userhomedir = os.path.join(homedir, user.login)   # Return value
224
209
 
225
210
    if os.path.exists(userdir):
226
211
        if not force:
241
226
        shutil.move(homebackup, homedir)
242
227
        # Change the ownership of all the files to the right unixid
243
228
        logging.debug("chown %s's home directory files to uid %d"
244
 
            %(username, uid))
245
 
        os.chown(userhomedir, uid, uid)
 
229
            %(user.login, user.unixid))
 
230
        os.chown(userhomedir, user.unixid, user.unixid)
246
231
        for root, dirs, files in os.walk(userhomedir):
247
232
            for fsobj in dirs + files:
248
 
                os.chown(os.path.join(root, fsobj), uid, uid)
 
233
                os.chown(os.path.join(root, fsobj), user.unixid, user.unixid)
249
234
    else:
250
235
        # No user jail exists
251
236
        # Set up the user's home directory
252
237
        os.makedirs(userhomedir)
253
238
        # Chown (and set the GID to the same as the UID).
254
 
        os.chown(userhomedir, uid, uid)
 
239
        os.chown(userhomedir, user.unixid, user.unixid)
255
240
        # Chmod to rwxr-xr-x (755)
256
241
        os.chmod(userhomedir, 0755)
257
242
 
258
 
    # There are 2 special files which need to be generated specific to this
259
 
    # user: ${python_site_packages}/lib/conf/conf.py and /etc/passwd.
260
 
    # "__" username "__" users are exempt (special)
261
 
    if not (username.startswith("__") and username.endswith("__")):
262
 
        make_conf_py(username, userdir, ivle.conf.jail_system, svn_pass)
263
 
        make_etc_passwd(username, userdir, ivle.conf.jail_system, uid)
 
243
    make_conf_py(user.login, userdir, user.svn_pass)
 
244
    make_etc_passwd(user.login, userdir, ivle.conf.jail_system, user.unixid)
264
245
 
265
246
    return userhomedir
266
247
 
267
 
def make_conf_py(username, user_jail_dir, staging_dir, svn_pass=None):
 
248
def make_conf_py(username, user_jail_dir, svn_pass):
268
249
    """
269
250
    Creates (overwriting any existing file, and creating directories) a
270
251
    file ${python_site_packages}/ivle/conf/conf.py in a given user's jail.
271
252
    username: Username.
272
253
    user_jail_dir: User's jail dir, ie. ivle.conf.jail_base + username
273
 
    staging_dir: The dir with the staging copy of the jail. (With the
274
 
        template conf.py file).
275
 
    svn_pass: As with make_jail. User's SVN password, but if not supplied,
276
 
        will look up in the DB.
 
254
    svn_pass: User's SVN password.
277
255
    """
278
 
    template_conf_path = os.path.join(staging_dir,
279
 
            ivle.conf.python_site_packages[1:], "ivle/conf/conf.py")
280
256
    conf_path = os.path.join(user_jail_dir,
281
257
            ivle.conf.python_site_packages[1:], "ivle/conf/conf.py")
282
258
    os.makedirs(os.path.dirname(conf_path))
283
259
 
284
 
    # If svn_pass isn't supplied, grab it from the DB
285
 
    if svn_pass is None:
286
 
        dbconn = ivle.db.DB()
287
 
        svn_pass = dbconn.get_user(username).svn_pass
288
 
        dbconn.close()
289
 
 
290
 
    # Read the contents of the template conf file
291
 
    try:
292
 
        template_conf_file = open(template_conf_path, "r")
293
 
        template_conf_data = template_conf_file.read()
294
 
        template_conf_file.close()
295
 
    except:
296
 
        # Couldn't open template conf.py for some reason
297
 
        # Just treat it as empty file
298
 
        template_conf_data = ("# Warning: Problem building config script.\n"
299
 
                              "# Could not find template conf.py file.\n")
300
 
 
 
260
    # In the "in-jail" version of conf, we don't need MOST of the details
 
261
    # (it would be a security risk to have them here).
 
262
    # So we just write root_dir, and jail_base is "/".
 
263
    # (jail_base being "/" means "jail-relative" paths are relative to "/"
 
264
    # when inside the jail.)
 
265
 
 
266
    # XXX: jail_base is wrong and shouldn't be here. Unfortunately, jail code
 
267
    #      uses ivle.studpath.url_to_{local,jailpaths}, both of which use
 
268
    #      jail_base. Note that they don't use the bits of the return value
 
269
    #      that depend on jail_base, so it can be any string.
301
270
    conf_file = open(conf_path, "w")
302
 
    conf_file.write(template_conf_data)
303
 
    conf_file.write("\n# The login name for the owner of the jail\n")
304
 
    conf_file.write("login = %s\n" % repr(username))
305
 
    conf_file.write("\n")
306
 
    conf_file.write("# The subversion-only password for the owner of "
307
 
        "the jail\n")
308
 
    conf_file.write("svn_pass = %s\n" % repr(svn_pass))
 
271
    conf_file.write("""# IVLE jail configuration
 
272
 
 
273
# In URL space, where in the site is IVLE located. (All URLs will be prefixed
 
274
# with this).
 
275
# eg. "/" or "/ivle".
 
276
root_dir = %(root_dir)r
 
277
 
 
278
# This value is not relevant inside the jail, but must remain for now. See
 
279
# the XXX in ivle.makeuser.make_conf_py.
 
280
jail_base = '/'
 
281
 
 
282
# The hostname for serving publicly accessible pages
 
283
public_host = %(public_host)r
 
284
 
 
285
# The URL under which the Subversion repositories are located.
 
286
svn_addr = %(svn_addr)r
 
287
 
 
288
# The login name for the owner of the jail
 
289
login = %(username)r
 
290
 
 
291
# The subversion-only password for the owner of the jail
 
292
svn_pass = %(svn_pass)r
 
293
""" % {'root_dir': ivle.conf.root_dir,
 
294
       'public_host': ivle.conf.public_host,
 
295
       'svn_addr': ivle.conf.svn_addr,
 
296
       'username': username,
 
297
       'svn_pass': svn_pass,
 
298
      })
309
299
    conf_file.close()
310
300
 
311
301
    # Make this file world-readable
329
319
                      % (username, unixid, unixid, username))
330
320
    passwd_file.close()
331
321
 
332
 
def make_user_db(throw_on_error = True, **kwargs):
333
 
    """Creates a user's entry in the database, filling in all the fields.
334
 
    All arguments must be keyword args. They are the fields in the table.
335
 
    However, instead of supplying a "passhash", you must supply a
336
 
    "password" argument, which will be hashed internally.
337
 
    Also do not supply a state. All users are created in the "no_agreement"
338
 
    state.
339
 
    Also pulls the user's subjects using the configured subject pulldown
340
 
    module, and adds enrolments to the DB.
341
 
    Throws an exception if the user already exists.
342
 
    """
343
 
    dbconn = ivle.db.DB()
344
 
    dbconn.create_user(**kwargs)
345
 
    dbconn.close()
346
 
 
347
 
    if kwargs['password']:
348
 
        if os.path.exists(ivle.conf.svn_auth_local):
349
 
            create = ""
350
 
        else:
351
 
            create = "c"
352
 
        res = os.system("htpasswd -%smb %s %s %s" % (create,
353
 
                                                     ivle.conf.svn_auth_local,
354
 
                                                     kwargs['login'],
355
 
                                                     kwargs['password']))
356
 
        if res != 0 and throw_on_error:
357
 
            raise Exception("Unable to create local-auth for %s" % kwargs['login'])
358
 
 
359
 
    # Make sure the file is owned by the web server
360
 
    if create == "c":
361
 
        chown_to_webserver(ivle.conf.svn_auth_local)
362
 
 
363
 
    # Pulldown subjects and add enrolments
364
 
    ivle.pulldown_subj.enrol_user(kwargs['login'])
365
 
 
366
322
def mount_jail(login):
367
323
    # This is where we'll mount to...
368
324
    destdir = os.path.join(ivle.conf.jail_base, login)