示例#1
0
def create_tables():
    """Create tables filled with test data."""

    occupations_table = Table('occupations', metadata,
        Column('id', Integer, primary_key=True),
        Column('name', String(20)))
    users_table = Table('users', metadata,
        Column('id', Integer, primary_key=True),
        Column('name', String(20)),
        Column('occupation_id', Integer, ForeignKey("occupations.id")))
    addresses_table = Table('addresses', metadata,
        Column('id', Integer, primary_key=True),
        Column('user_id', Integer, ForeignKey("users.id")),
        Column('street', String(50)),
        Column('city', String(40)))

    mapper(Occupation, occupations_table)
    mapper(User, users_table, properties={
        'occupation' : relation(Occupation, lazy=False),
        'addresses': relation(Address, backref='user', lazy=False)})
    mapper(Address, addresses_table)

    try:
        metadata.create_all()
    except Exception, error:
        # workaround for a problem with PySqlite < 2.6 and SQLAlchemy < 0.5
        if 'Cannot operate on a closed cursor' in str(error):
            metadata.create_all(checkfirst=False)
        else:
            raise
示例#2
0
def setup_package():
    assert os.path.exists(
        _config_file), 'Config file %s must exist' % _config_file
    load_config(configfile=_config_file)
    log_to_stream(sys.stdout, level=logging.DEBUG)
    get_engine()
    metadata.create_all()
 def setUp(self):
     """Set database configuration and set up database.
     """
     self.sa_dburi = config.get('sqlalchemy.dburi')
     set_db_uri('sqlite:///:memory:', 'sqlalchemy')
     bind_metadata()
     self.users_table = Table("users", metadata,
         Column("user_id", Integer, primary_key=True),
         Column("user_name", String(40)),
         Column("password", String(10)))
     metadata.create_all()
示例#4
0
def create_tables(drop_all=False):
    """Create all tables defined in the model in the database.

    Optionally drop existing tables before creating them.

    """
    get_engine()
    if drop_all:
        print "Dropping all database tables defined in model."
        metadata.drop_all()
    metadata.create_all()

    print "All database tables defined in model created."
示例#5
0
def create_tables(drop_all=False):
    """Create all tables defined in the model in the database.

    Optionally drop existing tables before creating them.

    """
    get_engine()
    if drop_all:
        print "Dropping all database tables defined in model."
        metadata.drop_all()
    metadata.create_all()

    print "All database tables defined in model created."
def setup_module():
    global users_table, test_table, multi_table, fresh_multi_table

    config.update({
        'sqlalchemy.dburi': 'sqlite:///:memory:',
        'fresh.dburi': 'sqlite:///freshtest.db',
    })

    if os.path.exists('freshtest.db'):
        os.unlink('freshtest.db')
    fresh_metadata = get_metadata('fresh')
    if metadata.is_bound():
        metadata.bind = None
    bind_metadata()
    metadata.bind.echo = True
    fresh_metadata.bind.echo = True

    users_table = Table("users", metadata,
        Column("user_id", Integer, primary_key=True),
        Column("user_name", String(40)),
        Column("password", String(10)))
    persons_table = Table("persons", metadata,
            Column("id", Integer, primary_key=True),
            Column("name", String(40)))
    addresses_table = Table("addresses", metadata,
            Column("id", Integer, primary_key=True),
            Column("address", String(40)),
            Column("city", String(40)),
            Column("person_id", Integer, ForeignKey(persons_table.c.id)))
    multi_table = Table('multi', metadata,
        Column('id', Integer, primary_key=True))

    metadata.create_all()

    test_table = Table("test", fresh_metadata,
        Column("id", Integer, primary_key=True),
        Column("val", String(40)))
    fresh_multi_table = Table('multi', fresh_metadata,
        Column('id', Integer, primary_key=True))

    fresh_metadata.create_all()

    mapper(User, users_table)
    mapper(Person, persons_table)
    mapper(Address, addresses_table, properties=dict(
        person=relation(Person, backref='addresses')))
    mapper(Test, test_table)

    start_server()
示例#7
0
def create(command, args):
    print "Creating tables at %s" % (config.get("sqlalchemy.dburi"))
    get_engine()
    get_model()
    metadata.create_all()
示例#8
0
文件: init.py 项目: sibiaoluo/beaker
def init_db(user_name=None, password=None, user_display_name=None, user_email_address=None):
    get_engine()
    metadata.create_all()
    session.begin()

    try:
        admin = Group.by_name(u'admin')
    except InvalidRequestError:
        admin     = Group(group_name=u'admin',display_name=u'Admin')

    try:
        lab_controller = Group.by_name(u'lab_controller')
    except InvalidRequestError:
        lab_controller = Group(group_name=u'lab_controller',
                               display_name=u'Lab Controller')
    
    #Setup User account
    if user_name:
        if password:
            user = User(user_name=user_name.decode('utf8'), password=password.decode('utf8'))
            if user_display_name:
                user.display_name = user_display_name.decode('utf8')
            if user_email_address:
                user.email_address = user_email_address.decode('utf8')
            admin.users.append(user)
        else:
            print "Password must be provided with username"
    elif len(admin.users) == 0:
        print "No admin account exists, please create one with --user"
        sys.exit(1)

    # Create distro_expire perm if not present
    try:
        distro_expire_perm = Permission.by_name(u'distro_expire')
    except NoResultFound:
        distro_expire_perm = Permission(u'distro_expire')

    # Create proxy_auth perm if not present
    try:
        proxy_auth_perm = Permission.by_name(u'proxy_auth')
    except NoResultFound:
        proxy_auth_perm = Permission(u'proxy_auth')

    # Create tag_distro perm if not present
    try:
        tag_distro_perm = Permission.by_name(u'tag_distro')
    except NoResultFound:
        tag_distro_perm = Permission(u'tag_distro')
        admin.permissions.append(tag_distro_perm)

    # Create stop_task perm if not present
    try:
        stop_task_perm = Permission.by_name(u'stop_task')
    except NoResultFound:
        stop_task_perm = Permission(u'stop_task')
        lab_controller.permissions.append(stop_task_perm)
        admin.permissions.append(stop_task_perm)

    # Create secret_visible perm if not present
    try:
        secret_visible_perm = Permission.by_name(u'secret_visible')
    except NoResultFound:
        secret_visible_perm = Permission(u'secret_visible')
        lab_controller.permissions.append(secret_visible_perm)
        admin.permissions.append(secret_visible_perm)

    #Setup Hypervisors Table
    if Hypervisor.query.count() == 0:
        kvm       = Hypervisor(hypervisor=u'KVM')
        xen       = Hypervisor(hypervisor=u'Xen')
        hyperv    = Hypervisor(hypervisor=u'HyperV')
        vmware    = Hypervisor(hypervisor=u'VMWare')

    #Setup kernel_type Table
    if KernelType.query.count() == 0:
        default  = KernelType(kernel_type=u'default', uboot=False)
        highbank = KernelType(kernel_type=u'highbank', uboot=False)
        imx      = KernelType(kernel_type=u'imx', uboot=False)
        mvebu    = KernelType(kernel_type=u'mvebu', uboot=True)
        omap     = KernelType(kernel_type=u'omap', uboot=False)
        tegra    = KernelType(kernel_type=u'tegra', uboot=False)

    #Setup base Architectures
    if Arch.query.count() == 0:
        i386   = Arch(u'i386')
        x86_64 = Arch(u'x86_64')
        ia64   = Arch(u'ia64')
        ppc    = Arch(u'ppc')
        ppc64  = Arch(u'ppc64')
        s390   = Arch(u's390')
        s390x  = Arch(u's390x')
        armhfp = Arch(u'armhfp')

    #Setup base power types
    if PowerType.query.count() == 0:
        apc_snmp    = PowerType(u'apc_snmp')
        PowerType(u'apc_snmp_then_etherwake')
        bladecenter = PowerType(u'bladecenter')
        bullpap     = PowerType(u'bladepap')
        drac        = PowerType(u'drac')
        ether_wake  = PowerType(u'ether_wake')
        PowerType(u'hyper-v')
        ilo         = PowerType(u'ilo')
        integrity   = PowerType(u'integrity')
        ipmilan     = PowerType(u'ipmilan')
        ipmitool    = PowerType(u'ipmitool')
        lpar        = PowerType(u'lpar')
        rsa         = PowerType(u'rsa')
        virsh       = PowerType(u'virsh')
        wti         = PowerType(u'wti')

    #Setup key types
    if Key.query.count() == 0:
        DISKSPACE       = Key(u'DISKSPACE',True)
        COMMENT         = Key(u'COMMENT')
        CPUFAMILY       = Key(u'CPUFAMILY',True)
        CPUFLAGS        = Key(u'CPUFLAGS')
        CPUMODEL        = Key(u'CPUMODEL')
        CPUMODELNUMBER  = Key(u'CPUMODELNUMBER', True)
        CPUSPEED        = Key(u'CPUSPEED',True)
        CPUVENDOR       = Key(u'CPUVENDOR')
        DISK            = Key(u'DISK',True)
        FORMFACTOR      = Key(u'FORMFACTOR')
        HVM             = Key(u'HVM')
        MEMORY          = Key(u'MEMORY',True)
        MODEL           = Key(u'MODEL')
        MODULE          = Key(u'MODULE')
        NETWORK         = Key(u'NETWORK')
        NR_DISKS        = Key(u'NR_DISKS',True)
        NR_ETH          = Key(u'NR_ETH',True)
        NR_IB           = Key(u'NR_IB',True)
        PCIID           = Key(u'PCIID')
        PROCESSORS      = Key(u'PROCESSORS',True)
        RTCERT          = Key(u'RTCERT')
        SCRATCH         = Key(u'SCRATCH')
        STORAGE         = Key(u'STORAGE')
        USBID           = Key(u'USBID')
        VENDOR          = Key(u'VENDOR')
        XENCERT         = Key(u'XENCERT')
        NETBOOT         = Key(u'NETBOOT_METHOD')

    #Setup ack/nak reposnses
    if Response.query.count() == 0:
        ACK      = Response(response=u'ack')
        NAK      = Response(response=u'nak')

    if RetentionTag.query.count() == 0:
        SCRATCH         = RetentionTag(tag=u'scratch', is_default=1, expire_in_days=30)
        SIXTYDAYS       = RetentionTag(tag=u'60days', needs_product=False, expire_in_days=60)
        ONETWENTYDAYS   = RetentionTag(tag=u'120days', needs_product=False, expire_in_days=120)
        ACTIVE          = RetentionTag(tag=u'active', needs_product=True)
        AUDIT           = RetentionTag(tag=u'audit', needs_product=True)

    config_items = [
        # name, description, numeric
        (u'root_password', u'Plaintext root password for provisioned systems', False),
        (u'root_password_validity', u"Maximum number of days a user's root password is valid for", True),
        (u'default_guest_memory', u"Default memory (MB) for dynamic guest provisioning", True),
        (u'default_guest_disk_size', u"Default disk size (GB) for dynamic guest provisioning", True),
        (u'guest_name_prefix', u'Prefix for names of dynamic guests in oVirt', False),
    ]
    for name, description, numeric in config_items:
        try:
            ConfigItem.by_name(name)
        except NoResultFound:
            ConfigItem(name=name, description=description, numeric=numeric)
    session.flush()
    if ConfigItem.by_name(u'root_password').current_value() is None:
        ConfigItem.by_name(u'root_password').set(u'beaker', user=admin.users[0])

    session.commit()
    session.close()
def create_tables():
    """Create tables filled with test data."""

    occupations_table = Table(
        "occupations", metadata, Column("id", Integer, primary_key=True), Column("name", String(20))
    )
    users_table = Table(
        "users",
        metadata,
        Column("id", Integer, primary_key=True),
        Column("name", String(20)),
        Column("occupation_id", Integer, ForeignKey("occupations.id")),
    )
    addresses_table = Table(
        "addresses",
        metadata,
        Column("id", Integer, primary_key=True),
        Column("user_id", Integer, ForeignKey("users.id")),
        Column("street", String(50)),
        Column("city", String(40)),
    )

    mapper(Occupation, occupations_table)
    mapper(
        User,
        users_table,
        properties={
            "occupation": relation(Occupation, lazy=False),
            "addresses": relation(Address, backref="user", lazy=False),
        },
    )
    mapper(Address, addresses_table)

    metadata.create_all()

    occupations = ({"id": 1, "name": "Doctor"}, {"id": 2, "name": "Actor"}, {"id": 3, "name": "Programmer"})
    users = (
        {"id": 1, "name": "Smith", "occupation_id": 1},
        {"id": 2, "name": "John", "occupation_id": 2},
        {"id": 3, "name": "Fred", "occupation_id": 2},
        {"id": 4, "name": "Albert", "occupation_id": 3},
        {"id": 5, "name": "Nicole", "occupation_id": None},
        {"id": 6, "name": "Sarah", "occupation_id": None},
        {"id": 7, "name": "Walter", "occupation_id": 1},
        {"id": 8, "name": "Bush", "occupation_id": None},
    )
    addresses = (
        {"id": 1, "user_id": None, "street": "street P", "city": "city X"},
        {"id": 2, "user_id": 2, "street": "street B", "city": "city Z"},
        {"id": 3, "user_id": 4, "street": "street C", "city": "city X"},
        {"id": 4, "user_id": 1, "street": "street D", "city": "city Y"},
        {"id": 5, "user_id": None, "street": "street E", "city": "city Z"},
        {"id": 6, "user_id": 1, "street": "street F", "city": "city Z"},
        {"id": 7, "user_id": 3, "street": "street G", "city": "city Y"},
        {"id": 8, "user_id": 7, "street": "street H", "city": "city Y"},
        {"id": 9, "user_id": 1, "street": "street I", "city": "city X"},
        {"id": 10, "user_id": 6, "street": "street J", "city": "city X"},
        {"id": 11, "user_id": 3, "street": "street K", "city": "city Z"},
        {"id": 12, "user_id": 2, "street": "street L", "city": "city X"},
        {"id": 13, "user_id": 8, "street": "street M", "city": "city X"},
        {"id": 14, "user_id": 5, "street": "street N", "city": "city Y"},
        {"id": 15, "user_id": 1, "street": "street O", "city": "city Y"},
        {"id": 16, "user_id": 3, "street": "street A", "city": "city X"},
    )

    metadata.bind.execute(occupations_table.insert(), occupations)
    metadata.bind.execute(users_table.insert(), users)
    metadata.bind.execute(addresses_table.insert(), addresses)

    SOAddress.createTable()

    # SQLObject tests will need only "addresses"
    for kw in addresses:
        SOAddress(**kw)
示例#10
0
def create(command, args):
    print "Creating tables at %s" % (config.get("sqlalchemy.dburi"))
    get_engine()
    get_model()
    metadata.create_all()
示例#11
0
def setup_module():
    global fresh_metadata, users_table, test_table, Person, Address, Test

    config.update({
        "sqlalchemy.dburi" : "sqlite:///:memory:"})

    if os.path.exists('freshtest.db'):
        os.unlink('freshtest.db')

    get_engine()
    fresh_metadata = MetaData()
    # :memory: can't be used in multiple threads
    fresh_metadata.bind = 'sqlite:///freshtest.db'
    metadata.bind.echo = True
    fresh_metadata.bind.echo = True

    users_table = Table("users", metadata,
        Column("user_id", Integer, primary_key=True),
        Column("user_name", String(40)),
        Column("password", String(10)))

    mapper(User, users_table)

    if ActiveMapper:

        class Person(ActiveMapper):
            class mapping:
                id = column(Integer, primary_key=True)
                name = column(String(40))
                addresses = one_to_many("Address")

        class Address(ActiveMapper):
            class mapping:
                id = column(Integer, primary_key=True)
                address = column(String(40))
                city = column(String(40))
                person_id = column(Integer,
                    foreign_key=ForeignKey("person.id"))

    else:

        persons_table = Table("persons", metadata,
                Column("id", Integer, primary_key=True),
                Column("name", String(40)))
        addresses_table = Table("addresses", metadata,
                Column("id", Integer, primary_key=True),
                Column("address", String(40)),
                Column("city", String(40)),
                Column("person_id", Integer,
                    ForeignKey(persons_table.c.id)))

        class Person(object):
            pass

        class Address(object):
            pass

        mapper(Person, persons_table)
        mapper(Address, addresses_table, properties=dict(
            person=relation(Person, backref='addresses')))

    test_table = Table("test", fresh_metadata,
        Column("id", Integer, primary_key=True),
        Column("val", String(40)))

    class Test(object):
        pass

    mapper(Test, test_table)

    try:
        metadata.create_all()
        fresh_metadata.create_all()
    except Exception, error:
        # workaround for a problem with PySqlite < 2.6 and SQLAlchemy < 0.5
        if 'Cannot operate on a closed cursor' in str(error):
            metadata.create_all(checkfirst=False)
            fresh_metadata.create_all(checkfirst=False)
        else:
            raise
示例#12
0
文件: base.py 项目: thraxil/gtreed
def sacreate(command, args):
    print "Creating tables at %s" % (config.get("sqlalchemy.dburi"))
    from turbogears.database import bind_meta_data, metadata
    bind_meta_data()
    get_model()
    metadata.create_all()
示例#13
0
def setup_package():
    assert os.path.exists(_config_file), "Config file %s must exist" % _config_file
    load_config(configfile=_config_file)
    log_to_stream(sys.stdout, level=logging.DEBUG)
    get_engine()
    metadata.create_all()
示例#14
0
def setup_module():
    global fresh_metadata, users_table, test_table, Person, Address, Test

    config.update({"sqlalchemy.dburi": "sqlite:///:memory:"})

    if os.path.exists('freshtest.db'):
        os.unlink('freshtest.db')

    get_engine()
    fresh_metadata = MetaData()
    # :memory: can't be used in multiple threads
    fresh_metadata.bind = 'sqlite:///freshtest.db'
    metadata.bind.echo = True
    fresh_metadata.bind.echo = True

    users_table = Table("users", metadata,
                        Column("user_id", Integer, primary_key=True),
                        Column("user_name", String(40)),
                        Column("password", String(10)))

    mapper(User, users_table)

    if ActiveMapper:

        class Person(ActiveMapper):
            class mapping:
                id = column(Integer, primary_key=True)
                name = column(String(40))
                addresses = one_to_many("Address")

        class Address(ActiveMapper):
            class mapping:
                id = column(Integer, primary_key=True)
                address = column(String(40))
                city = column(String(40))
                person_id = column(Integer,
                                   foreign_key=ForeignKey("person.id"))

    else:

        persons_table = Table("persons", metadata,
                              Column("id", Integer, primary_key=True),
                              Column("name", String(40)))
        addresses_table = Table(
            "addresses", metadata, Column("id", Integer, primary_key=True),
            Column("address", String(40)), Column("city", String(40)),
            Column("person_id", Integer, ForeignKey(persons_table.c.id)))

        class Person(object):
            pass

        class Address(object):
            pass

        mapper(Person, persons_table)
        mapper(Address,
               addresses_table,
               properties=dict(person=relation(Person, backref='addresses')))

    test_table = Table("test", fresh_metadata,
                       Column("id", Integer, primary_key=True),
                       Column("val", String(40)))

    class Test(object):
        pass

    mapper(Test, test_table)

    try:
        metadata.create_all()
        fresh_metadata.create_all()
    except Exception, error:
        # workaround for a problem with PySqlite < 2.6 and SQLAlchemy < 0.5
        if 'Cannot operate on a closed cursor' in str(error):
            metadata.create_all(checkfirst=False)
            fresh_metadata.create_all(checkfirst=False)
        else:
            raise
示例#15
0
文件: init.py 项目: ustbgaofan/beaker
def init_db(user_name=None, password=None, user_display_name=None, user_email_address=None):
    get_engine()
    metadata.create_all()
    session.begin()

    try:
        admin = Group.by_name(u'admin')
    except InvalidRequestError:
        admin     = Group(group_name=u'admin',display_name=u'Admin')
        session.add(admin)

    try:
        lab_controller = Group.by_name(u'lab_controller')
    except InvalidRequestError:
        lab_controller = Group(group_name=u'lab_controller',
                               display_name=u'Lab Controller')
        session.add(lab_controller)

    #Setup User account
    if user_name:
        if password:
            user = User(user_name=user_name.decode('utf8'), password=password.decode('utf8'))
            if user_display_name:
                user.display_name = user_display_name.decode('utf8')
            if user_email_address:
                user.email_address = user_email_address.decode('utf8')
            admin.users.append(user)
        else:
            print "Password must be provided with username"
    elif len(admin.users) == 0:
        print "No admin account exists, please create one with --user"
        sys.exit(1)

    # Create distro_expire perm if not present
    try:
        distro_expire_perm = Permission.by_name(u'distro_expire')
    except NoResultFound:
        distro_expire_perm = Permission(u'distro_expire')
        session.add(distro_expire_perm)

    # Create proxy_auth perm if not present
    try:
        proxy_auth_perm = Permission.by_name(u'proxy_auth')
    except NoResultFound:
        proxy_auth_perm = Permission(u'proxy_auth')
        session.add(proxy_auth_perm)

    # Create tag_distro perm if not present
    try:
        tag_distro_perm = Permission.by_name(u'tag_distro')
    except NoResultFound:
        tag_distro_perm = Permission(u'tag_distro')
        admin.permissions.append(tag_distro_perm)

    # Create stop_task perm if not present
    try:
        stop_task_perm = Permission.by_name(u'stop_task')
    except NoResultFound:
        stop_task_perm = Permission(u'stop_task')
        lab_controller.permissions.append(stop_task_perm)
        admin.permissions.append(stop_task_perm)

    # Create secret_visible perm if not present
    try:
        secret_visible_perm = Permission.by_name(u'secret_visible')
    except NoResultFound:
        secret_visible_perm = Permission(u'secret_visible')
        lab_controller.permissions.append(secret_visible_perm)
        admin.permissions.append(secret_visible_perm)

    #Setup Hypervisors Table
    if Hypervisor.query.count() == 0:
        for h in [u'KVM', u'Xen', u'HyperV', u'VMWare']:
            session.add(Hypervisor(hypervisor=h))

    #Setup kernel_type Table
    if KernelType.query.count() == 0:
        for type in [u'default', u'highbank', u'imx', u'omap', u'tegra']:
            session.add(KernelType(kernel_type=type, uboot=False))
        for type in [u'mvebu']:
            session.add(KernelType(kernel_type=type, uboot=True))

    #Setup base Architectures
    if Arch.query.count() == 0:
        for arch in [u'i386', u'x86_64', u'ia64', u'ppc', u'ppc64',
                u's390', u's390x', u'armhfp']:
            session.add(Arch(arch))

    #Setup base power types
    if PowerType.query.count() == 0:
        for power_type in [u'apc_snmp', u'apc_snmp_then_etherwake',
                u'bladecenter', u'bladepap', u'drac', u'ether_wake', u'hyper-v',
                u'ilo', u'integrity', u'ipmilan', u'ipmitool', u'lpar', u'rsa',
                u'virsh', u'wti']:
            session.add(PowerType(power_type))

    #Setup key types
    if Key.query.count() == 0:
        session.add(Key(u'DISKSPACE',True))
        session.add(Key(u'COMMENT'))
        session.add(Key(u'CPUFAMILY',True))
        session.add(Key(u'CPUFLAGS'))
        session.add(Key(u'CPUMODEL'))
        session.add(Key(u'CPUMODELNUMBER', True))
        session.add(Key(u'CPUSPEED',True))
        session.add(Key(u'CPUVENDOR'))
        session.add(Key(u'DISK',True))
        session.add(Key(u'FORMFACTOR'))
        session.add(Key(u'HVM'))
        session.add(Key(u'MEMORY',True))
        session.add(Key(u'MODEL'))
        session.add(Key(u'MODULE'))
        session.add(Key(u'NETWORK'))
        session.add(Key(u'NR_DISKS',True))
        session.add(Key(u'NR_ETH',True))
        session.add(Key(u'NR_IB',True))
        session.add(Key(u'PCIID'))
        session.add(Key(u'PROCESSORS',True))
        session.add(Key(u'RTCERT'))
        session.add(Key(u'SCRATCH'))
        session.add(Key(u'STORAGE'))
        session.add(Key(u'USBID'))
        session.add(Key(u'VENDOR'))
        session.add(Key(u'XENCERT'))
        session.add(Key(u'NETBOOT_METHOD'))

    #Setup ack/nak reposnses
    if Response.query.count() == 0:
        session.add(Response(response=u'ack'))
        session.add(Response(response=u'nak'))

    if RetentionTag.query.count() == 0:
        session.add(RetentionTag(tag=u'scratch', is_default=1, expire_in_days=30))
        session.add(RetentionTag(tag=u'60days', needs_product=False, expire_in_days=60))
        session.add(RetentionTag(tag=u'120days', needs_product=False, expire_in_days=120))
        session.add(RetentionTag(tag=u'active', needs_product=True))
        session.add(RetentionTag(tag=u'audit', needs_product=True))

    config_items = [
        # name, description, numeric
        (u'root_password', u'Plaintext root password for provisioned systems', False),
        (u'root_password_validity', u"Maximum number of days a user's root password is valid for", True),
        (u'default_guest_memory', u"Default memory (MB) for dynamic guest provisioning", True),
        (u'default_guest_disk_size', u"Default disk size (GB) for dynamic guest provisioning", True),
        (u'guest_name_prefix', u'Prefix for names of dynamic guests in oVirt', False),
    ]
    for name, description, numeric in config_items:
        ConfigItem.lazy_create(name=name, description=description, numeric=numeric)
    if ConfigItem.by_name(u'root_password').current_value() is None:
        ConfigItem.by_name(u'root_password').set(u'beaker', user=admin.users[0])

    session.commit()
    session.close()