196 lines
7.1 KiB
Python
196 lines
7.1 KiB
Python
import os
|
|
import re
|
|
from subprocess import run, CalledProcessError, PIPE
|
|
from tempfile import TemporaryFile
|
|
|
|
from django.db.models import Model
|
|
from django.db.models.signals import pre_save, post_save, post_delete
|
|
from django.dispatch import receiver
|
|
from django.contrib.auth.models import User
|
|
from django.db.models import TextField, BooleanField, CharField, ForeignKey
|
|
from django.template.loader import get_template
|
|
|
|
from common.mailing import send_email
|
|
from help.models import Ticket
|
|
|
|
SSH_TYPE_CHOICES = (
|
|
('ssh-rsa', 'ssh-rsa',),
|
|
('ssh-dss', 'ssh-dss',),
|
|
)
|
|
|
|
KEYFILE_HEADER = """Hi! This file is automatically managed by tilde.town. You
|
|
probably shouldn't change it. If you want to add more public keys that's
|
|
totally fine: you can put them in ~/.ssh/authorized_keys"""
|
|
TMP_PATH = '/tmp/ttadmin'
|
|
|
|
ENSURE_PRESENT = 'present'
|
|
ENSURE_ABSENT = 'absent'
|
|
|
|
def user_in_passwd(username):
|
|
"""Given a username, returns either the user's line in passwd or None.
|
|
Opens and reads passwd every time. Memoize or something if this becomes an
|
|
issue."""
|
|
with open('/etc/passwd') as passwd:
|
|
for line in passwd:
|
|
if username == line.split(':')[0]:
|
|
return line.rstrip()
|
|
|
|
|
|
class Townie(User):
|
|
"""Both an almost normal Django User as well as an abstraction over a
|
|
system user."""
|
|
class Meta:
|
|
verbose_name = 'Townie'
|
|
verbose_name_plural = 'Townies'
|
|
shell = CharField(max_length=50, default="/bin/bash")
|
|
reviewed = BooleanField(default=False)
|
|
reasons = TextField(blank=True, null=False, default='')
|
|
displayname = CharField(max_length=100, blank=False, null=False)
|
|
|
|
def send_welcome_email(self, admin_name='vilmibm'):
|
|
welcome_tmpl = get_template('users/welcome_email.txt')
|
|
context = {
|
|
'username': self.username,
|
|
'admin_name': admin_name,
|
|
}
|
|
text = welcome_tmpl.render(context)
|
|
from_address = '{}@tilde.town'.format(admin_name)
|
|
success = send_email(self.email, text, subject='tilde.town!', frum=from_address)
|
|
if not success:
|
|
Ticket.objects.create(name='system',
|
|
email='root@tilde.town',
|
|
issue_type='other',
|
|
issue_text='was not able to send welcome email to {} ({})'.format(
|
|
self.username,
|
|
self.email))
|
|
|
|
# managing concrete system state
|
|
|
|
def reconcile(self, ensure):
|
|
assert(self.reviewed)
|
|
dot_ssh_path = '/home/{}/.ssh'.format(self.username)
|
|
if ensure == ENSURE_ABSENT:
|
|
# TODO delete
|
|
# This is manual for now because it very rarely comes up and I want
|
|
# the present case to work.
|
|
pass
|
|
|
|
if ensure == ENSURE_PRESENT:
|
|
# TODO handle rename case either with update fields or a rename action
|
|
# Add the user
|
|
result = run(['sudo',
|
|
'adduser',
|
|
'--quiet',
|
|
'--shell={}'.format(self.shell),
|
|
'--gecos="{}"'.format(self.displayname),
|
|
'--disabled-password',
|
|
self.username,],
|
|
check=True,
|
|
)
|
|
|
|
# Create .ssh
|
|
run(['sudo', '--user={}'.format(self.username), 'mkdir', dot_ssh_path])
|
|
|
|
# Write out authorized_keys file
|
|
with TemporaryFile(dir="/tmp") as fp:
|
|
fp.write(self.generate_authorized_keys().encode('utf-8'))
|
|
fp.seek(0)
|
|
run(['sudo',
|
|
'--user={}'.format(self.username),
|
|
'/opt/bin/create_keyfile.py',
|
|
self.username],
|
|
stdin=fp
|
|
)
|
|
|
|
def generate_authorized_keys(self):
|
|
"""returns a string suitable for writing out to an authorized_keys
|
|
file"""
|
|
content = KEYFILE_HEADER
|
|
pubkeys = Pubkey.objects.filter(townie=self)
|
|
for key in pubkeys:
|
|
if key.startswith('ssh-'):
|
|
content += '\n {}'.format(key.key)
|
|
else:
|
|
content += '\n{} {}'.format(key.key_type, key.key)
|
|
|
|
return content
|
|
|
|
|
|
class Pubkey(Model):
|
|
key_type = CharField(max_length=50,
|
|
blank=False,
|
|
null=False,
|
|
choices=SSH_TYPE_CHOICES,
|
|
)
|
|
key = TextField(blank=False, null=False)
|
|
townie = ForeignKey(Townie)
|
|
|
|
|
|
@receiver(pre_save, sender=Townie)
|
|
def on_townie_pre_save(sender, instance, **kwargs):
|
|
existing = Townie.objects.filter(username=instance.username)
|
|
if not existing: # we're making a new user
|
|
return
|
|
|
|
if not existing[0].reviewed and instance.reviewed == True:
|
|
instance.send_welcome_email()
|
|
|
|
@receiver(post_save, sender=Townie)
|
|
def post_save_reconcile(sender, instance, **kwargs):
|
|
if not instance.reviewed:
|
|
return
|
|
instance.reconcile(ENSURE_PRESENT)
|
|
|
|
@receiver(post_delete, sender=Townie)
|
|
def post_delete_reconcile(sender, instance, **kwargs):
|
|
if not instance.reviewed:
|
|
# TODO should i actually do this check?
|
|
# I might want to make it such that users can never become un-reviewed.
|
|
return
|
|
instance.reconcile(ENSURE_ABSENT)
|
|
|
|
# what the puppet module does:
|
|
# * creates user account
|
|
# * creates home directory
|
|
# * creates authorized_keys2
|
|
# * adds user to group 'tilde' (why?)
|
|
# * sets shell
|
|
# * creates .ssh directory
|
|
# * creates .irssi directory
|
|
# * creates templatized .irssi config file (irssi isn't even default anymore...)
|
|
# * creates hardcoded .twurlrc file (why not skel?)
|
|
#
|
|
# some of this stuff is pointless and the actually required stuff is:
|
|
# * create user account (useradd)
|
|
# * create home dir (useradd)
|
|
# * create .ssh/authorized_keys2 (need functions for this
|
|
# * set shell (chsh)
|
|
# * create .twurlrc (just use /etc/skel)
|
|
|
|
# other things to consider:
|
|
# * what happens when a user wants their name changed?
|
|
# * it looks like usermod -l and a mv of the home dir can change a user's username.
|
|
# * would hook this into the pre_save signal to note a username change
|
|
# * what happens when a user is marked as not reviewed?
|
|
# * does this signal user deletion? Or does literal Townie deletion signal
|
|
# "needs to be removed from disk"? I think it makes the most sense for the
|
|
# latter to imply full user deletion.
|
|
# * I honestly can't even think of a reason to revert a user to "not reviewed"
|
|
# and perhaps it's best to just not make that possible. for now, though, I
|
|
# think I can ignore it.
|
|
# * what happens when a user needs to be banned?
|
|
# * the Townie should be deleted via post_delete signal
|
|
# * what are things about a user that might change in django and require changes on disk?
|
|
# * username
|
|
# * displayname (only if i start using this?)
|
|
# * ssh key
|
|
#
|
|
# how should this code be structured?
|
|
# * within the Townie model, hardcoded
|
|
# * outside the Townie model, procedurally
|
|
# * within an abstract class
|
|
#
|
|
# for now my gut says to implement stuff hardcoded in the Townie class but with
|
|
# an eye towards generalizing the pattern in some base class for other
|
|
# resources as needed.
|