← 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
45
45
import filecmp
46
46
import logging
47
47
import ivle.conf
 
48
import ivle.db
48
49
import ivle.pulldown_subj
49
50
 
50
 
from ivle.database import ProjectGroup
51
 
 
52
51
def chown_to_webserver(filename):
53
52
    """
54
53
    Chowns a file so the web server user owns it.
74
73
 
75
74
    chown_to_webserver(path)
76
75
 
77
 
def rebuild_svn_config(store):
 
76
def rebuild_svn_config():
78
77
    """Build the complete SVN configuration file.
79
78
    """
80
 
    users = store.find(ivle.database.User)
 
79
    conn = ivle.db.DB()
 
80
    users = conn.get_users()
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(store):
 
106
def rebuild_svn_group_config():
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'])
109
112
    f = open(ivle.conf.svn_group_conf + ".new", "w")
110
113
    f.write("# IVLE SVN Group Repositories Configuration\n")
111
114
    f.write("# Auto-generated on %s\n" % time.asctime())
112
115
    f.write("\n")
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])
 
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']])
119
123
        f.write("[%s:/]\n"%reponame)
120
 
        for user in group.members:
121
 
            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'])
122
127
        f.write("\n")
123
128
    f.close()
124
129
    os.rename(ivle.conf.svn_group_conf + ".new", ivle.conf.svn_group_conf)
125
130
    chown_to_webserver(ivle.conf.svn_group_conf)
126
131
 
127
 
def make_svn_auth(store, login, throw_on_error=True):
 
132
def make_svn_auth(login, throw_on_error=True):
128
133
    """Setup svn authentication for the given user.
129
 
       Uses the given DB store object. Does not commit to the db.
 
134
       FIXME: create local.auth entry
130
135
    """
131
136
    passwd = md5.new(uuid.uuid4().bytes).digest().encode('hex')
132
137
    if os.path.exists(ivle.conf.svn_auth_ivle):
134
139
    else:
135
140
        create = "c"
136
141
 
137
 
    user = ivle.database.User.get_by_login(store, login)
138
 
    user.svn_pass = unicode(passwd)
 
142
    ivle.db.DB().update_user(login, svn_pass=passwd)
139
143
 
140
144
    res = os.system("htpasswd -%smb %s %s %s" % (create,
141
145
                                              ivle.conf.svn_auth_ivle,
178
182
    return (to_add, to_remove)
179
183
 
180
184
 
181
 
def make_jail(user, force=True):
 
185
def make_jail(username, uid, force=True, svn_pass=None):
182
186
    """Creates a new user's jail space, in the jail directory as configured in
183
187
    conf.py.
184
188
 
189
193
 
190
194
    Chowns the user's directory within the jail to the given UID.
191
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
 
192
201
    force: If false, exception if jail already exists for this user.
193
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.
194
207
    """
195
208
    # MUST run as root or some of this may fail
196
209
    if os.getuid() != 0:
203
216
    elif not os.path.isdir(tempdir):
204
217
        os.unlink(tempdir)
205
218
        os.mkdir(tempdir)
206
 
    userdir = os.path.join(ivle.conf.jail_src_base, user.login)
 
219
    userdir = os.path.join(ivle.conf.jail_src_base, username)
207
220
    homedir = os.path.join(userdir, 'home')
208
 
    userhomedir = os.path.join(homedir, user.login)   # Return value
 
221
    userhomedir = os.path.join(homedir, username)   # Return value
209
222
 
210
223
    if os.path.exists(userdir):
211
224
        if not force:
226
239
        shutil.move(homebackup, homedir)
227
240
        # Change the ownership of all the files to the right unixid
228
241
        logging.debug("chown %s's home directory files to uid %d"
229
 
            %(user.login, user.unixid))
230
 
        os.chown(userhomedir, user.unixid, user.unixid)
 
242
            %(username, uid))
 
243
        os.chown(userhomedir, uid, uid)
231
244
        for root, dirs, files in os.walk(userhomedir):
232
245
            for fsobj in dirs + files:
233
 
                os.chown(os.path.join(root, fsobj), user.unixid, user.unixid)
 
246
                os.chown(os.path.join(root, fsobj), uid, uid)
234
247
    else:
235
248
        # No user jail exists
236
249
        # Set up the user's home directory
237
250
        os.makedirs(userhomedir)
238
251
        # Chown (and set the GID to the same as the UID).
239
 
        os.chown(userhomedir, user.unixid, user.unixid)
 
252
        os.chown(userhomedir, uid, uid)
240
253
        # Chmod to rwxr-xr-x (755)
241
254
        os.chmod(userhomedir, 0755)
242
255
 
243
 
    make_conf_py(user.login, userdir, user.svn_pass)
244
 
    make_etc_passwd(user.login, userdir, ivle.conf.jail_system, 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)
245
262
 
246
263
    return userhomedir
247
264
 
248
 
def make_conf_py(username, user_jail_dir, svn_pass):
 
265
def make_conf_py(username, user_jail_dir, staging_dir, svn_pass=None):
249
266
    """
250
267
    Creates (overwriting any existing file, and creating directories) a
251
268
    file ${python_site_packages}/ivle/conf/conf.py in a given user's jail.
252
269
    username: Username.
253
270
    user_jail_dir: User's jail dir, ie. ivle.conf.jail_base + username
254
 
    svn_pass: User's SVN password.
 
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.
255
275
    """
 
276
    template_conf_path = os.path.join(staging_dir,
 
277
            ivle.conf.python_site_packages[1:], "ivle/conf/conf.py")
256
278
    conf_path = os.path.join(user_jail_dir,
257
279
            ivle.conf.python_site_packages[1:], "ivle/conf/conf.py")
258
280
    os.makedirs(os.path.dirname(conf_path))
259
281
 
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.
 
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
 
270
299
    conf_file = open(conf_path, "w")
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
 
      })
 
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))
299
307
    conf_file.close()
300
308
 
301
309
    # Make this file world-readable
319
327
                      % (username, unixid, unixid, username))
320
328
    passwd_file.close()
321
329
 
 
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
 
322
364
def mount_jail(login):
323
365
    # This is where we'll mount to...
324
366
    destdir = os.path.join(ivle.conf.jail_base, login)